@eric0117/agentforge 0.1.0

package/dist/doctor.js

@@ -0,0 +1,223 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readMasterDir } from "./agents/io.js";
+import { AGENTS } from "./agents/index.js";
+import { masterDir, readConfig } from "./agentforge-config.js";
+import { LANG_INSTRUCTIONS } from "./skills-data.js";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+const OK = `${GREEN}✓${RESET}`;
+const WARN = `${YELLOW}⚠${RESET}`;
+const FAIL = `${RED}✗${RESET}`;
+const AGENT_FILES = {
+    claude: { dir: ".claude/skills", guide: "CLAUDE.md" },
+    cursor: { dir: ".cursor/rules", guide: ".cursorrules" },
+    codex: { dir: ".agents/skills", guide: "AGENTS.md" },
+};
+export async function runDoctor(opts) {
+    const root = resolve(opts.pathArg ?? process.cwd());
+    let issues = 0;
+    let warnings = 0;
+    console.log(`${BOLD}🩺 agentforge doctor${RESET}  ${DIM}${root}${RESET}\n`);
+    // ── Workspace ──────────────────────────────────────────────────────
+    console.log(`${BOLD}Workspace${RESET}`);
+    const cfg = readConfig(root);
+    if (!cfg) {
+        console.log(`  ${FAIL} not initialized — no agentforge/config.json`);
+        console.log(`    ${DIM}run ${CYAN}agentforge init${RESET}${DIM} here to set one up${RESET}\n`);
+        printToolsSection();
+        process.exit(1);
+    }
+    console.log(`  ${OK} config.json  ${DIM}(v${1}, lang=${cfg.lang}, agents=${cfg.agents.join(", ") || "—"})${RESET}`);
+    const md = masterDir(root);
+    if (!existsSync(md)) {
+        console.log(`  ${FAIL} master skills directory missing: ${md}`);
+        issues++;
+    }
+    else {
+        const { skills, skipped, warnings: masterWarnings } = readMasterDir(md);
+        console.log(`  ${OK} master skills  ${DIM}(${skills.length} valid)${RESET}`);
+        if (skipped.length > 0) {
+            console.log(`  ${FAIL} ${skipped.length} invalid master file(s) — ${DIM}skipped during sync${RESET}`);
+            for (const s of skipped) {
+                console.log(`    ${DIM}- ${s.file}: ${s.reason}${RESET}`);
+            }
+            issues += skipped.length;
+        }
+        if (masterWarnings.length > 0) {
+            console.log(`  ${WARN} ${masterWarnings.length} master file warning(s)`);
+            for (const w of masterWarnings) {
+                console.log(`    ${DIM}- ${w.file}: ${w.warning}${RESET}`);
+            }
+            warnings += masterWarnings.length;
+        }
+    }
+    // ── Agents ─────────────────────────────────────────────────────────
+    console.log(`\n${BOLD}Agents${RESET}`);
+    if (cfg.agents.length === 0) {
+        console.log(`  ${WARN} no agents installed — run ${CYAN}agentforge add-agent${RESET}`);
+        warnings++;
+    }
+    else {
+        const masterIds = existsSync(md)
+            ? new Set(readMasterDir(md).skills.map((s) => s.id))
+            : new Set();
+        for (const id of cfg.agents) {
+            const adapter = AGENTS.find((a) => a.id === id);
+            const label = adapter?.label ?? id;
+            const { dir, guide } = AGENT_FILES[id];
+            const dirAbs = join(root, dir);
+            const guideAbs = join(root, guide);
+            const dirExists = existsSync(dirAbs);
+            const guideExists = existsSync(guideAbs);
+            const present = dirExists ? countSkills(id, dirAbs) : new Set();
+            const missing = [...masterIds].filter((mid) => !present.has(mid));
+            const orphans = [...present].filter((pid) => !masterIds.has(pid));
+            if (!dirExists || !guideExists) {
+                console.log(`  ${FAIL} ${label}  ${DIM}${!dirExists ? `${dir} missing` : `${guide} missing`}${RESET}`);
+                console.log(`    ${DIM}run ${CYAN}agentforge sync-skills${RESET}${DIM} to regenerate${RESET}`);
+                issues++;
+                continue;
+            }
+            const noteParts = [`${present.size} skill${present.size === 1 ? "" : "s"}`];
+            if (missing.length > 0)
+                noteParts.push(`${YELLOW}${missing.length} not propagated${DIM}`);
+            if (orphans.length > 0)
+                noteParts.push(`${YELLOW}${orphans.length} orphan${DIM}`);
+            const mark = missing.length === 0 && orphans.length === 0 ? OK : WARN;
+            console.log(`  ${mark} ${label}  ${DIM}(${noteParts.join(", ")})${RESET}`);
+            if (missing.length > 0) {
+                console.log(`    ${DIM}missing:${RESET} ${missing.join(", ")}  ${DIM}→ ${CYAN}agentforge sync-skills${RESET}`);
+                warnings++;
+            }
+            if (orphans.length > 0) {
+                console.log(`    ${DIM}orphan: ${orphans.join(", ")}  → ${CYAN}agentforge remove-skill <id>${RESET}`);
+                warnings++;
+            }
+        }
+        // Whole-agent orphans: agent dir/guide present but agent NOT in config.
+        // Happens when the user manually deletes from config or copies an
+        // existing tree from elsewhere.
+        for (const id of Object.keys(AGENT_FILES)) {
+            if (cfg.agents.includes(id))
+                continue;
+            const { dir, guide } = AGENT_FILES[id];
+            const hasDir = existsSync(join(root, dir));
+            const hasGuide = existsSync(join(root, guide));
+            if (hasDir || hasGuide) {
+                const label = AGENTS.find((a) => a.id === id)?.label ?? id;
+                const which = [hasDir ? dir : null, hasGuide ? guide : null]
+                    .filter(Boolean)
+                    .join(", ");
+                console.log(`  ${WARN} ${label}  ${DIM}files present but not in config: ${which}${RESET}`);
+                console.log(`    ${DIM}→ ${CYAN}agentforge add-agent ${id}${RESET}${DIM} to re-register, or ${CYAN}agentforge remove-agent ${id}${RESET}${DIM} to clean up${RESET}`);
+                warnings++;
+            }
+        }
+    }
+    // ── Lang drift ─────────────────────────────────────────────────────
+    // config.lang is supposed to reflect what's actually written into master
+    // skills (the {{OUTPUT_LANGUAGE_INSTRUCTION}} placeholder is substituted at
+    // init time). If someone edited config.lang by hand, the master content
+    // now lies — agents will respond in the wrong language.
+    const drift = detectLangDrift(md, cfg.lang);
+    if (drift) {
+        console.log(`\n${BOLD}Language${RESET}`);
+        console.log(`  ${WARN} config.lang=${BOLD}${cfg.lang}${RESET}${DIM} but master files were written for ${BOLD}${drift}${RESET}${DIM}.${RESET}`);
+        console.log(`    ${DIM}→ ${CYAN}agentforge init ${root} --lang ${cfg.lang} --force-skills${RESET}${DIM} to rewrite master files, then ${CYAN}agentforge sync-skills${RESET}`);
+        warnings++;
+    }
+    // ── External tools ─────────────────────────────────────────────────
+    printToolsSection();
+    // ── Summary ────────────────────────────────────────────────────────
+    console.log(`${BOLD}Summary${RESET}`);
+    if (issues === 0 && warnings === 0) {
+        console.log(`  ${OK} workspace is healthy.`);
+        process.exit(0);
+    }
+    if (issues > 0)
+        console.log(`  ${FAIL} ${issues} issue${issues === 1 ? "" : "s"}`);
+    if (warnings > 0)
+        console.log(`  ${WARN} ${warnings} warning${warnings === 1 ? "" : "s"}`);
+    process.exit(issues > 0 ? 1 : 0);
+}
+/**
+ * Walk master skills and decide which lang their substituted
+ * {{OUTPUT_LANGUAGE_INSTRUCTION}} block actually matches. Returns the
+ * detected lang if it differs from `expected`, or null if they agree (or if
+ * we can't tell — e.g. no master files, or no language section).
+ */
+function detectLangDrift(md, expected) {
+    if (!existsSync(md))
+        return null;
+    const langs = ["en", "ko", "ja"];
+    const entries = readdirSync(md, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".md"))
+        .map((e) => e.name)
+        .slice(0, 3); // sample a few; checking all 9 would be wasteful
+    if (entries.length === 0)
+        return null;
+    for (const file of entries) {
+        let body;
+        try {
+            body = readFileSync(join(md, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const l of langs) {
+            if (body.includes(LANG_INSTRUCTIONS[l])) {
+                return l === expected ? null : l;
+            }
+        }
+    }
+    return null;
+}
+function countSkills(agent, dir) {
+    const ids = new Set();
+    if (!existsSync(dir))
+        return ids;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        if (agent === "claude" && e.isDirectory())
+            ids.add(e.name);
+        else if (agent === "cursor" && e.isFile() && e.name.endsWith(".mdc"))
+            ids.add(e.name.slice(0, -4));
+        else if (agent === "codex" && e.isFile() && e.name.endsWith(".md"))
+            ids.add(e.name.slice(0, -3));
+    }
+    return ids;
+}
+function printToolsSection() {
+    console.log(`\n${BOLD}External tools${RESET}`);
+    printTool("git", ["--version"], "required for worktrees + history");
+    printTool("gh", ["--version"], "needed by pr-create / pr-review-analyze / incident-context");
+    const editor = process.env["VISUAL"] || process.env["EDITOR"];
+    if (editor) {
+        console.log(`  ${OK} $EDITOR  ${DIM}${editor}${RESET}`);
+    }
+    else {
+        console.log(`  ${WARN} $EDITOR not set  ${DIM}— ${CYAN}agentforge add-skill${RESET}${DIM} falls back to vim/nano${RESET}`);
+    }
+    console.log(`  ${OK} node  ${DIM}${process.version}${RESET}\n`);
+}
+function printTool(cmd, args, purpose) {
+    try {
+        const out = execSync(`${cmd} ${args.join(" ")}`, {
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim()
+            .split("\n")[0];
+        console.log(`  ${OK} ${cmd}  ${DIM}${out}${RESET}`);
+    }
+    catch {
+        console.log(`  ${FAIL} ${cmd} not found  ${DIM}— ${purpose}${RESET}`);
+    }
+}

package/dist/enter.js

@@ -0,0 +1,85 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { configPath } from "./agentforge-config.js";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+export async function runEnter(opts) {
+    const root = findWorkspaceRoot(process.cwd());
+    if (!root) {
+        process.stderr.write(`\n${YELLOW}⚠${RESET} Not inside an agentforge workspace.\n` +
+            `  ${DIM}cwd: ${process.cwd()}${RESET}\n\n` +
+            `  Run ${CYAN}agentforge enter${RESET} from a workspace directory (one containing ${CYAN}agentforge/config.json${RESET}).\n\n`);
+        process.exit(1);
+    }
+    const anvilDir = join(root, "anvil");
+    const features = listFeatures(anvilDir);
+    if (!opts.slug) {
+        if (features.length === 0) {
+            process.stderr.write(`\n${YELLOW}⚠${RESET} No active features in ${DIM}${anvilDir}${RESET}.\n\n` +
+                `  Start one with ${CYAN}claude${RESET} → "let's start a new feature".\n\n`);
+            process.exit(1);
+        }
+        process.stderr.write(`\nusage: ${CYAN}agentforge enter <slug>${RESET}\n\nActive features:\n` +
+            features.map((f) => `  ${CYAN}${f}${RESET}`).join("\n") +
+            `\n\n`);
+        process.exit(1);
+    }
+    const target = join(anvilDir, opts.slug);
+    if (!existsSync(target) || !statSync(target).isDirectory()) {
+        process.stderr.write(`\n${RED}✗${RESET} Feature not found: ${CYAN}${opts.slug}${RESET}\n` +
+            `  ${DIM}expected: ${target}${RESET}\n\n`);
+        if (features.length > 0) {
+            process.stderr.write(`Active features:\n` +
+                features.map((f) => `  ${CYAN}${f}${RESET}`).join("\n") +
+                `\n\n`);
+        }
+        process.exit(1);
+    }
+    process.stdout.write(`${DIM}→ ${target}${RESET}\n${DIM}→ launching claude…${RESET}\n`);
+    const child = spawn("claude", [], { cwd: target, stdio: "inherit" });
+    child.on("error", (err) => {
+        const e = err;
+        if (e.code === "ENOENT") {
+            process.stderr.write(`\n${RED}✗${RESET} ${CYAN}claude${RESET} command not found on PATH.\n\n` +
+                `  Install Claude Code: ${CYAN}https://claude.com/claude-code${RESET}\n\n`);
+        }
+        else {
+            process.stderr.write(`\n${RED}✗${RESET} failed to launch claude: ${e.message}\n\n`);
+        }
+        process.exit(1);
+    });
+    child.on("exit", (code, signal) => {
+        if (signal)
+            process.kill(process.pid, signal);
+        else
+            process.exit(code ?? 0);
+    });
+}
+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 listFeatures(anvilDir) {
+    if (!existsSync(anvilDir))
+        return [];
+    try {
+        return readdirSync(anvilDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/init.js

@@ -0,0 +1,272 @@
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { pickAgents } from "./agent-prompt.js";
+import { ensureDir, readMasterDir, renderTemplate, setVerbose, writeRendered, } from "./agents/io.js";
+import { getAgent } from "./agents/index.js";
+import { configPath, masterDir, upsertConfig } from "./agentforge-config.js";
+import { pickLanguage } from "./lang-prompt.js";
+import { printLogo } from "./logo.js";
+import { promptPath } from "./path-prompt.js";
+import { pickSkills } from "./skill-prompt.js";
+import { LANG_LABEL, SKILLS } from "./skills-data.js";
+const BASE_DIRS = ["repos", "anvil", "artifacts"];
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+export async function runInit(opts) {
+    // Pre-flight validation (before logo / prompts) for the explicit-path case.
+    if (opts.pathArg) {
+        const targetAbs = resolve(opts.pathArg);
+        // (a) refuse filesystem root — would try to mkdir /repos, /anvil etc.
+        if (targetAbs === dirname(targetAbs)) {
+            process.stderr.write(`\nerror: ${targetAbs} is the filesystem root — pick a real directory to host the workspace.\n\n`);
+            process.exit(1);
+        }
+        // (b) refuse if target sits inside another agentforge workspace —
+        //     workspaces shouldn't nest (repos/ is meant for git checkouts).
+        if (!opts.forceSkills && !opts.forceClaude) {
+            const outer = findEnclosingWorkspace(targetAbs);
+            if (outer && outer !== targetAbs) {
+                process.stderr.write(`\n${YELLOW}⚠${RESET} ${targetAbs} sits inside another agentforge workspace:\n` +
+                    `  ${DIM}${outer}${RESET}\n\n` +
+                    `  Workspaces shouldn't nest. ${DIM}repos/${RESET} is meant for ${BOLD}git checkouts${RESET}, not nested workspaces.\n` +
+                    `  Pick a path outside ${DIM}${outer}${RESET}, or pass ${CYAN}--force${RESET} to override.\n\n`);
+                process.exit(1);
+            }
+        }
+        // (c) already-initialized? — block re-init (drift trap from earlier).
+        if (!opts.forceSkills && !opts.forceClaude && existsSync(configPath(targetAbs))) {
+            printAlreadyInitialized(targetAbs);
+            process.exit(1);
+        }
+        // (d) dir exists and has unrelated content — refuse before scrambling
+        //     workspace files in among the user's project.
+        if (!opts.forceSkills && !opts.forceClaude) {
+            const intruders = unexpectedEntries(targetAbs);
+            if (intruders.length > 0) {
+                printNotEmpty(targetAbs, intruders);
+                process.exit(1);
+            }
+        }
+    }
+    printLogo();
+    const targetPath = await resolveTargetPath(opts);
+    const targetAbs = resolve(targetPath);
+    // Same checks for the interactive path (no --path arg given).
+    if (!opts.forceSkills &&
+        !opts.forceClaude &&
+        existsSync(configPath(targetAbs))) {
+        printAlreadyInitialized(targetAbs);
+        process.exit(1);
+    }
+    if (!opts.forceSkills && !opts.forceClaude) {
+        const intruders = unexpectedEntries(targetAbs);
+        if (intruders.length > 0) {
+            printNotEmpty(targetAbs, intruders);
+            process.exit(1);
+        }
+    }
+    const agentIds = await resolveAgents(opts);
+    const lang = await resolveLanguage(opts);
+    const selectedSkills = await selectSkills(opts, lang);
+    const root = resolve(targetPath);
+    if (!existsSync(root)) {
+        mkdirSync(root, { recursive: true });
+    }
+    // Workspace skeleton — quiet, one summary line.
+    setVerbose(false);
+    for (const dir of BASE_DIRS) {
+        ensureDir(join(root, dir), dir);
+    }
+    ensureDir(masterDir(root), "agentforge/skills");
+    setVerbose(true);
+    line(`${GREEN}+${RESET} workspace skeleton  ${DIM}(${BASE_DIRS.join("/, ")}/, agentforge/)${RESET}`);
+    // Master skills — quiet writes, one summary line.
+    setVerbose(false);
+    let written = 0;
+    for (const s of selectedSkills) {
+        const rendered = renderTemplate(s.template, lang);
+        const destAbs = join(masterDir(root), `${s.id}.md`);
+        const destRel = `agentforge/skills/${s.id}.md`;
+        writeRendered(destAbs, destRel, rendered, opts.forceSkills);
+        written++;
+    }
+    upsertConfig(root, { version: 1, lang, agents: agentIds });
+    setVerbose(true);
+    line(`${GREEN}+${RESET} master skills        ${DIM}(${written} skill${written === 1 ? "" : "s"} → agentforge/skills/, + agentforge/config.json)${RESET}`);
+    // Adapter installs — quiet, one line per agent.
+    const { skills: masterSkills, skipped } = readMasterDir(masterDir(root));
+    if (skipped.length > 0) {
+        for (const sk of skipped) {
+            line(`  ${DIM}skipped master file ${sk.file} — ${sk.reason}${RESET}`);
+        }
+    }
+    setVerbose(false);
+    try {
+        for (const id of agentIds) {
+            const adapter = getAgent(id);
+            adapter.install({
+                root,
+                masterSkills,
+                skillCatalog: SKILLS.slice(),
+                lang,
+                forceSkills: opts.forceSkills,
+                forceClaude: opts.forceClaude,
+            });
+            line(`${GREEN}+${RESET} ${adapter.label.padEnd(18)} ${DIM}(${adapter.outputSummary})${RESET}`);
+        }
+    }
+    finally {
+        setVerbose(true);
+    }
+    printNextSteps(root, agentIds, lang);
+}
+async function resolveTargetPath(opts) {
+    if (opts.pathArg)
+        return opts.pathArg;
+    if (opts.yes)
+        return process.cwd();
+    return promptPath("Workspace directory", process.cwd());
+}
+async function resolveAgents(opts) {
+    if (opts.agents && opts.agents.length > 0)
+        return opts.agents;
+    if (opts.yes)
+        return ["claude"];
+    // requireAtLeastOne: interactive picker won't return [] — it re-prompts.
+    return pickAgents(opts.lang ?? "en", { requireAtLeastOne: true });
+}
+async function resolveLanguage(opts) {
+    if (opts.lang)
+        return opts.lang;
+    if (opts.yes)
+        return "en";
+    return pickLanguage();
+}
+async function selectSkills(opts, lang) {
+    if (opts.yes)
+        return SKILLS.slice();
+    const ids = await pickSkills(SKILLS.map((s) => ({
+        id: s.id,
+        title: s.title,
+        description: s.description[lang],
+        details: s.details[lang],
+    })));
+    return SKILLS.filter((s) => ids.includes(s.id));
+}
+function printNextSteps(root, agentIds, lang) {
+    const repos = join(root, "repos");
+    const repoCount = existsSync(repos)
+        ? readdirSync(repos, { withFileTypes: true }).filter((d) => d.isDirectory())
+            .length
+        : 0;
+    console.log("");
+    console.log(`${BOLD}${GREEN}✓${RESET} workspace ready at ${CYAN}${root}${RESET}  ${DIM}(lang: ${LANG_LABEL[lang]})${RESET}`);
+    console.log("");
+    console.log(`${BOLD}Next steps:${RESET}`);
+    if (repoCount === 0) {
+        console.log(`  cd ${root}/repos && git clone <repo-url>    ${DIM}# add repos to work with${RESET}`);
+        console.log(`  cd ${root} && ${launchHint(agentIds)}        ${DIM}# launch your agent${RESET}`);
+    }
+    else {
+        console.log(`  ${DIM}(found ${repoCount} repo${repoCount === 1 ? "" : "s"} in repos/)${RESET}`);
+        console.log(`  cd ${root} && ${launchHint(agentIds)}`);
+    }
+    console.log("");
+    console.log(`${BOLD}Useful commands:${RESET}`);
+    console.log(`  ${CYAN}agentforge list-skills${RESET}        ${DIM}# see what's installed${RESET}`);
+    console.log(`  ${CYAN}agentforge add-skill${RESET}          ${DIM}# create your own skill${RESET}`);
+    console.log(`  ${CYAN}agentforge sync-skills${RESET}        ${DIM}# propagate master edits to all agents${RESET}`);
+    console.log(`  ${CYAN}agentforge add-agent${RESET}          ${DIM}# add another agent later${RESET}`);
+    console.log("");
+}
+function launchHint(agentIds) {
+    const cmds = agentIds.map((id) => {
+        switch (id) {
+            case "claude":
+                return "claude";
+            case "cursor":
+                return "cursor .";
+            case "codex":
+                return "codex";
+        }
+    });
+    return cmds.join("  /  ");
+}
+function line(s) {
+    console.log(s);
+}
+/** Files / dirs that agentforge owns at the workspace root. Anything else
+ * in the target dir means the user picked a path that's already in use. */
+const WORKSPACE_ENTRIES = new Set([
+    ...BASE_DIRS,
+    "agentforge",
+    ".claude",
+    ".cursor",
+    ".agents",
+    "CLAUDE.md",
+    "AGENTS.md",
+    ".cursorrules",
+]);
+/**
+ * Return entries in `dir` that don't belong to agentforge. Dotfiles other
+ * than agentforge's own (`.claude`, `.cursor`, `.agents`, `.cursorrules`) are
+ * surfaced too — `.git/`, `.env`, IDE folders etc. mean this is already
+ * someone's project.
+ */
+function unexpectedEntries(dir) {
+    if (!existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((name) => name !== ".DS_Store") // macOS OS noise
+        .filter((name) => !WORKSPACE_ENTRIES.has(name))
+        .sort();
+}
+function printNotEmpty(targetAbs, intruders) {
+    const preview = intruders.slice(0, 6);
+    const extra = intruders.length - preview.length;
+    const list = preview
+        .map((n) => `    ${DIM}-${RESET} ${n}`)
+        .join("\n");
+    const more = extra > 0 ? `\n    ${DIM}… and ${extra} more${RESET}` : "";
+    process.stderr.write(`\n${YELLOW}⚠${RESET} ${targetAbs} isn't empty.\n\n` +
+        `  It contains files that don't look like agentforge:\n${list}${more}\n\n` +
+        `  agentforge would overlay its workspace structure (${DIM}repos/, anvil/, artifacts/, agentforge/${RESET}) on top.\n` +
+        `  Pick an empty directory, or pass ${CYAN}--force${RESET} to proceed anyway (existing files are not touched, only the workspace structure is added).\n\n`);
+}
+/**
+ * Walk up from `start` looking for a parent directory that has
+ * `agentforge/config.json`. Returns the workspace root if found, else null.
+ * Returns `start` itself if `start` is already a workspace.
+ */
+function findEnclosingWorkspace(start) {
+    let cur = start;
+    while (true) {
+        if (existsSync(configPath(cur)))
+            return cur;
+        const parent = dirname(cur);
+        if (parent === cur)
+            return null; // reached FS root
+        cur = parent;
+    }
+}
+function printAlreadyInitialized(targetAbs) {
+    process.stderr.write(`\n${YELLOW}⚠${RESET} ${targetAbs} is already an agentforge workspace.\n\n` +
+        `  Use one of these instead:\n` +
+        `    ${CYAN}agentforge add-agent${RESET}      ${DIM}# install another agent (Claude / Cursor / Codex)${RESET}\n` +
+        `    ${CYAN}agentforge add-skill${RESET}      ${DIM}# create a new skill${RESET}\n` +
+        `    ${CYAN}agentforge sync-skills${RESET}    ${DIM}# propagate master skill edits to every agent${RESET}\n` +
+        `    ${CYAN}agentforge list-skills${RESET}    ${DIM}# see what's installed${RESET}\n` +
+        `    ${CYAN}agentforge doctor${RESET}         ${DIM}# diagnose the workspace${RESET}\n\n` +
+        `  Or pass ${CYAN}--force${RESET} to overwrite everything (existing files are backed up to .bak).\n\n`);
+}

package/dist/lang-prompt.js

@@ -0,0 +1,88 @@
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+const OPTIONS = [
+    { value: "en", label: "English", hint: "" },
+    { value: "ko", label: "한국어", hint: "Korean" },
+    { value: "ja", label: "日本語", hint: "Japanese" },
+];
+async function readKey() {
+    return new Promise((resolve) => {
+        process.stdin.once("data", (chunk) => {
+            resolve(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+        });
+    });
+}
+export async function pickLanguage() {
+    if (!process.stdin.isTTY)
+        return "en";
+    let cursor = 0;
+    let lastLineCount = 0;
+    const HEADER = `${CYAN}?${RESET} ${BOLD}Language${RESET}  ${DIM}↑↓ move · enter confirm${RESET}`;
+    const render = () => {
+        if (lastLineCount > 0) {
+            process.stdout.write(`\x1b[${lastLineCount}A\x1b[J`);
+        }
+        const lines = [HEADER, ""];
+        for (let i = 0; i < OPTIONS.length; i++) {
+            const o = OPTIONS[i];
+            const prefix = i === cursor ? `${CYAN}❯${RESET}` : " ";
+            const label = i === cursor ? `${CYAN}${o.label}${RESET}` : o.label;
+            const hint = o.hint ? `  ${DIM}— ${o.hint}${RESET}` : "";
+            lines.push(`${prefix}  ${label}${hint}`);
+        }
+        const text = lines.join("\n") + "\n";
+        process.stdout.write(text);
+        lastLineCount = text.split("\n").length - 1;
+    };
+    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 && lastLineCount > 0) {
+            process.stdout.write(`\x1b[${lastLineCount}A\x1b[J`);
+        }
+    };
+    render();
+    try {
+        while (true) {
+            const chunk = await readKey();
+            if (chunk === "\x1b[A") {
+                cursor = (cursor - 1 + OPTIONS.length) % OPTIONS.length;
+                render();
+                continue;
+            }
+            if (chunk === "\x1b[B") {
+                cursor = (cursor + 1) % OPTIONS.length;
+                render();
+                continue;
+            }
+            if (chunk.startsWith("\x1b"))
+                continue;
+            for (const ch of chunk) {
+                if (ch === "\x03") {
+                    cleanup(true);
+                    process.stdout.write(`${YELLOW}aborted.${RESET}\n`);
+                    process.exit(130);
+                }
+                if (ch === "\r" || ch === "\n") {
+                    const picked = OPTIONS[cursor];
+                    cleanup(true);
+                    process.stdout.write(`${CYAN}?${RESET} ${BOLD}Language${RESET}  ${DIM}›${RESET} ${picked.label}\n`);
+                    return picked.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        cleanup(true);
+        throw err;
+    }
+}