@phren/cli 0.0.1

package/mcp/dist/shell.js

@@ -0,0 +1,352 @@
+import * as fs from "fs";
+import * as path from "path";
+import { addTask, addFinding, loadShellState, saveShellState, } from "./data-access.js";
+import { style } from "./shell-render.js";
+import { MAX_UNDO_STACK, TAB_ICONS, } from "./shell-types.js";
+import { resultMsg, defaultRunHooks, defaultRunUpdate, defaultRunRelink, } from "./shell-palette.js";
+import { runDoctor } from "./link.js";
+import { renderShell, } from "./shell-view.js";
+import { executePalette, completeInput as completeInputFn, getListItems, handleNavigateKey, } from "./shell-input.js";
+import { errorMessage } from "./utils.js";
+// ── Shell class ──────────────────────────────────────────────────────────────
+export class PhrenShell {
+    phrenPath;
+    profile;
+    deps;
+    state;
+    message = `  ${style.boldCyan("←→")} ${style.dim("tabs")}  ${style.boldCyan("↑↓")} ${style.dim("move")}  ${style.boldCyan("↵")} ${style.dim("activate")}  ${style.boldCyan("?")} ${style.dim("help")}`;
+    healthCache;
+    prevHealthView;
+    showHelp = false;
+    pendingConfirm;
+    undoStack = [];
+    navMode = "navigate";
+    inputBuf = "";
+    inputCtx = "";
+    inputMqId = "";
+    cursorMap = {};
+    viewScrollMap = {};
+    healthLineCount = 0;
+    _subsectionsCache = null;
+    get mode() { return this.navMode; }
+    get inputBuffer() { return this.inputBuf; }
+    get filter() { return this.state.filter; }
+    constructor(phrenPath, profile, deps = {
+        runDoctor,
+        runRelink: defaultRunRelink,
+        runHooks: defaultRunHooks,
+        runUpdate: defaultRunUpdate,
+    }) {
+        this.phrenPath = phrenPath;
+        this.profile = profile;
+        this.deps = deps;
+        this.state = loadShellState(phrenPath);
+        this.state.view = "Projects";
+        this.message = this.state.project
+            ? `  Dashboard ready — active context ${style.boldCyan(this.state.project)}`
+            : `  Dashboard ready — choose a project with ${style.boldCyan("↵")} or stay global`;
+    }
+    close() { saveShellState(this.phrenPath, this.state); }
+    setMessage(msg) { this.message = msg; }
+    confirmThen(label, action) {
+        this.pendingConfirm = { label, action };
+        this.setMessage(`${label}  ${style.boldCyan("y")} ${style.dim("confirm")}  ${style.boldCyan("n")} ${style.dim("cancel")}`);
+    }
+    setView(view) {
+        this.state.view = view;
+        this.viewScrollMap[view] = 0;
+        saveShellState(this.phrenPath, this.state);
+    }
+    setFilter(value) {
+        this.state.filter = value.trim() || undefined;
+        saveShellState(this.phrenPath, this.state);
+        this.setMessage(this.state.filter ? `  Filter: ${style.yellow(this.state.filter)}` : "  Filter cleared.");
+    }
+    snapshotForUndo(label, file) {
+        try {
+            if (fs.existsSync(file)) {
+                const content = fs.readFileSync(file, "utf8");
+                this.undoStack.push({ label, file, content });
+                if (this.undoStack.length > MAX_UNDO_STACK)
+                    this.undoStack.shift();
+            }
+        }
+        catch (err) {
+            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                process.stderr.write(`[phren] shell pushUndo: ${errorMessage(err)}\n`);
+        }
+    }
+    popUndo() {
+        const entry = this.undoStack.pop();
+        if (!entry)
+            return "Nothing to undo.";
+        try {
+            fs.writeFileSync(entry.file, entry.content);
+            return `Undid: ${entry.label}`;
+        }
+        catch (err) {
+            return `Undo failed: ${errorMessage(err)}`;
+        }
+    }
+    ensureProjectSelected() {
+        if (!this.state.project) {
+            this.setMessage("No project selected — open one from Projects view (↵) or use :open <project>");
+            return null;
+        }
+        return this.state.project;
+    }
+    invalidateSubsectionsCache() { this._subsectionsCache = null; }
+    // ── Cursor management ────────────────────────────────────────────────────
+    currentCursor() { return this.cursorMap[this.state.view] ?? 0; }
+    setCursor(n) {
+        const count = this.getListItems().length;
+        this.cursorMap[this.state.view] = count > 0 ? Math.max(0, Math.min(n, count - 1)) : 0;
+    }
+    moveCursor(delta) { this.setCursor(this.currentCursor() + delta); }
+    currentScroll() { return this.viewScrollMap[this.state.view] ?? 0; }
+    setScroll(n) { this.viewScrollMap[this.state.view] = Math.max(0, n); }
+    getListItems() {
+        return getListItems(this.phrenPath, this.profile, this.state, this.healthLineCount);
+    }
+    startInput(ctx, initial) { this.navMode = "input"; this.inputCtx = ctx; this.inputBuf = initial; }
+    cancelInput() { this.navMode = "navigate"; this.inputBuf = ""; this.inputCtx = ""; this.setMessage("  Cancelled."); }
+    async submitInput() {
+        const buf = this.inputBuf;
+        const ctx = this.inputCtx;
+        this.navMode = "navigate";
+        this.inputBuf = "";
+        this.inputCtx = "";
+        if (!buf.trim() && ctx !== "command") {
+            this.setMessage("  Nothing entered.");
+            return;
+        }
+        switch (ctx) {
+            case "filter":
+                this.setFilter(buf);
+                break;
+            case "command":
+                await this.runPalette(buf.startsWith(":") ? buf.slice(1) : buf);
+                break;
+            case "add": {
+                const p = this.ensureProjectSelected();
+                if (!p)
+                    return;
+                this.setMessage(`  ${resultMsg(addTask(this.phrenPath, p, buf))}`);
+                break;
+            }
+            case "learn-add": {
+                const p = this.ensureProjectSelected();
+                if (!p)
+                    return;
+                this.setMessage(`  ${resultMsg(addFinding(this.phrenPath, p, buf))}`);
+                break;
+            }
+            case "skill-add": {
+                const p = this.ensureProjectSelected();
+                if (!p)
+                    return;
+                const name = buf.trim().replace(/\.md$/i, "").replace(/[^a-zA-Z0-9_-]/g, "-");
+                if (!name) {
+                    this.setMessage("  No name entered.");
+                    return;
+                }
+                const destDir = path.join(this.phrenPath, p, "skills");
+                fs.mkdirSync(destDir, { recursive: true });
+                const dest = path.join(destDir, `${name}.md`);
+                if (fs.existsSync(dest)) {
+                    this.setMessage(`  Skill "${name}" already exists.`);
+                    return;
+                }
+                const template = `# ${name}\n\nDescribe what this skill does.\n\n## Usage\n\n\`\`\`\nExample usage here\n\`\`\`\n`;
+                fs.writeFileSync(dest, template, "utf8");
+                this.setMessage(`  Created skill "${name}" — edit ${dest}`);
+                break;
+            }
+            case "mq-edit": {
+                this.setMessage("  Queue editing has been removed. The review queue is now read-only.");
+                this.inputMqId = "";
+                break;
+            }
+        }
+    }
+    // ── Raw key handling ───────────────────────────────────────────────────
+    async handleRawKey(key) {
+        if (key === "\x03" || key === "\x04")
+            return false;
+        if (this.pendingConfirm) {
+            const pending = this.pendingConfirm;
+            this.pendingConfirm = undefined;
+            if (key.toLowerCase() === "y") {
+                pending.action();
+            }
+            else {
+                this.setMessage("  Cancelled.");
+            }
+            return true;
+        }
+        if (this.showHelp) {
+            this.showHelp = false;
+            this.setMessage(`  ${style.boldCyan("←→")} ${style.dim("tabs")}  ${style.boldCyan("↑↓")} ${style.dim("move")}  ${style.boldCyan("↵")} ${style.dim("activate")}  ${style.boldCyan("?")} ${style.dim("help")}`);
+            return true;
+        }
+        return this.navMode === "input" ? this.handleInputKey(key) : handleNavigateKey(this.asNavigationHost(), key);
+    }
+    async handleInputKey(key) {
+        if (key === "\x03")
+            return false;
+        if (key === "\x1b") {
+            this.cancelInput();
+            return true;
+        }
+        if (key === "\r" || key === "\n") {
+            await this.submitInput();
+            return true;
+        }
+        if (key === "\x7f" || key === "\x08") {
+            this.inputBuf = this.inputBuf.slice(0, -1);
+            return true;
+        }
+        if (key.startsWith("\x1b["))
+            return true;
+        if (key.length === 1 && key.charCodeAt(0) >= 32) {
+            this.inputBuf += key;
+            return true;
+        }
+        return true;
+    }
+    // ── Doctor snapshot ────────────────────────────────────────────────────
+    async doctorSnapshot() {
+        if (this.healthCache && Date.now() - this.healthCache.at < 10_000)
+            return this.healthCache.result;
+        const result = await this.deps.runDoctor(this.phrenPath, false);
+        this.healthCache = { at: Date.now(), result };
+        return result;
+    }
+    // ── Render (delegates to shell-view.ts) ────────────────────────────────
+    async render() {
+        const ctx = {
+            phrenPath: this.phrenPath, profile: this.profile, state: this.state,
+            currentCursor: () => this.currentCursor(), currentScroll: () => this.currentScroll(),
+            setScroll: (n) => this.setScroll(n),
+        };
+        return renderShell(ctx, this.navMode, this.inputCtx, this.inputBuf, this.showHelp, this.message, () => this.doctorSnapshot(), this._subsectionsCache, (n) => { this.healthLineCount = n; }, (c) => { this._subsectionsCache = c; });
+    }
+    // ── Navigation host adapter ────────────────────────────────────────────
+    asNavigationHost() {
+        const self = this;
+        return {
+            phrenPath: this.phrenPath, profile: this.profile, state: this.state, deps: this.deps,
+            get showHelp() { return self.showHelp; }, set showHelp(v) { self.showHelp = v; },
+            get healthCache() { return self.healthCache; }, set healthCache(v) { self.healthCache = v; },
+            get prevHealthView() { return self.prevHealthView; }, set prevHealthView(v) { self.prevHealthView = v; },
+            get filter() { return self.state.filter; },
+            get inputMqId() { return self.inputMqId; }, set inputMqId(v) { self.inputMqId = v; },
+            setMessage: (msg) => this.setMessage(msg), setView: (view) => this.setView(view),
+            setFilter: (value) => this.setFilter(value),
+            confirmThen: (label, action) => this.confirmThen(label, action),
+            snapshotForUndo: (label, file) => this.snapshotForUndo(label, file),
+            ensureProjectSelected: () => this.ensureProjectSelected(),
+            invalidateSubsectionsCache: () => this.invalidateSubsectionsCache(),
+            popUndo: () => this.popUndo(),
+            currentCursor: () => this.currentCursor(),
+            setCursor: (n) => this.setCursor(n),
+            moveCursor: (delta) => this.moveCursor(delta),
+            getListItems: () => this.getListItems(),
+            startInput: (ctx, initial) => this.startInput(ctx, initial),
+        };
+    }
+    // ── Palette (delegates to shell-input.ts) ──────────────────────────────
+    async runPalette(input) {
+        await executePalette(this.asNavigationHost(), input);
+    }
+    async handleInput(raw) {
+        const input = raw.trim();
+        if (this.pendingConfirm) {
+            const pending = this.pendingConfirm;
+            this.pendingConfirm = undefined;
+            if (input.toLowerCase() === "y") {
+                pending.action();
+            }
+            else {
+                this.setMessage("  Cancelled.");
+            }
+            return true;
+        }
+        if (this.showHelp) {
+            this.showHelp = false;
+            this.setMessage(`  ${style.boldCyan("←→")} ${style.dim("tabs")}  ${style.boldCyan("↑↓")} ${style.dim("move")}  ${style.boldCyan("↵")} ${style.dim("activate")}  ${style.boldCyan("?")} ${style.dim("help")}`);
+            if (!input)
+                return true;
+        }
+        if (!input)
+            return true;
+        if (["q", "quit", ":q", ":quit", ":exit"].includes(input.toLowerCase()))
+            return false;
+        if (input === "p") {
+            this.setView("Projects");
+            this.setMessage(`  ${TAB_ICONS.Projects} Projects`);
+            return true;
+        }
+        if (input === "b") {
+            if (!this.state.project) {
+                this.setMessage(style.dim("  Select a project first (↵)"));
+                return true;
+            }
+            this.setView("Tasks");
+            this.setMessage(`  ${TAB_ICONS.Tasks} Tasks`);
+            return true;
+        }
+        if (input === "l") {
+            if (!this.state.project) {
+                this.setMessage(style.dim("  Select a project first (↵)"));
+                return true;
+            }
+            this.setView("Findings");
+            this.setMessage(`  ${TAB_ICONS.Findings} Fragments`);
+            return true;
+        }
+        if (input === "m") {
+            if (!this.state.project) {
+                this.setMessage(style.dim("  Select a project first (↵)"));
+                return true;
+            }
+            this.setView("Review Queue");
+            this.setMessage(`  ${TAB_ICONS["Review Queue"]} Review Queue`);
+            return true;
+        }
+        if (input === "s") {
+            if (!this.state.project) {
+                this.setMessage(style.dim("  Select a project first (↵)"));
+                return true;
+            }
+            this.setView("Skills");
+            this.setMessage(`  ${TAB_ICONS.Skills} Skills`);
+            return true;
+        }
+        if (input === "k") {
+            this.setView("Hooks");
+            this.setMessage(`  ${TAB_ICONS.Hooks} Hooks`);
+            return true;
+        }
+        if (input === "h") {
+            this.healthCache = undefined;
+            this.setView("Health");
+            this.setMessage(`  ${TAB_ICONS.Health} Health`);
+            return true;
+        }
+        if (input.startsWith("/")) {
+            this.setFilter(input.slice(1));
+            return true;
+        }
+        if (input.startsWith(":")) {
+            await this.runPalette(input.slice(1));
+            return true;
+        }
+        await this.runPalette(input);
+        return true;
+    }
+    completeInput(line) {
+        return completeInputFn(line, this.phrenPath, this.profile, this.state);
+    }
+}
+export { startShell } from "./shell-entry.js";

package/mcp/dist/skill-files.js

@@ -0,0 +1,117 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homePath } from "./shared.js";
+import { findProjectDir } from "./project-locator.js";
+import { buildSkillManifest } from "./skill-registry.js";
+import { setSkillEnabled } from "./skill-state.js";
+import { errorMessage } from "./utils.js";
+function normalizeSkillRemovalTarget(skillPath) {
+    if (!skillPath)
+        return skillPath;
+    if (path.basename(skillPath).toLowerCase() === "skill.md") {
+        return path.dirname(skillPath);
+    }
+    return skillPath;
+}
+function symlinkManagedSkill(src, dest, managedRoot) {
+    try {
+        const stat = fs.lstatSync(dest);
+        if (stat.isSymbolicLink()) {
+            const currentTarget = fs.readlinkSync(dest);
+            const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
+            const managedPrefix = path.resolve(managedRoot) + path.sep;
+            if (resolvedTarget === path.resolve(src))
+                return;
+            if (!resolvedTarget.startsWith(managedPrefix))
+                return;
+            fs.unlinkSync(dest);
+        }
+        else {
+            return;
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.symlinkSync(src, dest);
+}
+function removeManagedSkillLink(dest, managedRoot) {
+    try {
+        const stat = fs.lstatSync(dest);
+        if (!stat.isSymbolicLink())
+            return;
+        const currentTarget = fs.readlinkSync(dest);
+        const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
+        const managedPrefix = path.resolve(managedRoot) + path.sep;
+        if (!resolvedTarget.startsWith(managedPrefix))
+            return;
+        fs.unlinkSync(dest);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT" && (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG)) {
+            process.stderr.write(`[phren] removeManagedSkillLink: ${errorMessage(err)}\n`);
+        }
+    }
+}
+function writeSkillArtifacts(destDir, manifest) {
+    const parentDir = path.dirname(destDir);
+    fs.mkdirSync(parentDir, { recursive: true });
+    fs.writeFileSync(path.join(parentDir, "skill-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    fs.writeFileSync(path.join(parentDir, "skill-commands.json"), `${JSON.stringify({
+        scope: manifest.scope,
+        project: manifest.project,
+        generatedAt: manifest.generatedAt,
+        commands: manifest.commands.filter((command) => command.registered),
+        problems: manifest.problems,
+    }, null, 2)}\n`);
+}
+export function syncScopeSkillsToDir(phrenPath, scope, destDir) {
+    const manifest = buildSkillManifest(phrenPath, "", scope, destDir);
+    const expectedNames = new Set();
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const skill of manifest.skills) {
+        const destName = skill.format === "folder" ? skill.name : path.basename(skill.path);
+        const destPath = path.join(destDir, destName);
+        if (!skill.visibleToAgents) {
+            removeManagedSkillLink(destPath, phrenPath);
+            continue;
+        }
+        expectedNames.add(destName);
+        symlinkManagedSkill(skill.root, destPath, phrenPath);
+    }
+    for (const entry of fs.readdirSync(destDir)) {
+        if (expectedNames.has(entry))
+            continue;
+        removeManagedSkillLink(path.join(destDir, entry), phrenPath);
+    }
+    writeSkillArtifacts(destDir, manifest);
+    return manifest;
+}
+export function syncSkillLinksForScope(phrenPath, scope) {
+    if (scope.toLowerCase() === "global") {
+        return syncScopeSkillsToDir(phrenPath, "global", homePath(".claude", "skills"));
+    }
+    const projectDir = findProjectDir(scope);
+    if (!projectDir)
+        return null;
+    return syncScopeSkillsToDir(phrenPath, scope, path.join(projectDir, ".claude", "skills"));
+}
+export function setSkillEnabledAndSync(phrenPath, scope, name, enabled) {
+    setSkillEnabled(phrenPath, scope, name, enabled);
+    syncSkillLinksForScope(phrenPath, scope);
+}
+export function removeSkillPath(skillPath) {
+    const target = normalizeSkillRemovalTarget(skillPath);
+    if (!target || !fs.existsSync(target))
+        return target;
+    const stat = fs.lstatSync(target);
+    if (stat.isDirectory()) {
+        fs.rmSync(target, { recursive: true, force: true });
+    }
+    else {
+        fs.unlinkSync(target);
+    }
+    return target;
+}