@phren/cli 0.1.12 → 0.1.14

package/dist/cli/session-tool-hook.js

@@ -0,0 +1,376 @@
+/**
+ * PostToolUse hook handler and context hook handler.
+ * Extracted from hooks-session.ts for modularity.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { buildHookContext, debugLog, appendAuditLog, runtimeFile, sessionMarker, getPhrenPath, getWorkflowPolicy, appendReviewQueue, getProactivityLevelForFindings, FINDING_SENSITIVITY_CONFIG, isProjectHookEnabled, errorMessage, detectProject, } from "./hooks-context.js";
+import { logger } from "../logger.js";
+import { buildIndex, queryRows, } from "../shared/index.js";
+import { filterTaskByPriority } from "../shared/retrieval.js";
+// ── 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 getSessionCap() {
+    if (process.env.PHREN_AUTOCAPTURE_SESSION_CAP) {
+        return parseInt(process.env.PHREN_AUTOCAPTURE_SESSION_CAP, 10);
+    }
+    try {
+        const policy = getWorkflowPolicy(getPhrenPath());
+        const sensitivity = policy.findingSensitivity ?? "balanced";
+        return FINDING_SENSITIVITY_CONFIG[sensitivity]?.sessionCap ?? 10;
+    }
+    catch {
+        return 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("hooks-session", `hookTool stdinRead: ${errorMessage(err)}`);
+                process.exit(0);
+            }
+        }
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch (err) {
+            logger.debug("hooks-session", `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("hooks-session", `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("hooks-session", `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("hooks-session", `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("hooks-session", `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("hooks-session", `hookTool capFileRead: ${errorMessage(err)}`);
+                            }
+                            count += candidates.length;
+                            fs.writeFileSync(capFile, count.toString());
+                        }
+                        catch (err) {
+                            logger.debug("hooks-session", `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;
+}
+// ── Context hook handler ────────────────────────────────────────────────────
+function readStdinJson() {
+    if (process.stdin.isTTY)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(0, "utf-8"));
+    }
+    catch (err) {
+        logger.debug("hooks-session", `readStdinJson: ${errorMessage(err)}`);
+        return null;
+    }
+}
+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("");
+            }
+        }
+        // Collect pinned tasks across ALL projects (excluding Done)
+        const allTaskRows = queryRows(db, "SELECT project, content FROM docs WHERE type = 'task'", []);
+        const pinnedFromOtherProjects = [];
+        if (allTaskRows) {
+            for (const row of allTaskRows) {
+                const taskProject = row[0];
+                if (taskProject === project)
+                    continue;
+                const content = row[1];
+                const pinned = content.split("\n")
+                    .filter(l => l.startsWith("- [ ] ") && /\[pinned\]/i.test(l))
+                    .map(l => `[${taskProject}] ${l}`);
+                pinnedFromOtherProjects.push(...pinned);
+            }
+        }
+        // Active project tasks — pinned float to top, exclude Done
+        const taskRow = queryRows(db, "SELECT content FROM docs WHERE project = ? AND type = 'task'", [project]);
+        const pinnedItems = [];
+        const otherItems = [];
+        if (taskRow) {
+            const content = taskRow[0][0];
+            const allItems = content.split("\n").filter(l => l.startsWith("- [ ] "));
+            for (const item of allItems) {
+                if (/\[pinned\]/i.test(item)) {
+                    pinnedItems.push(item);
+                }
+                else {
+                    otherItems.push(item);
+                }
+            }
+        }
+        const filteredOther = filterTaskByPriority(otherItems);
+        const allPinned = [...pinnedItems, ...pinnedFromOtherProjects].slice(0, 10);
+        const remaining = Math.max(0, 5 - allPinned.length);
+        const trimmedOther = filteredOther.slice(0, remaining);
+        if (allPinned.length > 0 || trimmedOther.length > 0) {
+            if (allPinned.length > 0) {
+                parts.push("## Pinned tasks");
+                parts.push(allPinned.join("\n"));
+            }
+            if (trimmedOther.length > 0) {
+                parts.push("## Active tasks");
+                parts.push(trimmedOther.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"));
+    }
+}

package/dist/profile-store.js

@@ -310,8 +310,19 @@ export function listProjectCards(phrenPath, profile) {
     const dirs = getProjectDirs(phrenPath, profile).sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
     const cards = dirs.map(buildProjectCard);
     const seen = new Set(dirs.map((d) => path.basename(d)));
-    // Include projects from team stores
+    // Include projects from team stores, filtered by active profile
     try {
+        // Resolve the profile's project allow-list (if any)
+        let profileProjectNames;
+        if (profile) {
+            const profiles = listProfiles(phrenPath);
+            if (profiles.ok) {
+                const active = profiles.data.find((p) => p.name === profile);
+                if (active && active.projects.length > 0) {
+                    profileProjectNames = new Set(active.projects);
+                }
+            }
+        }
         for (const store of getNonPrimaryStores(phrenPath)) {
             if (!fs.existsSync(store.path))
                 continue;
@@ -319,6 +330,8 @@ export function listProjectCards(phrenPath, profile) {
                 const name = path.basename(dir);
                 if (seen.has(name) || name === "global")
                     continue;
+                if (profileProjectNames && !profileProjectNames.has(name))
+                    continue;
                 seen.add(name);
                 cards.push(buildProjectCard(dir));
             }

package/dist/shared/index.js

@@ -30,12 +30,30 @@ async function refreshStoreProjectDirs(phrenPath, profile) {
     try {
         const { getNonPrimaryStores, getStoreProjectDirs } = await import("../store-registry.js");
         const otherStores = getNonPrimaryStores(phrenPath);
-        const dirs = [];
+        let dirs = [];
         for (const store of otherStores) {
             if (!fs.existsSync(store.path))
                 continue;
             dirs.push(...getStoreProjectDirs(store));
         }
+        // Filter by active profile's project list, matching getProjectDirs behavior
+        if (profile) {
+            const profilePath = path.join(phrenPath, "profiles", `${profile}.yaml`);
+            if (fs.existsSync(profilePath)) {
+                try {
+                    const yaml = await import("js-yaml");
+                    const data = yaml.load(fs.readFileSync(profilePath, "utf-8"), { schema: yaml.CORE_SCHEMA });
+                    const projects = data?.projects;
+                    if (Array.isArray(projects)) {
+                        const allowed = new Set(projects.map(String));
+                        dirs = dirs.filter(dir => allowed.has(path.basename(dir)));
+                    }
+                }
+                catch {
+                    // Profile parse error — include all dirs as fallback
+                }
+            }
+        }
         _cachedStoreProjectDirs = dirs;
         _cachedStorePhrenPath = phrenPath;
     }
@@ -445,8 +463,9 @@ function globAllFiles(phrenPath, profile) {
     const allAbsolutePaths = [];
     for (const dir of projectDirs) {
         const projectName = path.basename(dir);
-        const config = readProjectConfig(phrenPath, projectName);
-        const ownership = getProjectOwnershipMode(phrenPath, projectName, config);
+        const storePath = path.dirname(dir);
+        const config = readProjectConfig(storePath, projectName);
+        const ownership = getProjectOwnershipMode(storePath, projectName, config);
         const mdFilesSet = new Set();
         for (const pattern of indexPolicy.includeGlobs) {
             const dot = indexPolicy.includeHidden || pattern.startsWith(".") || pattern.includes("/.");

package/dist/shared/retrieval.js

@@ -495,20 +495,21 @@ export async function searchKnowledgeRows(db, options) {
  * Returns an array of results tagged with their source store. Read-only — no mutations.
  */
 export async function searchFederatedStores(localPhrenPath, options) {
-    let nonPrimaryStores;
+    // Registered non-primary stores are already included in the main FTS index
+    // by buildIndex (via refreshStoreProjectDirs). Only search unregistered
+    // federation paths from PHREN_FEDERATION_PATHS to avoid double indexing.
+    let registeredStorePaths;
     try {
         const { getNonPrimaryStores } = await import("../store-registry.js");
-        nonPrimaryStores = getNonPrimaryStores(localPhrenPath).map((s) => ({
-            path: s.path, name: s.name, id: s.id,
-        }));
+        registeredStorePaths = new Set(getNonPrimaryStores(localPhrenPath).map((s) => s.path));
     }
     catch {
-        // Fallback: parse PHREN_FEDERATION_PATHS directly (pre-registry compat)
-        const raw = process.env.PHREN_FEDERATION_PATHS ?? "";
-        nonPrimaryStores = raw.split(":").map((p) => p.trim())
-            .filter((p) => p.length > 0 && p !== localPhrenPath && fs.existsSync(p))
-            .map((p) => ({ path: p, name: path.basename(p), id: "" }));
+        registeredStorePaths = new Set();
     }
+    const raw = process.env.PHREN_FEDERATION_PATHS ?? "";
+    const nonPrimaryStores = raw.split(":").map((p) => p.trim())
+        .filter((p) => p.length > 0 && p !== localPhrenPath && !registeredStorePaths.has(p) && fs.existsSync(p))
+        .map((p) => ({ path: p, name: path.basename(p), id: "" }));
     if (nonPrimaryStores.length === 0)
         return [];
     const allRows = [];

package/dist/tools/search.js

@@ -474,7 +474,7 @@ async function handleGetProjectSummary(ctx, { name }) {
             for (const [file, type] of [["summary.md", "summary"], ["CLAUDE.md", "claude"], ["FINDINGS.md", "findings"], ["tasks.md", "task"], ["truths.md", "canonical"]]) {
                 const filePath = path.join(projDir, file);
                 if (fs.existsSync(filePath)) {
-                    fsDocs.push({ filename: file, type, content: fs.readFileSync(filePath, "utf8").slice(0, 8000), path: filePath });
+                    fsDocs.push({ project: lookupName, filename: file, type, content: fs.readFileSync(filePath, "utf8").slice(0, 8000), path: filePath });
                 }
             }
             if (fsDocs.length > 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/cli",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Knowledge layer for AI agents — CLI, MCP server, and data layer",
   "type": "module",
   "bin": {