ActiveDeveloper Productivity / LLM Tooling / Monorepo Architecture• Technical Overview

LogMyCode

Turn Messy Daily Git Commits into Clean Standup Reports in 5 Seconds

What it is

LogMyCode is a VS Code extension that solves 'end-of-day amnesia' for developers working across multiple repositories. With a single keyboard shortcut, it scans your local Git history, combines your commits with quick meeting notes, and uses Groq's Llama-3.3-70B to generate clean daily standup updates formatted for Slack or Jira in under 800ms.

Tech Stack

Frontend

VS Code Extension APIWebview PanelTypeScriptTailwind CSS

Backend

Express.jsZod ValidationNode.js Child ProcessTypeScript

Database & Cache

NeonDB Serverless PostgreSQLDrizzle ORM

AI & Cloud

Groq Cloud LPULlama-3.3-70B-VersatileVercel Serverless

System Architecture

System Architecture Sketch

Whiteboard architecture • Click any box to inspect

Tier 1: Developer Client (VS Code)

Local IPC / Pipes

Tier 2: Backend API & Prompt Synthesis

HTTPS REST

Tier 3: Cloud Inference & Persistence

VS Code Webview UIClient

Component Role

Embedded editor sidebar that displays detected commits, accepts quick meeting notes, and renders formatted standup bullets.

Core Engineering Highlight

Concurrent Multi-Repo Git Scraping & Sub-800ms Synthesis

Parsing local commit logs across microservices with zero network latency.

Modern engineers work across multiple repositories concurrently (e.g. backend API, web client, shared UI package). LogMyCode triggers concurrent child-process streams across all registered workspace roots, executing `git log --no-merges` locally. It deduplicates cherry-picks, strips sensitive internal disk paths, and passes sanitized summaries to Groq's Llama-3.3-70B—delivering polished standup bullets in under 800ms.

How it works & Technical Depth:

Concurrent local scanning: Child processes extract diffs and commits across all open workspaces in parallel.

Zero network leakage of source code: Only commit message metadata and masked file summaries leave the machine.

Sub-800ms end-to-end latency: Leverages Groq hardware-accelerated LPUs for instantaneous standup generation.

One-click export: Directly formatted for Slack, Jira, or Scrum with a single clipboard copy.

extension/src/gitService.ts (Concurrent Workspace Scanner)typescript

import { exec } from "child_process";
import { promisify } from "util";

const execAsync = promisify(exec);

export async function scanWorkspaceRepositories(workspacePaths: string[]): Promise<ParsedCommit[]> {
  // Concurrently scan all active repositories in parallel
  const repoPromises = workspacePaths.map(async (repoPath) => {
    try {
      const gitCmd = 'git log --no-merges --since="24 hours ago" --pretty=format:"%H|%an|%s|%cI"';
      const { stdout } = await execAsync(gitCmd, { cwd: repoPath, timeout: 2500 });
      
      return stdout.split("\n")
        .filter(Boolean)
        .map(line => {
          const [hash, author, message, date] = line.split("|");
          return { hash: hash.substring(0, 7), author, message, date, repository: repoPath.split("/").pop() };
        });
    } catch {
      return []; // Gracefully skip uninitialized or non-git folders
    }
  });

  const results = await Promise.all(repoPromises);
  return results.flat().sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
}

Key Challenges & Trade-offs

Hurdle #1

Filtering Daily Commit Noise into Executive Standups

The Bottleneck:

Daily Git logs are filled with noisy messages like 'fix typo', 'wip auth', and 'temp test' that look sloppy in formal engineering standups.

The Engineered Solution:

Engineered an Agile synthesis prompt that groups related commits by functional subsystem and correlates them with developer offline meeting notes, producing clear accomplishment bullets.

Takeaway: Good developer tools bridge the gap between low-level Git activity and high-level team communication.

Hurdle #2

Zero-Latency Extension UX

The Bottleneck:

Waiting 4–6 seconds for traditional LLM cloud APIs broke the developer's editing flow inside VS Code.

The Engineered Solution:

Switched to Groq LPU hardware acceleration, reducing response times from ~4500ms down to ~750ms.

Takeaway: In developer workflows, sub-second latency is the difference between daily habit and abandonment.

Back to all projects View project repository on GitHub