@eric0117/agentforge 0.1.0

package/dist/rename.js

@@ -0,0 +1,222 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { configPath, requireWorkspace } from "./agentforge-config.js";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+export async function runRename(opts) {
+    if (!opts.oldSlug || !opts.newSlug) {
+        fail(`usage: ${CYAN}agentforge rename <old-slug> <new-slug>${RESET}\n`);
+    }
+    if (opts.oldSlug === opts.newSlug) {
+        fail(`old and new slug are the same: ${opts.oldSlug}\n`);
+    }
+    if (!SLUG_RE.test(opts.newSlug)) {
+        fail(`invalid new slug: ${opts.newSlug}\n  must match /^[a-z0-9][a-z0-9-]*$/ (lowercase, digits, hyphens; start with letter/digit)\n`);
+    }
+    const root = findWorkspaceRoot(opts.pathArg ?? process.cwd());
+    if (!root) {
+        fail(`Not inside an agentforge workspace (looked for ${CYAN}agentforge/config.json${RESET} upward from cwd).\n`);
+    }
+    // Make sure config is valid — also gives a friendly error if not initialized.
+    requireWorkspace(root);
+    const oldDir = join(root, "anvil", opts.oldSlug);
+    const newDir = join(root, "anvil", opts.newSlug);
+    if (!existsSync(oldDir) || !statSync(oldDir).isDirectory()) {
+        fail(`feature not found: ${CYAN}${opts.oldSlug}${RESET}\n  expected: ${oldDir}\n`);
+    }
+    if (existsSync(newDir)) {
+        fail(`target already exists: ${CYAN}${opts.newSlug}${RESET}\n  ${newDir}\n  Pick a different new slug.\n`);
+    }
+    // Discover worktrees inside the feature
+    const repos = readdirSync(oldDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+        .map((e) => e.name)
+        .sort();
+    console.log(`${BOLD}${CYAN}▸${RESET} renaming feature ${CYAN}${opts.oldSlug}${RESET} → ${CYAN}${opts.newSlug}${RESET}`);
+    console.log(`  ${DIM}root: ${root}${RESET}`);
+    console.log(`  ${DIM}worktrees: ${repos.length}${RESET}`);
+    console.log("");
+    const plan = [];
+    for (const repo of repos) {
+        const wt = join(oldDir, repo);
+        let currentBranch = "";
+        let dirty = false;
+        try {
+            currentBranch = execGit(wt, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+        }
+        catch {
+            console.log(`  ${YELLOW}skip:${RESET} ${repo} — not a git worktree (or git unavailable)`);
+            continue;
+        }
+        try {
+            const status = execGit(wt, ["status", "--porcelain"]);
+            dirty = status.trim().length > 0;
+        }
+        catch {
+            // treat unreadable as dirty for safety
+            dirty = true;
+        }
+        const canonical = resolveCanonical(root, repo, wt);
+        plan.push({
+            repo,
+            canonical,
+            currentBranch,
+            dirty,
+            renameBranch: currentBranch === opts.oldSlug,
+        });
+        console.log(`  ${repo}  ${DIM}branch=${currentBranch}${RESET}` +
+            (dirty ? `  ${YELLOW}(dirty)${RESET}` : "") +
+            (currentBranch === opts.oldSlug
+                ? `  ${DIM}→ branch will be renamed to ${opts.newSlug}${RESET}`
+                : `  ${DIM}→ branch stays (per-repo convention)${RESET}`));
+    }
+    console.log("");
+    // Refuse on dirty unless --force
+    const dirtyRepos = plan.filter((p) => p.dirty);
+    if (dirtyRepos.length > 0 && !opts.force) {
+        fail(`${dirtyRepos.length} worktree(s) have uncommitted changes:\n` +
+            dirtyRepos.map((p) => `  - ${p.repo}`).join("\n") +
+            `\n\nCommit/stash first, or pass ${CYAN}--force${RESET} to proceed anyway.\n`);
+    }
+    // Confirm before destructive action unless --yes
+    if (!opts.yes) {
+        console.log(`${YELLOW}!${RESET} This will:\n` +
+            `  • move ${plan.length} worktree dir(s) anvil/${opts.oldSlug}/… → anvil/${opts.newSlug}/…\n` +
+            `  • rename ${plan.filter((p) => p.renameBranch).length} branch(es) named "${opts.oldSlug}" to "${opts.newSlug}"\n` +
+            `  • move anvil/${opts.oldSlug}/CLAUDE.md → anvil/${opts.newSlug}/CLAUDE.md (and rewrite slug references inside)\n` +
+            `  • delete the now-empty anvil/${opts.oldSlug}/\n` +
+            `\nRe-run with ${CYAN}--yes${RESET} to proceed.\n`);
+        process.exit(0);
+    }
+    // Create the new feature dir
+    mkdirSync(newDir, { recursive: true });
+    // Move each worktree
+    for (const p of plan) {
+        const fromWt = join(oldDir, p.repo);
+        const toWt = join(newDir, p.repo);
+        try {
+            execGit(p.canonical, ["worktree", "move", fromWt, toWt]);
+            console.log(`${GREEN}+${RESET} moved worktree: anvil/${opts.oldSlug}/${p.repo} → anvil/${opts.newSlug}/${p.repo}`);
+        }
+        catch (err) {
+            fail(`failed to move worktree for ${p.repo}: ${err.message}\n` +
+                `  Some worktrees may have already moved — inspect anvil/ and re-run after cleanup.\n`);
+        }
+        if (p.renameBranch) {
+            try {
+                execGit(toWt, ["branch", "-m", opts.oldSlug, opts.newSlug]);
+                console.log(`${GREEN}+${RESET} renamed branch: ${p.repo} ${opts.oldSlug} → ${opts.newSlug}`);
+            }
+            catch (err) {
+                console.log(`${YELLOW}!${RESET} branch rename failed for ${p.repo}: ${err.message} (continuing)`);
+            }
+        }
+    }
+    // Move CLAUDE.md + rewrite slug references inside
+    const oldClaudeMd = join(oldDir, "CLAUDE.md");
+    const newClaudeMd = join(newDir, "CLAUDE.md");
+    if (existsSync(oldClaudeMd)) {
+        let body = readFileSync(oldClaudeMd, "utf8");
+        body = body.split(opts.oldSlug).join(opts.newSlug);
+        writeFileSync(newClaudeMd, body);
+        unlinkSync(oldClaudeMd);
+        console.log(`${GREEN}+${RESET} moved CLAUDE.md (and rewrote ${opts.oldSlug} → ${opts.newSlug} inside)`);
+    }
+    // Move any other top-level files (HANDOFF.md, PLAN.md, etc.) and remove the
+    // lock file
+    for (const entry of readdirSync(oldDir, { withFileTypes: true })) {
+        const src = join(oldDir, entry.name);
+        if (entry.name === ".agentforge.lock") {
+            try {
+                unlinkSync(src);
+            }
+            catch {
+                /* ignore */
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            const dst = join(newDir, entry.name);
+            let content = readFileSync(src, "utf8");
+            content = content.split(opts.oldSlug).join(opts.newSlug);
+            writeFileSync(dst, content);
+            unlinkSync(src);
+            console.log(`${GREEN}+${RESET} moved ${entry.name}`);
+        }
+    }
+    // Remove old dir if now empty
+    try {
+        rmdirSync(oldDir);
+        console.log(`${GREEN}+${RESET} removed empty anvil/${opts.oldSlug}/`);
+    }
+    catch (err) {
+        console.log(`${YELLOW}!${RESET} could not remove anvil/${opts.oldSlug}/ — inspect manually: ${err.message}`);
+    }
+    // Append to activity log
+    appendLog(root, {
+        skill: "agentforge-rename",
+        action: "renamed",
+        oldSlug: opts.oldSlug,
+        newSlug: opts.newSlug,
+        repos: plan.map((p) => p.repo).join(","),
+    });
+    console.log("");
+    console.log(`${BOLD}${GREEN}✓${RESET} rename complete`);
+    console.log(`  ${DIM}next: cd anvil/${opts.newSlug}/${RESET}`);
+}
+function execGit(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8" });
+}
+function resolveCanonical(root, repo, worktree) {
+    // Prefer repos/<repo> if it exists; otherwise ask git for the main worktree
+    const candidate = join(root, "repos", repo);
+    if (existsSync(candidate))
+        return candidate;
+    try {
+        const out = execGit(worktree, ["worktree", "list", "--porcelain"]);
+        // The first "worktree <path>" line is the main worktree
+        const m = out.match(/^worktree (.+)$/m);
+        if (m)
+            return m[1];
+    }
+    catch {
+        /* ignore */
+    }
+    return candidate; // best-effort; git worktree move will error if wrong
+}
+function findWorkspaceRoot(start) {
+    let dir = resolve(start);
+    while (true) {
+        if (existsSync(configPath(dir)))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function appendLog(root, fields) {
+    const logPath = join(root, "agentforge", "log.jsonl");
+    mkdirSync(dirname(logPath), { recursive: true });
+    const entry = {
+        ts: new Date().toISOString(),
+        ...fields,
+    };
+    try {
+        writeFileSync(logPath, `${JSON.stringify(entry)}\n`, { flag: "a" });
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+function fail(msg) {
+    process.stderr.write(`\n${RED}✗${RESET} ${msg}\n`);
+    process.exit(1);
+}

package/dist/skill-prompt.js

@@ -0,0 +1,199 @@
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+function wrap(text, width) {
+    const out = [];
+    for (const paragraph of text.split("\n")) {
+        if (paragraph === "") {
+            out.push("");
+            continue;
+        }
+        let line = "";
+        for (const word of paragraph.split(/\s+/)) {
+            if (line.length === 0) {
+                line = word;
+            }
+            else if (line.length + 1 + word.length <= width) {
+                line += " " + word;
+            }
+            else {
+                out.push(line);
+                line = word;
+            }
+        }
+        if (line)
+            out.push(line);
+    }
+    return out;
+}
+async function readKey() {
+    return new Promise((resolve) => {
+        process.stdin.once("data", (chunk) => {
+            resolve(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+        });
+    });
+}
+export async function pickSkills(items) {
+    if (!process.stdin.isTTY) {
+        return items.map((i) => i.id);
+    }
+    let cursor = 0;
+    const selected = new Set(items.map((i) => i.id));
+    let view = "list";
+    let lastLineCount = 0;
+    const HEADER_LIST = `${CYAN}?${RESET} ${BOLD}Skills to install${RESET}  ${DIM}↑↓ move · space toggle · → details · enter confirm${RESET}`;
+    const headerDetails = (title, idx, total) => `${CYAN}?${RESET} ${BOLD}${title}${RESET}  ${DIM}(${idx}/${total})   ↑↓ next · ← back${RESET}`;
+    const renderList = () => {
+        const lines = [HEADER_LIST, ""];
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const isSel = selected.has(item.id);
+            const isCur = i === cursor;
+            const marker = isSel ? `${GREEN}◉${RESET}` : `${DIM}◯${RESET}`;
+            const prefix = isCur ? `${CYAN}❯${RESET}` : " ";
+            const title = isCur ? `${CYAN}${item.title}${RESET}` : item.title;
+            lines.push(`${prefix} ${marker}  ${title}  ${DIM}— ${item.description}${RESET}`);
+        }
+        return lines.join("\n") + "\n";
+    };
+    const renderDetails = () => {
+        const item = items[cursor];
+        const isSel = selected.has(item.id);
+        const status = isSel
+            ? `${GREEN}◉ selected${RESET}`
+            : `${DIM}◯ not selected${RESET}`;
+        const width = Math.min((process.stdout.columns || 80) - 4, 78);
+        const bar = `${DIM}${"─".repeat(width)}${RESET}`;
+        const lines = [
+            headerDetails(item.title, cursor + 1, items.length),
+            `  ${bar}`,
+            "",
+        ];
+        for (const w of wrap(item.details, width - 2)) {
+            lines.push(`  ${w}`);
+        }
+        lines.push("");
+        lines.push(`  ${status}    ${DIM}space toggle · enter confirm${RESET}`);
+        return lines.join("\n") + "\n";
+    };
+    const clear = () => {
+        if (lastLineCount > 0) {
+            process.stdout.write(`\x1b[${lastLineCount}A\x1b[J`);
+        }
+    };
+    const render = () => {
+        clear();
+        const text = view === "list" ? renderList() : renderDetails();
+        process.stdout.write(text);
+        lastLineCount = text.split("\n").length - 1;
+    };
+    // Setup raw mode
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    process.stdout.write("\x1b[?25l"); // hide cursor
+    const cleanup = (clearUi) => {
+        process.stdout.write("\x1b[?25h"); // show cursor
+        stdin.setRawMode(false);
+        stdin.pause();
+        if (clearUi)
+            clear();
+    };
+    render();
+    try {
+        while (true) {
+            const chunk = await readKey();
+            // Whole-chunk escape sequences (arrow keys)
+            if (chunk === "\x1b[A") {
+                cursor = (cursor - 1 + items.length) % items.length;
+                render();
+                continue;
+            }
+            if (chunk === "\x1b[B") {
+                cursor = (cursor + 1) % items.length;
+                render();
+                continue;
+            }
+            if (chunk === "\x1b[C") {
+                if (view === "list") {
+                    view = "details";
+                    render();
+                }
+                continue;
+            }
+            if (chunk === "\x1b[D") {
+                if (view === "details") {
+                    view = "list";
+                    render();
+                }
+                continue;
+            }
+            if (chunk === "\x1b") {
+                // bare ESC
+                if (view === "details") {
+                    view = "list";
+                    render();
+                }
+                continue;
+            }
+            if (chunk.startsWith("\x1b")) {
+                continue; // ignore other escapes
+            }
+            // Per-char
+            let handled = false;
+            for (const ch of chunk) {
+                if (ch === "\x03") {
+                    // Ctrl+C
+                    cleanup(true);
+                    process.stdout.write(`${YELLOW}aborted.${RESET}\n`);
+                    process.exit(130);
+                }
+                if (ch === "\r" || ch === "\n") {
+                    cleanup(true);
+                    const picked = items.filter((i) => selected.has(i.id));
+                    const summary = picked.length > 0
+                        ? picked.map((p) => p.title).join(", ")
+                        : `${DIM}none${RESET}`;
+                    process.stdout.write(`${CYAN}?${RESET} ${BOLD}Skills to install${RESET}  ${DIM}›${RESET} ${summary}\n`);
+                    return picked.map((p) => p.id);
+                }
+                if (ch === " ") {
+                    const item = items[cursor];
+                    if (selected.has(item.id))
+                        selected.delete(item.id);
+                    else
+                        selected.add(item.id);
+                    render();
+                    handled = true;
+                    continue;
+                }
+                // letters could shortcut a/n: select all / select none
+                if (ch === "a") {
+                    for (const it of items)
+                        selected.add(it.id);
+                    render();
+                    handled = true;
+                    continue;
+                }
+                if (ch === "n") {
+                    selected.clear();
+                    render();
+                    handled = true;
+                    continue;
+                }
+            }
+            if (!handled) {
+                // unknown — re-render in case of partial state
+                render();
+            }
+        }
+    }
+    catch (err) {
+        cleanup(true);
+        throw err;
+    }
+}