vibe-coding-master 0.0.5 → 0.0.7

package/dist/backend/services/claude-transcript-service.js

@@ -0,0 +1,509 @@
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync, watch as fsWatch } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_TAIL_POLL_INTERVAL_MS = 500;
+/**
+ * Adapted from CodingForMoney/cc-pm's transcript tailer.
+ *
+ * Claude Code writes semantic JSONL events under ~/.claude/projects. Tailing
+ * those files is much more reliable than trying to infer answer boundaries
+ * from the terminal TUI's raw PTY output.
+ */
+export class TranscriptTail {
+    path;
+    handlers;
+    offset = 0;
+    buffer = "";
+    watcher = null;
+    pollTimer = null;
+    flushing = false;
+    flushScheduled = false;
+    constructor(path, handlers) {
+        this.path = path;
+        this.handlers = handlers;
+    }
+    start(opts) {
+        if (!existsSync(this.path)) {
+            throw new Error(`transcript not found: ${this.path}`);
+        }
+        const stat = statSync(this.path);
+        if (opts?.replaySince) {
+            this.replaySince(opts.replaySince);
+        }
+        else if (opts?.replayLastN && opts.replayLastN > 0) {
+            this.replayHistory(opts.replayLastN);
+        }
+        this.offset = stat.size;
+        this.buffer = "";
+        try {
+            this.watcher = fsWatch(this.path, () => {
+                this.scheduleFlush();
+            });
+        }
+        catch {
+            this.watcher = null;
+        }
+        this.pollTimer = setInterval(() => {
+            this.scheduleFlush();
+        }, opts?.pollIntervalMs ?? DEFAULT_TAIL_POLL_INTERVAL_MS);
+        this.scheduleFlush();
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    scheduleFlush() {
+        if (this.flushing || this.flushScheduled) {
+            return;
+        }
+        this.flushScheduled = true;
+        setImmediate(() => {
+            this.flushScheduled = false;
+            this.flush();
+        });
+    }
+    flush() {
+        if (this.flushing) {
+            return;
+        }
+        this.flushing = true;
+        try {
+            const stat = statSync(this.path);
+            if (stat.size < this.offset) {
+                this.offset = stat.size;
+                this.buffer = "";
+                return;
+            }
+            if (stat.size === this.offset) {
+                return;
+            }
+            const toRead = stat.size - this.offset;
+            const fd = openSync(this.path, "r");
+            try {
+                const buf = Buffer.alloc(toRead);
+                readSync(fd, buf, 0, toRead, this.offset);
+                this.offset = stat.size;
+                this.buffer += buf.toString("utf-8");
+            }
+            finally {
+                closeSync(fd);
+            }
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    this.tryEmit(line);
+                }
+            }
+        }
+        catch (error) {
+            this.handlers.onError?.(error);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    replayHistory(n) {
+        try {
+            const text = readFileSync(this.path, "utf-8");
+            const events = [];
+            for (const line of text.split("\n")) {
+                if (line.trim()) {
+                    events.push(...parseAssistantContent(line));
+                }
+            }
+            for (const event of events.slice(-n)) {
+                this.handlers.onContent(event);
+            }
+        }
+        catch (error) {
+            this.handlers.onError?.(error);
+        }
+    }
+    replaySince(replaySince) {
+        const sinceMs = Date.parse(replaySince);
+        if (!Number.isFinite(sinceMs)) {
+            return;
+        }
+        try {
+            const text = readFileSync(this.path, "utf-8");
+            for (const line of text.split("\n")) {
+                if (!line.trim()) {
+                    continue;
+                }
+                for (const event of parseAssistantContent(line)) {
+                    const eventMs = Date.parse(event.timestamp);
+                    if (Number.isFinite(eventMs) && eventMs >= sinceMs) {
+                        this.handlers.onContent(event);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.handlers.onError?.(error);
+        }
+    }
+    tryEmit(line) {
+        for (const event of parseAssistantContent(line)) {
+            this.handlers.onContent(event);
+        }
+    }
+}
+export function createClaudeTranscriptService() {
+    return {
+        subscribeToRoleSession(session, listener, options = {}) {
+            let tail;
+            let retryTimer;
+            let stopped = false;
+            const start = () => {
+                if (stopped) {
+                    return;
+                }
+                const transcriptPath = resolveExistingClaudeTranscriptPath(session);
+                if (!transcriptPath) {
+                    retryTimer = setTimeout(start, 500);
+                    return;
+                }
+                try {
+                    tail = new TranscriptTail(transcriptPath, {
+                        onContent: listener,
+                        onError: options.onError
+                    });
+                    tail.start({
+                        replayLastN: options.replayLastN,
+                        replaySince: options.replaySince
+                    });
+                    options.onTranscriptPathResolved?.(transcriptPath);
+                }
+                catch (error) {
+                    options.onError?.(error);
+                    tail?.stop();
+                    tail = undefined;
+                    retryTimer = setTimeout(start, 500);
+                }
+            };
+            start();
+            return () => {
+                stopped = true;
+                if (retryTimer) {
+                    clearTimeout(retryTimer);
+                }
+                tail?.stop();
+            };
+        }
+    };
+}
+export function resolveExistingClaudeTranscriptPath(session) {
+    const sessionPath = existingFile(session.transcriptPath);
+    if (sessionPath) {
+        return sessionPath;
+    }
+    const cwdPath = existingFile(claudeTranscriptPath(session.cwd, session.claudeSessionId));
+    if (cwdPath) {
+        return cwdPath;
+    }
+    return findClaudeTranscriptPathBySessionId(session.claudeSessionId);
+}
+export function findClaudeTranscriptPathBySessionId(claudeSessionId) {
+    const root = claudeProjectsRoot();
+    let projectDirs;
+    try {
+        projectDirs = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    const matches = [];
+    for (const dirent of projectDirs) {
+        if (!dirent.isDirectory()) {
+            continue;
+        }
+        const candidate = existingFile(join(root, dirent.name, `${claudeSessionId}.jsonl`));
+        if (!candidate) {
+            continue;
+        }
+        try {
+            matches.push({ path: candidate, mtimeMs: statSync(candidate).mtimeMs });
+        }
+        catch {
+            // Ignore files that disappear while scanning Claude's transcript folder.
+        }
+    }
+    matches.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return matches[0]?.path;
+}
+function existingFile(candidate) {
+    if (!candidate) {
+        return undefined;
+    }
+    try {
+        return statSync(candidate).isFile() ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function claudeProjectsRoot() {
+    return join(homedir(), ".claude", "projects");
+}
+export function projectHash(projectDir) {
+    return projectDir.replace(/[\/\s]+/g, "-");
+}
+export function projectsTranscriptDir(projectDir) {
+    return join(claudeProjectsRoot(), projectHash(projectDir));
+}
+export function claudeTranscriptPath(projectDir, claudeSessionId) {
+    return join(projectsTranscriptDir(projectDir), `${claudeSessionId}.jsonl`);
+}
+export function parseAssistantContent(line) {
+    let obj;
+    try {
+        obj = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (obj.type === "user") {
+        return parseUserToolResults(obj);
+    }
+    if (obj.type !== "assistant") {
+        return [];
+    }
+    const message = obj.message;
+    const content = message?.content;
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const textParts = [];
+    const thinkingParts = [];
+    const questions = [];
+    const todos = [];
+    const agents = [];
+    const rawTools = [];
+    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : new Date().toISOString();
+    const uuid = typeof obj.uuid === "string" ? obj.uuid : undefined;
+    const rawStopReason = message?.stop_reason;
+    const stopReason = typeof rawStopReason === "string" ? rawStopReason : undefined;
+    for (const entry of content) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const block = entry;
+        if (block.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+            textParts.push(block.text);
+            continue;
+        }
+        if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.length > 0) {
+            thinkingParts.push(block.thinking);
+            continue;
+        }
+        if (block.type !== "tool_use") {
+            continue;
+        }
+        const toolId = typeof block.id === "string" ? block.id : undefined;
+        const toolName = typeof block.name === "string" ? block.name : undefined;
+        if (!toolId || !toolName) {
+            continue;
+        }
+        if (toolName === "AskUserQuestion") {
+            const payload = parseQuestionInput(block.input);
+            if (payload) {
+                questions.push({ id: toolId, payload });
+            }
+        }
+        else if (toolName === "TodoWrite") {
+            const payload = parseTodoInput(block.input);
+            if (payload) {
+                todos.push({ id: toolId, payload });
+            }
+        }
+        else if (toolName === "Agent" || toolName === "Task") {
+            const payload = parseAgentInput(block.input);
+            if (payload) {
+                agents.push({ id: toolId, payload });
+            }
+        }
+        else {
+            rawTools.push({
+                id: toolId,
+                payload: { name: toolName, input: block.input }
+            });
+        }
+    }
+    const out = [];
+    if (textParts.length > 0) {
+        const text = textParts.join("\n\n");
+        out.push({
+            kind: "text",
+            timestamp,
+            text,
+            id: uuid ?? `${timestamp}-${text.slice(0, 16)}`,
+            ...(stopReason !== undefined ? { stopReason } : {})
+        });
+    }
+    if (thinkingParts.length > 0) {
+        const text = thinkingParts.join("\n\n");
+        out.push({
+            kind: "thinking",
+            timestamp,
+            text,
+            id: uuid ? `${uuid}#thinking` : `${timestamp}-thinking-${text.slice(0, 16)}`,
+            ...(stopReason !== undefined ? { stopReason } : {})
+        });
+    }
+    for (const question of questions) {
+        out.push({
+            kind: "question",
+            timestamp,
+            id: question.id,
+            question: question.payload
+        });
+    }
+    for (const todo of todos) {
+        out.push({
+            kind: "todo",
+            timestamp,
+            id: todo.id,
+            todo: todo.payload
+        });
+    }
+    for (const agent of agents) {
+        out.push({
+            kind: "agent",
+            timestamp,
+            id: agent.id,
+            agent: agent.payload
+        });
+    }
+    for (const tool of rawTools) {
+        out.push({
+            kind: "tool_use",
+            timestamp,
+            id: tool.id,
+            toolUse: tool.payload
+        });
+    }
+    return out;
+}
+function parseUserToolResults(obj) {
+    const message = obj.message;
+    const content = message?.content;
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : new Date().toISOString();
+    const out = [];
+    for (const entry of content) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const block = entry;
+        if (block.type !== "tool_result") {
+            continue;
+        }
+        const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
+        if (!toolUseId) {
+            continue;
+        }
+        out.push({
+            kind: "tool_result",
+            timestamp,
+            id: `${toolUseId}#result`,
+            toolResult: {
+                tool_use_id: toolUseId,
+                content: block.content,
+                isError: block.is_error === true
+            }
+        });
+    }
+    return out;
+}
+function parseQuestionInput(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const rawQuestions = raw.questions;
+    if (!Array.isArray(rawQuestions) || rawQuestions.length === 0) {
+        return null;
+    }
+    const questions = [];
+    for (const rawQuestion of rawQuestions) {
+        if (!rawQuestion || typeof rawQuestion !== "object") {
+            continue;
+        }
+        const questionRecord = rawQuestion;
+        const rawOptions = questionRecord.options;
+        if (!Array.isArray(rawOptions) || rawOptions.length === 0) {
+            continue;
+        }
+        const options = [];
+        for (const rawOption of rawOptions) {
+            if (!rawOption || typeof rawOption !== "object") {
+                continue;
+            }
+            const optionRecord = rawOption;
+            const option = {
+                label: typeof optionRecord.label === "string" ? optionRecord.label : "",
+                description: typeof optionRecord.description === "string" ? optionRecord.description : ""
+            };
+            if (typeof optionRecord.preview === "string") {
+                option.preview = optionRecord.preview;
+            }
+            options.push(option);
+        }
+        if (options.length > 0) {
+            questions.push({
+                question: typeof questionRecord.question === "string" ? questionRecord.question : "",
+                header: typeof questionRecord.header === "string" ? questionRecord.header : "",
+                multiSelect: questionRecord.multiSelect === true,
+                options
+            });
+        }
+    }
+    return questions.length > 0 ? { questions } : null;
+}
+function parseTodoInput(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const rawTodos = raw.todos;
+    if (!Array.isArray(rawTodos) || rawTodos.length === 0) {
+        return null;
+    }
+    const todos = [];
+    for (const rawTodo of rawTodos) {
+        if (!rawTodo || typeof rawTodo !== "object") {
+            continue;
+        }
+        const todoRecord = rawTodo;
+        const content = typeof todoRecord.content === "string" ? todoRecord.content : "";
+        const activeForm = typeof todoRecord.activeForm === "string" ? todoRecord.activeForm : "";
+        const rawStatus = todoRecord.status;
+        const status = rawStatus === "in_progress" || rawStatus === "completed"
+            ? rawStatus
+            : "pending";
+        if (content || activeForm) {
+            todos.push({ content, activeForm, status });
+        }
+    }
+    return todos.length > 0 ? { todos } : null;
+}
+function parseAgentInput(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const record = raw;
+    const description = typeof record.description === "string" ? record.description : "";
+    const prompt = typeof record.prompt === "string" ? record.prompt : "";
+    const subagent_type = typeof record.subagent_type === "string" ? record.subagent_type : "";
+    if (!description && !prompt) {
+        return null;
+    }
+    return { description, prompt, subagent_type };
+}

package/dist/backend/services/harness-service.js

@@ -0,0 +1,178 @@
+import path from "node:path";
+import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
+import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
+import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
+import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
+import { renderReviewerHarnessRules } from "../templates/harness/reviewer-agent.js";
+export const VCM_HARNESS_VERSION = 1;
+const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
+const HARNESS_FILES = [
+    {
+        kind: "root-claude",
+        path: "CLAUDE.md",
+        title: "CLAUDE.md",
+        renderRules: renderRootClaudeHarnessRules
+    },
+    {
+        kind: "agent-project-manager",
+        path: ".claude/agents/project-manager.md",
+        title: "Project Manager Agent",
+        frontmatter: renderAgentFrontmatter("project-manager", "User-facing VCM orchestration role for task clarification, role routing, handoffs, acceptance, and PR preparation."),
+        renderRules: renderProjectManagerHarnessRules
+    },
+    {
+        kind: "agent-architect",
+        path: ".claude/agents/architect.md",
+        title: "Architect Agent",
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, test contracts, and post-review docs sync."),
+        renderRules: renderArchitectHarnessRules
+    },
+    {
+        kind: "agent-coder",
+        path: ".claude/agents/coder.md",
+        title: "Coder Agent",
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes, focused tests, implementation logs, and validation evidence."),
+        renderRules: renderCoderHarnessRules
+    },
+    {
+        kind: "agent-reviewer",
+        path: ".claude/agents/reviewer.md",
+        title: "Reviewer Agent",
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent review role for acceptance, test adequacy, scope checks, docs gaps, and risk findings."),
+        renderRules: renderReviewerHarnessRules
+    }
+];
+export function createHarnessService(deps) {
+    return {
+        async getHarnessStatus(repoRoot) {
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            return renderHarnessStatus(analyses);
+        },
+        async applyHarness(repoRoot) {
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            const changedFiles = [];
+            for (const analysis of analyses) {
+                if (analysis.status.action === "ok" || !analysis.nextContent) {
+                    continue;
+                }
+                await deps.fs.writeText(resolveHarnessPath(repoRoot, analysis.definition.path), analysis.nextContent);
+                if (analysis.plannedChange) {
+                    changedFiles.push(analysis.plannedChange);
+                }
+            }
+            return {
+                version: VCM_HARNESS_VERSION,
+                changedFiles,
+                message: changedFiles.length === 0
+                    ? "VCM Harness is already up to date."
+                    : "VCM Harness updated. Review these files and commit the harness changes before starting long-running work."
+            };
+        }
+    };
+}
+async function analyzeHarnessFiles(fs, repoRoot) {
+    const analyses = [];
+    for (const definition of HARNESS_FILES) {
+        analyses.push(await analyzeHarnessFile(fs, repoRoot, definition));
+    }
+    return analyses;
+}
+async function analyzeHarnessFile(fs, repoRoot, definition) {
+    const absolutePath = resolveHarnessPath(repoRoot, definition.path);
+    const expectedBlock = renderManagedBlock(definition.renderRules());
+    const exists = await fs.pathExists(absolutePath);
+    if (!exists) {
+        return {
+            definition,
+            status: {
+                kind: definition.kind,
+                path: definition.path,
+                exists: false,
+                hasManagedBlock: false,
+                action: "create"
+            },
+            plannedChange: {
+                path: definition.path,
+                action: "create",
+                reason: "File is missing; VCM will create a recommended default."
+            },
+            nextContent: renderNewHarnessFile(definition, expectedBlock)
+        };
+    }
+    const currentContent = await fs.readText(absolutePath);
+    const match = currentContent.match(MANAGED_BLOCK_PATTERN);
+    if (!match) {
+        return {
+            definition,
+            status: {
+                kind: definition.kind,
+                path: definition.path,
+                exists: true,
+                hasManagedBlock: false,
+                action: "insert"
+            },
+            plannedChange: {
+                path: definition.path,
+                action: "insert",
+                reason: "File exists but does not contain VCM managed rules."
+            },
+            nextContent: `${currentContent.trimEnd()}\n\n${expectedBlock}\n`
+        };
+    }
+    const managedVersion = match[1] ? Number(match[1]) : undefined;
+    const currentBlock = match[0];
+    const action = currentBlock === expectedBlock ? "ok" : "update";
+    return {
+        definition,
+        status: {
+            kind: definition.kind,
+            path: definition.path,
+            exists: true,
+            hasManagedBlock: true,
+            managedVersion,
+            action
+        },
+        plannedChange: action === "ok"
+            ? undefined
+            : {
+                path: definition.path,
+                action,
+                reason: managedVersion === VCM_HARNESS_VERSION
+                    ? "VCM managed rules differ from the current recommended template."
+                    : `VCM managed block version is ${managedVersion ?? "missing"}; current version is ${VCM_HARNESS_VERSION}.`
+            },
+        nextContent: action === "ok"
+            ? undefined
+            : currentContent.replace(MANAGED_BLOCK_PATTERN, expectedBlock)
+    };
+}
+function renderHarnessStatus(analyses) {
+    const files = analyses.map((analysis) => analysis.status);
+    const plannedChanges = analyses
+        .map((analysis) => analysis.plannedChange)
+        .filter((change) => Boolean(change));
+    return {
+        version: VCM_HARNESS_VERSION,
+        files,
+        needsApply: plannedChanges.length > 0,
+        plannedChanges,
+        warnings: plannedChanges.length > 0
+            ? ["Review and commit VCM Harness changes before starting long-running work."]
+            : []
+    };
+}
+function renderManagedBlock(rules) {
+    return `<!-- VCM:BEGIN version=${VCM_HARNESS_VERSION} -->\n${rules.trimEnd()}\n<!-- VCM:END -->`;
+}
+function renderNewHarnessFile(definition, block) {
+    const frontmatter = definition.frontmatter
+        ? `${definition.frontmatter.trimEnd()}\n\n`
+        : "";
+    return `${frontmatter}# ${definition.title}\n\n${block}\n`;
+}
+function renderAgentFrontmatter(name, description) {
+    return `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---`;
+}
+function resolveHarnessPath(repoRoot, relativePath) {
+    return path.join(repoRoot, relativePath);
+}

package/dist/backend/services/project-service.js

@@ -59,11 +59,15 @@ export function createProjectService(deps) {
                 config,
                 warnings
             };
+            await deps.appSettings.recordRecentRepositoryPath(repoRoot);
             return currentProject;
         },
         async getCurrentProject() {
             return currentProject;
         },
+        async getRecentRepositoryPaths() {
+            return deps.appSettings.getRecentRepositoryPaths();
+        },
         async loadConfig(repoRoot) {
             const configPath = this.getConfigPath(repoRoot);
             if (!(await deps.fs.pathExists(configPath))) {