@phren/cli 0.0.27 → 0.0.32

package/mcp/dist/cli-hooks-git.js

@@ -0,0 +1,243 @@
+import { debugLog, EXEC_TIMEOUT_MS, withFileLock, recordFeedback, getQualityMultiplier, errorMessage, } from "./cli/hooks-context.js";
+import { sessionMetricsFile, } from "./shared.js";
+import { autoMergeConflicts, mergeTask, mergeFindings, } from "./shared/content.js";
+import { runGit } from "./utils.js";
+import { isTaskFileName } from "./data/tasks.js";
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import { fileURLToPath } from "url";
+export function getGitContext(cwd) {
+    if (!cwd)
+        return null;
+    const git = (args) => runGit(cwd, args, EXEC_TIMEOUT_MS, debugLog);
+    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (!branch)
+        return null;
+    const changedFiles = new Set();
+    for (const changed of [
+        git(["diff", "--name-only"]),
+        git(["diff", "--name-only", "--cached"]),
+    ]) {
+        if (!changed)
+            continue;
+        for (const line of changed.split("\n").map((s) => s.trim()).filter(Boolean)) {
+            changedFiles.add(line);
+            const basename = path.basename(line);
+            if (basename)
+                changedFiles.add(basename);
+        }
+    }
+    return { branch, changedFiles };
+}
+export function parseSessionMetrics(phrenPathLocal) {
+    const file = sessionMetricsFile(phrenPathLocal);
+    if (!fs.existsSync(file))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        debugLog(`parseSessionMetrics: failed to read ${file}: ${errorMessage(err)}`);
+        return {};
+    }
+}
+export function writeSessionMetrics(phrenPathLocal, data) {
+    const file = sessionMetricsFile(phrenPathLocal);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+}
+export function updateSessionMetrics(phrenPathLocal, updater) {
+    const file = sessionMetricsFile(phrenPathLocal);
+    withFileLock(file, () => {
+        const metrics = parseSessionMetrics(phrenPathLocal);
+        updater(metrics);
+        writeSessionMetrics(phrenPathLocal, metrics);
+    });
+}
+export function trackSessionMetrics(phrenPathLocal, sessionId, selected) {
+    updateSessionMetrics(phrenPathLocal, (metrics) => {
+        if (!metrics[sessionId])
+            metrics[sessionId] = { prompts: 0, keys: {}, lastChangedCount: 0, lastKeys: [] };
+        metrics[sessionId].prompts += 1;
+        const injectedKeys = [];
+        for (const injected of selected) {
+            injectedKeys.push(injected.key);
+            const key = injected.key;
+            const seen = metrics[sessionId].keys[key] || 0;
+            metrics[sessionId].keys[key] = seen + 1;
+            if (seen >= 1)
+                recordFeedback(phrenPathLocal, key, "reprompt");
+        }
+        const relevantCount = selected.filter((s) => getQualityMultiplier(phrenPathLocal, s.key) > 0.5).length;
+        const prevRelevant = metrics[sessionId].lastChangedCount || 0;
+        const prevKeys = metrics[sessionId].lastKeys || [];
+        if (relevantCount > prevRelevant) {
+            for (const prevKey of prevKeys) {
+                recordFeedback(phrenPathLocal, prevKey, "helpful");
+            }
+        }
+        metrics[sessionId].lastChangedCount = relevantCount;
+        metrics[sessionId].lastKeys = injectedKeys;
+        metrics[sessionId].lastSeen = new Date().toISOString();
+        const thirtyDaysAgo = Date.now() - 30 * 86400000;
+        for (const sid of Object.keys(metrics)) {
+            const seen = metrics[sid].lastSeen;
+            if (seen && new Date(seen).getTime() < thirtyDaysAgo) {
+                delete metrics[sid];
+            }
+        }
+    });
+}
+// ── Git command helpers for hooks ────────────────────────────────────────────
+export function isTransientGitError(message) {
+    return /(timed out|connection|network|could not resolve host|rpc failed|429|502|503|504|service unavailable)/i.test(message);
+}
+export function shouldRetryGitCommand(args) {
+    const cmd = args[0] || "";
+    return cmd === "push" || cmd === "pull" || cmd === "fetch";
+}
+export async function runBestEffortGit(args, cwd) {
+    const retries = shouldRetryGitCommand(args) ? 2 : 0;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            const output = execFileSync("git", args, {
+                cwd,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: EXEC_TIMEOUT_MS,
+            }).trim();
+            return { ok: true, output };
+        }
+        catch (err) {
+            const message = errorMessage(err);
+            if (attempt < retries && isTransientGitError(message)) {
+                const delayMs = 500 * (attempt + 1);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+                continue;
+            }
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: "git command failed" };
+}
+export async function countUnsyncedCommits(cwd) {
+    const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+    if (!upstream.ok || !upstream.output)
+        return 0;
+    const ahead = await runBestEffortGit(["rev-list", "--count", `${upstream.output.trim()}..HEAD`], cwd);
+    if (!ahead.ok || !ahead.output)
+        return 0;
+    const parsed = Number.parseInt(ahead.output.trim(), 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+export function isMergeableMarkdown(relPath) {
+    const filename = path.basename(relPath).toLowerCase();
+    return filename === "findings.md" || isTaskFileName(filename);
+}
+export async function snapshotLocalMergeableFiles(cwd) {
+    const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+    if (!upstream.ok || !upstream.output)
+        return new Map();
+    const changed = await runBestEffortGit(["diff", "--name-only", `${upstream.output.trim()}..HEAD`], cwd);
+    if (!changed.ok || !changed.output)
+        return new Map();
+    const snapshots = new Map();
+    for (const relPath of changed.output.split("\n").map((line) => line.trim()).filter(Boolean)) {
+        if (!isMergeableMarkdown(relPath))
+            continue;
+        const fullPath = path.join(cwd, relPath);
+        if (!fs.existsSync(fullPath))
+            continue;
+        snapshots.set(relPath, fs.readFileSync(fullPath, "utf8"));
+    }
+    return snapshots;
+}
+export async function reconcileMergeableFiles(cwd, snapshots) {
+    let changedAny = false;
+    for (const [relPath, localBeforePull] of snapshots.entries()) {
+        const fullPath = path.join(cwd, relPath);
+        if (!fs.existsSync(fullPath))
+            continue;
+        const current = fs.readFileSync(fullPath, "utf8");
+        const filename = path.basename(relPath).toLowerCase();
+        const merged = filename === "findings.md"
+            ? mergeFindings(current, localBeforePull)
+            : mergeTask(current, localBeforePull);
+        if (merged === current)
+            continue;
+        fs.writeFileSync(fullPath, merged);
+        changedAny = true;
+    }
+    if (!changedAny)
+        return false;
+    const add = await runBestEffortGit(["add", "--", ...snapshots.keys()], cwd);
+    if (!add.ok)
+        return false;
+    const commit = await runBestEffortGit(["commit", "-m", "auto-merge markdown recovery"], cwd);
+    return commit.ok;
+}
+export async function recoverPushConflict(cwd) {
+    const localSnapshots = await snapshotLocalMergeableFiles(cwd);
+    const pull = await runBestEffortGit(["pull", "--rebase", "--quiet"], cwd);
+    if (pull.ok) {
+        const reconciled = await reconcileMergeableFiles(cwd, localSnapshots);
+        const retryPush = await runBestEffortGit(["push"], cwd);
+        return {
+            ok: retryPush.ok,
+            detail: retryPush.ok
+                ? (reconciled ? "commit pushed after pull --rebase and markdown reconciliation" : "commit pushed after pull --rebase")
+                : (retryPush.error || "push failed after pull --rebase"),
+            pullStatus: "ok",
+            pullDetail: pull.output || "pull --rebase ok",
+        };
+    }
+    const conflicted = await runBestEffortGit(["diff", "--name-only", "--diff-filter=U"], cwd);
+    const conflictedOutput = conflicted.output?.trim() || "";
+    if (!conflicted.ok || !conflictedOutput) {
+        await runBestEffortGit(["rebase", "--abort"], cwd);
+        return {
+            ok: false,
+            detail: pull.error || "pull --rebase failed",
+            pullStatus: "error",
+            pullDetail: pull.error || "pull --rebase failed",
+        };
+    }
+    if (!autoMergeConflicts(cwd)) {
+        await runBestEffortGit(["rebase", "--abort"], cwd);
+        return {
+            ok: false,
+            detail: `rebase conflicts require manual resolution: ${conflictedOutput}`,
+            pullStatus: "error",
+            pullDetail: `rebase conflicts require manual resolution: ${conflictedOutput}`,
+        };
+    }
+    const continued = await runBestEffortGit(["-c", "core.editor=true", "rebase", "--continue"], cwd);
+    if (!continued.ok) {
+        await runBestEffortGit(["rebase", "--abort"], cwd);
+        return {
+            ok: false,
+            detail: continued.error || "rebase --continue failed",
+            pullStatus: "error",
+            pullDetail: continued.error || "rebase --continue failed",
+        };
+    }
+    const retryPush = await runBestEffortGit(["push"], cwd);
+    return {
+        ok: retryPush.ok,
+        detail: retryPush.ok ? "commit pushed after auto-merge recovery" : (retryPush.error || "push failed after auto-merge recovery"),
+        pullStatus: "ok",
+        pullDetail: "pull --rebase recovered via auto-merge",
+    };
+}
+export function resolveSubprocessArgs(command) {
+    // Prefer the entry script from process.argv[1] (the index.js that started this process)
+    const entry = process.argv[1];
+    if (entry && fs.existsSync(entry) && /index\.(ts|js)$/.test(entry))
+        return [entry, command];
+    // Fallback: look for index.js next to this file
+    const distEntry = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+    if (fs.existsSync(distEntry))
+        return [distEntry, command];
+    return null;
+}

package/mcp/dist/cli-hooks-prompt.js

@@ -0,0 +1,319 @@
+/**
+ * handleHookContext (SessionStart context injection) and handleHookTool (PostToolUse)
+ * with tool finding extraction helpers.
+ * Extracted from cli-hooks-session.ts for modularity.
+ */
+import { buildHookContext, debugLog, runtimeFile, sessionMarker, getPhrenPath, appendAuditLog, appendReviewQueue, detectProject, isProjectHookEnabled, getProactivityLevelForFindings, errorMessage, } from "./cli/hooks-context.js";
+import * as fs from "fs";
+import * as path from "path";
+import { buildIndex, queryRows, } from "./shared/index.js";
+import { filterTaskByPriority } from "./shared/retrieval.js";
+import { readStdinJson, getSessionCap } from "./cli-hooks-stop.js";
+import { logger } from "./logger.js";
+export async function handleHookContext() {
+    const ctx = buildHookContext();
+    if (!ctx.hooksEnabled) {
+        process.exit(0);
+    }
+    let cwd = ctx.cwd;
+    const ctxStdin = readStdinJson();
+    if (ctxStdin?.cwd)
+        cwd = ctxStdin.cwd;
+    const project = cwd !== ctx.cwd ? detectProject(ctx.phrenPath, cwd, ctx.profile) : ctx.activeProject;
+    if (!isProjectHookEnabled(ctx.phrenPath, project, "UserPromptSubmit")) {
+        process.exit(0);
+    }
+    const db = await buildIndex(ctx.phrenPath, ctx.profile);
+    const contextLabel = project ? `\u25c6 phren \u00b7 ${project} \u00b7 context` : `\u25c6 phren \u00b7 context`;
+    const parts = [contextLabel, "<phren-context>"];
+    if (project) {
+        const summaryRow = queryRows(db, "SELECT content FROM docs WHERE project = ? AND type = 'summary'", [project]);
+        if (summaryRow) {
+            parts.push(`# ${project}`);
+            parts.push(summaryRow[0][0]);
+            parts.push("");
+        }
+        const findingsRow = queryRows(db, "SELECT content FROM docs WHERE project = ? AND type = 'findings'", [project]);
+        if (findingsRow) {
+            const content = findingsRow[0][0];
+            const bullets = content.split("\n").filter(l => l.startsWith("- ")).slice(0, 10);
+            if (bullets.length > 0) {
+                parts.push("## Recent findings");
+                parts.push(bullets.join("\n"));
+                parts.push("");
+            }
+        }
+        const taskRow = queryRows(db, "SELECT content FROM docs WHERE project = ? AND type = 'task'", [project]);
+        if (taskRow) {
+            const content = taskRow[0][0];
+            const activeItems = content.split("\n").filter(l => l.startsWith("- "));
+            const filtered = filterTaskByPriority(activeItems);
+            const trimmed = filtered.slice(0, 5);
+            if (trimmed.length > 0) {
+                parts.push("## Active tasks");
+                parts.push(trimmed.join("\n"));
+                parts.push("");
+            }
+        }
+    }
+    else {
+        const projectRows = queryRows(db, "SELECT DISTINCT project FROM docs ORDER BY project", []);
+        if (projectRows) {
+            parts.push("# Phren projects");
+            parts.push(projectRows.map(r => `- ${r[0]}`).join("\n"));
+            parts.push("");
+        }
+    }
+    parts.push("</phren-context>");
+    if (parts.length > 2) {
+        console.log(parts.join("\n"));
+    }
+}
+// ── PostToolUse hook ─────────────────────────────────────────────────────────
+const INTERESTING_TOOLS = new Set(["Read", "Write", "Edit", "Bash", "Glob", "Grep"]);
+const COOLDOWN_MS = parseInt(process.env.PHREN_AUTOCAPTURE_COOLDOWN_MS ?? "30000", 10);
+function flattenToolResponseText(value, maxChars = 4000) {
+    if (typeof value === "string")
+        return value;
+    const queue = [value];
+    const parts = [];
+    let length = 0;
+    while (queue.length > 0 && length < maxChars) {
+        const current = queue.shift();
+        if (typeof current === "string") {
+            const trimmed = current.trim();
+            if (!trimmed)
+                continue;
+            parts.push(trimmed);
+            length += trimmed.length + 1;
+            continue;
+        }
+        if (Array.isArray(current)) {
+            queue.unshift(...current);
+            continue;
+        }
+        if (current && typeof current === "object") {
+            queue.unshift(...Object.values(current));
+        }
+    }
+    if (parts.length > 0)
+        return parts.join("\n").slice(0, maxChars);
+    return JSON.stringify(value ?? "").slice(0, maxChars);
+}
+export async function handleHookTool() {
+    const ctx = buildHookContext();
+    if (!ctx.hooksEnabled) {
+        process.exit(0);
+    }
+    try {
+        const start = Date.now();
+        let raw = "";
+        if (!process.stdin.isTTY) {
+            try {
+                raw = fs.readFileSync(0, "utf-8");
+            }
+            catch (err) {
+                logger.debug("hookTool stdinRead", errorMessage(err));
+                process.exit(0);
+            }
+        }
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch (err) {
+            logger.debug("hookTool stdinParse", errorMessage(err));
+            process.exit(0);
+        }
+        const toolName = String(data.tool_name ?? data.tool ?? "");
+        if (!INTERESTING_TOOLS.has(toolName)) {
+            process.exit(0);
+        }
+        const sessionId = data.session_id;
+        const input = (data.tool_input ?? {});
+        const entry = {
+            at: new Date().toISOString(),
+            session_id: sessionId,
+            tool: toolName,
+        };
+        if (toolName === "Read" || toolName === "Write" || toolName === "Edit") {
+            const filePath = input.file_path ?? input.path ?? undefined;
+            if (filePath)
+                entry.file = String(filePath);
+        }
+        else if (toolName === "Bash") {
+            const cmd = input.command ?? undefined;
+            if (cmd)
+                entry.command = String(cmd).slice(0, 200);
+        }
+        else if (toolName === "Glob") {
+            const pattern = input.pattern ?? undefined;
+            if (pattern)
+                entry.file = String(pattern);
+        }
+        else if (toolName === "Grep") {
+            const pattern = input.pattern ?? undefined;
+            const searchPath = input.path ?? undefined;
+            if (pattern)
+                entry.command = `grep ${pattern}${searchPath ? ` in ${searchPath}` : ""}`.slice(0, 200);
+        }
+        const responseStr = flattenToolResponseText(data.tool_response ?? "");
+        if (/(error|exception|failed|no such file|ENOENT)/i.test(responseStr)) {
+            entry.error = responseStr.slice(0, 300);
+        }
+        const cwd = (data.cwd ?? input.cwd ?? undefined);
+        let activeProject = cwd ? detectProject(ctx.phrenPath, cwd, ctx.profile) : null;
+        if (!isProjectHookEnabled(ctx.phrenPath, activeProject, "PostToolUse")) {
+            appendAuditLog(ctx.phrenPath, "hook_tool", `status=project_disabled project=${activeProject}`);
+            process.exit(0);
+        }
+        try {
+            const logFile = runtimeFile(ctx.phrenPath, "tool-log.jsonl");
+            fs.mkdirSync(path.dirname(logFile), { recursive: true });
+            fs.appendFileSync(logFile, JSON.stringify(entry) + "\n");
+        }
+        catch (err) {
+            logger.debug("hookTool toolLog", errorMessage(err));
+        }
+        const cooldownFile = runtimeFile(ctx.phrenPath, "hook-tool-cooldown");
+        try {
+            if (fs.existsSync(cooldownFile)) {
+                const age = Date.now() - fs.statSync(cooldownFile).mtimeMs;
+                if (age < COOLDOWN_MS) {
+                    debugLog(`hook-tool: cooldown active (${Math.round(age / 1000)}s < ${Math.round(COOLDOWN_MS / 1000)}s), skipping extraction`);
+                    activeProject = null;
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("hookTool cooldownStat", errorMessage(err));
+        }
+        if (activeProject && sessionId) {
+            try {
+                const capFile = sessionMarker(ctx.phrenPath, `tool-findings-${sessionId}`);
+                let count = 0;
+                if (fs.existsSync(capFile)) {
+                    count = Number.parseInt(fs.readFileSync(capFile, "utf8").trim(), 10) || 0;
+                }
+                const sessionCap = getSessionCap();
+                if (count >= sessionCap) {
+                    debugLog(`hook-tool: session cap reached (${count}/${sessionCap}), skipping extraction`);
+                    activeProject = null;
+                }
+            }
+            catch (err) {
+                logger.debug("hookTool sessionCapCheck", errorMessage(err));
+            }
+        }
+        const findingsLevelForTool = getProactivityLevelForFindings(ctx.phrenPath);
+        if (activeProject && findingsLevelForTool !== "low") {
+            try {
+                const candidates = filterToolFindingsForProactivity(extractToolFindings(toolName, input, responseStr), findingsLevelForTool);
+                for (const { text, confidence } of candidates) {
+                    appendReviewQueue(ctx.phrenPath, activeProject, "Review", [text]);
+                    debugLog(`hook-tool: queued candidate for review (conf=${confidence}): ${text.slice(0, 60)}`);
+                }
+                if (candidates.length > 0) {
+                    try {
+                        fs.writeFileSync(cooldownFile, Date.now().toString());
+                    }
+                    catch (err) {
+                        logger.debug("hookTool cooldownWrite", errorMessage(err));
+                    }
+                    if (sessionId) {
+                        try {
+                            const capFile = sessionMarker(ctx.phrenPath, `tool-findings-${sessionId}`);
+                            let count = 0;
+                            try {
+                                count = Number.parseInt(fs.readFileSync(capFile, "utf8").trim(), 10) || 0;
+                            }
+                            catch (err) {
+                                logger.debug("hookTool capFileRead", errorMessage(err));
+                            }
+                            count += candidates.length;
+                            fs.writeFileSync(capFile, count.toString());
+                        }
+                        catch (err) {
+                            logger.debug("hookTool capFileWrite", errorMessage(err));
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                debugLog(`hook-tool: finding extraction failed: ${errorMessage(err)}`);
+            }
+        }
+        else if (activeProject) {
+            debugLog("hook-tool: skipped because findings proactivity is low");
+        }
+        const elapsed = Date.now() - start;
+        debugLog(`hook-tool: ${toolName} logged in ${elapsed}ms`);
+        process.exit(0);
+    }
+    catch (err) {
+        debugLog(`hook-tool: unhandled error: ${err instanceof Error ? err.stack || err.message : String(err)}`);
+        process.exit(0);
+    }
+}
+const EXPLICIT_TAG_PATTERN = /\[(pitfall|decision|pattern|tradeoff|architecture|bug)\]\s*(.+)/i;
+export function filterToolFindingsForProactivity(candidates, level = getProactivityLevelForFindings(getPhrenPath())) {
+    if (level === "high")
+        return candidates;
+    if (level === "low")
+        return [];
+    return candidates.filter((candidate) => candidate.explicit === true);
+}
+export function extractToolFindings(toolName, input, responseStr) {
+    const candidates = [];
+    const changedContent = (toolName === "Edit" || toolName === "Write")
+        ? String(input.new_string ?? input.content ?? "")
+        : "";
+    const explicitSource = changedContent || responseStr;
+    const tagMatches = explicitSource.matchAll(new RegExp(EXPLICIT_TAG_PATTERN.source, "gi"));
+    for (const m of tagMatches) {
+        const tag = m[1].toLowerCase();
+        const content = m[2].replace(/\s+/g, " ").trim().slice(0, 200);
+        if (content) {
+            candidates.push({ text: `[${tag}] ${content}`, confidence: 0.85, explicit: true });
+        }
+    }
+    if (toolName === "Edit" || toolName === "Write") {
+        const filePath = String(input.file_path ?? input.path ?? "unknown");
+        const filename = path.basename(filePath);
+        if (/\b(TODO|FIXME)\b/.test(changedContent)) {
+            const firstLine = changedContent.split("\n").find((l) => /\b(TODO|FIXME)\b/.test(l));
+            if (firstLine) {
+                candidates.push({
+                    text: `[pitfall] ${filename}: ${firstLine.trim().slice(0, 150)}`,
+                    confidence: 0.45,
+                    explicit: false,
+                });
+            }
+        }
+        if (/\btry\s*\{[\s\S]*?\bcatch\b/.test(changedContent)) {
+            const meaningfulLine = changedContent.split("\n").find((l) => l.trim().length > 10 && !/^\s*(try|catch|\{|\})/.test(l));
+            if (meaningfulLine) {
+                candidates.push({
+                    text: `[pitfall] ${filename}: error handling added near "${meaningfulLine.trim().slice(0, 100)}"`,
+                    confidence: 0.45,
+                    explicit: false,
+                });
+            }
+        }
+    }
+    if (toolName === "Bash") {
+        const cmd = String(input.command ?? "").slice(0, 30);
+        const hasError = /(error|exception|failed|ENOENT|command not found|permission denied)/i.test(responseStr);
+        if (hasError && cmd) {
+            const firstErrorLine = responseStr.split("\n").find((l) => /(error|exception|failed|ENOENT|command not found|permission denied)/i.test(l));
+            if (firstErrorLine) {
+                candidates.push({
+                    text: `[bug] command '${cmd}' failed: ${firstErrorLine.trim().slice(0, 150)}`,
+                    confidence: 0.55,
+                    explicit: false,
+                });
+            }
+        }
+    }
+    return candidates;
+}