@phren/cli 0.0.27 → 0.0.32

package/mcp/dist/init-modes.js

@@ -0,0 +1,135 @@
+/**
+ * MCP-mode and hooks-mode toggle commands.
+ */
+import { configureClaude, configureVSCode, configureCursorMcp, configureCopilotMcp, configureCodexMcp, } from "./init/config.js";
+import { configureAllHooks } from "./hooks.js";
+import { debugLog, findPhrenPath, readRootManifest, } from "./shared.js";
+import { errorMessage } from "./utils.js";
+import { getMcpEnabledPreference, getHooksEnabledPreference, setMcpEnabledPreference, setHooksEnabledPreference, } from "./init/preferences.js";
+import { DEFAULT_PHREN_PATH, log } from "./init/shared.js";
+export function parseMcpMode(raw) {
+    if (!raw)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "on" || normalized === "off")
+        return normalized;
+    return undefined;
+}
+export async function runMcpMode(modeArg) {
+    const phrenPath = findPhrenPath() || (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
+    const manifest = readRootManifest(phrenPath);
+    const normalizedArg = modeArg?.trim().toLowerCase();
+    if (!normalizedArg || normalizedArg === "status") {
+        const current = getMcpEnabledPreference(phrenPath);
+        const hooks = getHooksEnabledPreference(phrenPath);
+        log(`MCP mode: ${current ? "on (recommended)" : "off (hooks-only fallback)"}`);
+        log(`Hooks mode: ${hooks ? "on (active)" : "off (disabled)"}`);
+        log(`Change mode: npx phren mcp-mode on|off`);
+        log(`Hooks toggle: npx phren hooks-mode on|off`);
+        return;
+    }
+    const mode = parseMcpMode(normalizedArg);
+    if (!mode) {
+        throw new Error(`Invalid mode "${modeArg}". Use: on | off | status`);
+    }
+    const enabled = mode === "on";
+    if (manifest?.installMode === "project-local") {
+        const vscodeStatus = configureVSCode(phrenPath, { mcpEnabled: enabled, scope: "workspace" });
+        setMcpEnabledPreference(phrenPath, enabled);
+        log(`MCP mode set to ${mode}.`);
+        log(`VS Code status: ${vscodeStatus}`);
+        log(`Project-local mode only configures workspace VS Code MCP.`);
+        return;
+    }
+    let claudeStatus = "no_settings";
+    let vscodeStatus = "no_vscode";
+    let cursorStatus = "no_cursor";
+    let copilotStatus = "no_copilot";
+    let codexStatus = "no_codex";
+    try {
+        claudeStatus = configureClaude(phrenPath, { mcpEnabled: enabled }) ?? claudeStatus;
+    }
+    catch (err) {
+        debugLog(`mcp-mode: configureClaude failed: ${errorMessage(err)}`);
+    }
+    try {
+        vscodeStatus = configureVSCode(phrenPath, { mcpEnabled: enabled }) ?? vscodeStatus;
+    }
+    catch (err) {
+        debugLog(`mcp-mode: configureVSCode failed: ${errorMessage(err)}`);
+    }
+    try {
+        cursorStatus = configureCursorMcp(phrenPath, { mcpEnabled: enabled }) ?? cursorStatus;
+    }
+    catch (err) {
+        debugLog(`mcp-mode: configureCursorMcp failed: ${errorMessage(err)}`);
+    }
+    try {
+        copilotStatus = configureCopilotMcp(phrenPath, { mcpEnabled: enabled }) ?? copilotStatus;
+    }
+    catch (err) {
+        debugLog(`mcp-mode: configureCopilotMcp failed: ${errorMessage(err)}`);
+    }
+    try {
+        codexStatus = configureCodexMcp(phrenPath, { mcpEnabled: enabled }) ?? codexStatus;
+    }
+    catch (err) {
+        debugLog(`mcp-mode: configureCodexMcp failed: ${errorMessage(err)}`);
+    }
+    // Persist preference only after config writes have been attempted
+    setMcpEnabledPreference(phrenPath, enabled);
+    log(`MCP mode set to ${mode}.`);
+    log(`Claude status: ${claudeStatus}`);
+    log(`VS Code status: ${vscodeStatus}`);
+    log(`Cursor status: ${cursorStatus}`);
+    log(`Copilot CLI status: ${copilotStatus}`);
+    log(`Codex status: ${codexStatus}`);
+    log(`Restart your agent to apply changes.`);
+}
+export async function runHooksMode(modeArg) {
+    const phrenPath = findPhrenPath() || (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
+    const manifest = readRootManifest(phrenPath);
+    const normalizedArg = modeArg?.trim().toLowerCase();
+    if (!normalizedArg || normalizedArg === "status") {
+        const current = getHooksEnabledPreference(phrenPath);
+        log(`Hooks mode: ${current ? "on (active)" : "off (disabled)"}`);
+        log(`Change mode: npx phren hooks-mode on|off`);
+        return;
+    }
+    const mode = parseMcpMode(normalizedArg);
+    if (!mode) {
+        throw new Error(`Invalid mode "${modeArg}". Use: on | off | status`);
+    }
+    if (manifest?.installMode === "project-local") {
+        throw new Error("hooks-mode is unsupported in project-local mode");
+    }
+    const enabled = mode === "on";
+    let claudeStatus = "no_settings";
+    try {
+        claudeStatus = configureClaude(phrenPath, {
+            mcpEnabled: getMcpEnabledPreference(phrenPath),
+            hooksEnabled: enabled,
+        }) ?? claudeStatus;
+    }
+    catch (err) {
+        debugLog(`hooks-mode: configureClaude failed: ${errorMessage(err)}`);
+    }
+    if (enabled) {
+        try {
+            const hooked = configureAllHooks(phrenPath, { allTools: true });
+            if (hooked.length)
+                log(`Updated hooks: ${hooked.join(", ")}`);
+        }
+        catch (err) {
+            debugLog(`hooks-mode: configureAllHooks failed: ${errorMessage(err)}`);
+        }
+    }
+    else {
+        log("Hooks will no-op immediately via preference and Claude hooks are removed.");
+    }
+    // Persist preference only after config writes have been attempted
+    setHooksEnabledPreference(phrenPath, enabled);
+    log(`Hooks mode set to ${mode}.`);
+    log(`Claude status: ${claudeStatus}`);
+    log(`Restart your agent to apply changes.`);
+}

package/mcp/dist/init-npm.js

@@ -0,0 +1,37 @@
+/**
+ * Version comparison utilities for phren init and update flows.
+ */
+function parseVersion(version) {
+    const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?/);
+    if (!match)
+        return { major: 0, minor: 0, patch: 0, pre: "" };
+    return {
+        major: Number.parseInt(match[1], 10) || 0,
+        minor: Number.parseInt(match[2], 10) || 0,
+        patch: Number.parseInt(match[3], 10) || 0,
+        pre: match[4] || "",
+    };
+}
+/**
+ * Compare two semver strings. Returns true when `current` is strictly newer
+ * than `previous`. Pre-release versions (e.g. 1.2.3-rc.1) sort before the
+ * corresponding release (1.2.3). Among pre-release tags, comparison is
+ * lexicographic.
+ */
+export function isVersionNewer(current, previous) {
+    if (!previous)
+        return false;
+    const c = parseVersion(current);
+    const p = parseVersion(previous);
+    if (c.major !== p.major)
+        return c.major > p.major;
+    if (c.minor !== p.minor)
+        return c.minor > p.minor;
+    if (c.patch !== p.patch)
+        return c.patch > p.patch;
+    if (c.pre && !p.pre)
+        return false;
+    if (!c.pre && p.pre)
+        return true;
+    return c.pre > p.pre;
+}

package/mcp/dist/init-project-local.js

@@ -0,0 +1,99 @@
+/**
+ * Project-local init mode: creates a .phren directory inside the workspace.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { atomicWriteText, debugLog, readRootManifest, writeRootManifest, } from "./shared.js";
+import { errorMessage } from "./utils.js";
+import { configureVSCode, logMcpTargetStatus, } from "./init/config.js";
+import { writeInstallPreferences, } from "./init/preferences.js";
+import { ensureGovernanceFiles, repairPreexistingInstall, runPostInitVerify, bootstrapFromExisting, detectProjectDir, } from "./init/setup.js";
+import { getProjectOwnershipDefault, } from "./project-config.js";
+import { VERSION, log } from "./init/shared.js";
+import { applyOnboardingPreferences } from "./init-env.js";
+export async function runProjectLocalInit(opts = {}) {
+    const detectedRoot = detectProjectDir(process.cwd(), path.join(process.cwd(), ".phren")) || process.cwd();
+    const hasWorkspaceMarker = fs.existsSync(path.join(detectedRoot, ".git")) ||
+        fs.existsSync(path.join(detectedRoot, "CLAUDE.md")) ||
+        fs.existsSync(path.join(detectedRoot, "AGENTS.md")) ||
+        fs.existsSync(path.join(detectedRoot, ".claude", "CLAUDE.md"));
+    if (!hasWorkspaceMarker) {
+        throw new Error("project-local mode must be run inside a repo or project root");
+    }
+    const workspaceRoot = path.resolve(detectedRoot);
+    const phrenPath = path.join(workspaceRoot, ".phren");
+    const existingManifest = readRootManifest(phrenPath);
+    if (existingManifest && existingManifest.installMode !== "project-local") {
+        throw new Error(`Refusing to reuse non-local phren root at ${phrenPath}`);
+    }
+    const ownershipDefault = opts.projectOwnershipDefault
+        ?? (existingManifest ? getProjectOwnershipDefault(phrenPath) : "detached");
+    if (!existingManifest && !opts.projectOwnershipDefault) {
+        opts.projectOwnershipDefault = ownershipDefault;
+    }
+    const mcpEnabled = opts.mcp ? opts.mcp === "on" : true;
+    const projectName = path.basename(workspaceRoot).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+    if (opts.dryRun) {
+        log("\nInit dry run. No files will be written.\n");
+        log(`Mode: project-local`);
+        log(`Workspace root: ${workspaceRoot}`);
+        log(`Phren root: ${phrenPath}`);
+        log(`Project: ${projectName}`);
+        log(`VS Code workspace MCP: ${mcpEnabled ? "on" : "off"}`);
+        log(`Hooks: unsupported in project-local mode`);
+        log("");
+        return;
+    }
+    fs.mkdirSync(phrenPath, { recursive: true });
+    writeRootManifest(phrenPath, {
+        version: 1,
+        installMode: "project-local",
+        syncMode: "workspace-git",
+        workspaceRoot,
+        primaryProject: projectName,
+    });
+    ensureGovernanceFiles(phrenPath);
+    repairPreexistingInstall(phrenPath);
+    fs.mkdirSync(path.join(phrenPath, "global", "skills"), { recursive: true });
+    fs.mkdirSync(path.join(phrenPath, ".runtime"), { recursive: true });
+    fs.mkdirSync(path.join(phrenPath, ".sessions"), { recursive: true });
+    if (!fs.existsSync(path.join(phrenPath, ".gitignore"))) {
+        atomicWriteText(path.join(phrenPath, ".gitignore"), [
+            ".runtime/",
+            ".sessions/",
+            "*.lock",
+            "*.tmp-*",
+            "",
+        ].join("\n"));
+    }
+    if (!fs.existsSync(path.join(phrenPath, "global", "CLAUDE.md"))) {
+        atomicWriteText(path.join(phrenPath, "global", "CLAUDE.md"), "# Global Context\n\nRepo-local Phren instructions shared across this workspace.\n");
+    }
+    const created = bootstrapFromExisting(phrenPath, workspaceRoot, { ownership: ownershipDefault });
+    applyOnboardingPreferences(phrenPath, opts);
+    writeInstallPreferences(phrenPath, {
+        mcpEnabled,
+        hooksEnabled: false,
+        skillsScope: opts.skillsScope ?? "global",
+        installedVersion: VERSION,
+    });
+    try {
+        const vscodeResult = configureVSCode(phrenPath, { mcpEnabled, scope: "workspace" });
+        logMcpTargetStatus("VS Code", vscodeResult, existingManifest ? "Updated" : "Configured");
+    }
+    catch (err) {
+        debugLog(`configureVSCode(workspace) failed: ${errorMessage(err)}`);
+    }
+    log(`\n${existingManifest ? "Updated" : "Created"} project-local phren at ${phrenPath}`);
+    log(`  Workspace root: ${workspaceRoot}`);
+    log(`  Project: ${created.project}`);
+    log(`  Ownership: ${created.ownership}`);
+    log(`  Sync mode: workspace-git`);
+    log(`  Hooks: off (unsupported in project-local mode)`);
+    log(`  VS Code MCP: ${mcpEnabled ? "workspace on" : "workspace off"}`);
+    const verify = runPostInitVerify(phrenPath);
+    log(`\nVerifying setup...`);
+    for (const check of verify.checks) {
+        log(`  ${check.ok ? "pass" : "FAIL"} ${check.name}: ${check.detail}`);
+    }
+}

package/mcp/dist/init-semantic.js

@@ -0,0 +1,48 @@
+/**
+ * Semantic search warm-up for init.
+ */
+export async function warmSemanticSearch(phrenPath, profile) {
+    const { checkOllamaAvailable, checkModelAvailable, getOllamaUrl, getEmbeddingModel } = await import("./shared/ollama.js");
+    const ollamaUrl = getOllamaUrl();
+    if (!ollamaUrl)
+        return "Semantic search: disabled.";
+    const model = getEmbeddingModel();
+    if (!await checkOllamaAvailable()) {
+        return `Semantic search not warmed: Ollama offline at ${ollamaUrl}.`;
+    }
+    if (!await checkModelAvailable()) {
+        return `Semantic search not warmed: model ${model} is not pulled yet.`;
+    }
+    const { buildIndex, listIndexedDocumentPaths } = await import("./shared/index.js");
+    const { getEmbeddingCache, formatEmbeddingCoverage } = await import("./shared/embedding-cache.js");
+    const { backgroundEmbedMissingDocs } = await import("./startup-embedding.js");
+    const { getPersistentVectorIndex } = await import("./shared/vector-index.js");
+    const db = await buildIndex(phrenPath, profile);
+    try {
+        const cache = getEmbeddingCache(phrenPath);
+        await cache.load().catch(() => { });
+        const allPaths = listIndexedDocumentPaths(phrenPath, profile);
+        const before = cache.coverage(allPaths);
+        if (before.missing > 0) {
+            await backgroundEmbedMissingDocs(db, cache);
+        }
+        await cache.load().catch(() => { });
+        const after = cache.coverage(allPaths);
+        if (cache.size() > 0) {
+            getPersistentVectorIndex(phrenPath).ensure(cache.getAllEntries());
+        }
+        if (after.total === 0) {
+            return `Semantic search ready (${model}), but there are no indexed docs yet.`;
+        }
+        const embeddedNow = Math.max(0, after.embedded - before.embedded);
+        const prefix = after.state === "warm" ? "Semantic search warmed" : "Semantic search warming";
+        const delta = embeddedNow > 0 ? `; embedded ${embeddedNow} new docs during init` : "";
+        return `${prefix}: ${model}, ${formatEmbeddingCoverage(after)}${delta}.`;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore close errors in init */ }
+    }
+}

package/mcp/dist/init-types.js

@@ -0,0 +1 @@
+export {};