@eric0117/agentforge 0.1.0

package/dist/agent-prompt.js

@@ -0,0 +1,211 @@
+import { AGENTS } from "./agents/index.js";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const YELLOW = "\x1b[33m";
+const STRIKE = "\x1b[9m";
+const NOSTRIKE = "\x1b[29m";
+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 pickAgents(lang, options = {}) {
+    const disabled = options.disabled ?? new Set();
+    const headerLabel = options.headerLabel ?? "Agents to set up";
+    if (!process.stdin.isTTY) {
+        // safe non-TTY default: pick claude if it's not already installed,
+        // otherwise nothing (caller decides what to do with an empty pick)
+        return disabled.has("claude") ? [] : ["claude"];
+    }
+    let cursor = 0;
+    // default selection: claude (if not already installed)
+    const selected = new Set(disabled.has("claude") ? [] : ["claude"]);
+    let view = "list";
+    let lastLineCount = 0;
+    let errorMessage = ""; // shown when Enter is pressed with nothing selected (when required)
+    const HEADER_LIST = `${CYAN}?${RESET} ${BOLD}${headerLabel}${RESET}  ${DIM}↑↓ move · space toggle · → details · enter confirm${RESET}`;
+    const headerDetails = (label, idx, total) => `${CYAN}?${RESET} ${BOLD}${label}${RESET}  ${DIM}(${idx}/${total})   ↑↓ next · ← back${RESET}`;
+    const renderList = () => {
+        const lines = [HEADER_LIST, ""];
+        for (let i = 0; i < AGENTS.length; i++) {
+            const item = AGENTS[i];
+            const isLocked = disabled.has(item.id);
+            const isSel = selected.has(item.id);
+            const isCur = i === cursor;
+            const prefix = isCur ? `${CYAN}❯${RESET}` : " ";
+            if (isLocked) {
+                const marker = `${DIM}🔒${RESET}`;
+                const title = `${DIM}${STRIKE}${item.label}${NOSTRIKE}${RESET}`;
+                const tag = `${DIM}(already installed)${RESET}`;
+                lines.push(`${prefix} ${marker} ${title}  ${tag}`);
+                continue;
+            }
+            const marker = isSel ? `${GREEN}◉${RESET}` : `${DIM}◯${RESET}`;
+            const title = isCur ? `${CYAN}${item.label}${RESET}` : item.label;
+            lines.push(`${prefix} ${marker}  ${title}`);
+        }
+        if (errorMessage) {
+            lines.push("");
+            lines.push(`  ${YELLOW}⚠${RESET} ${errorMessage}`);
+        }
+        return lines.join("\n") + "\n";
+    };
+    const renderDetails = () => {
+        const item = AGENTS[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.label, cursor + 1, AGENTS.length),
+            `  ${bar}`,
+            "",
+        ];
+        for (const w of wrap(item.details[lang], 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;
+    };
+    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");
+        stdin.setRawMode(false);
+        stdin.pause();
+        if (clearUi)
+            clear();
+    };
+    render();
+    try {
+        while (true) {
+            const chunk = await readKey();
+            if (chunk === "\x1b[A") {
+                cursor = (cursor - 1 + AGENTS.length) % AGENTS.length;
+                render();
+                continue;
+            }
+            if (chunk === "\x1b[B") {
+                cursor = (cursor + 1) % AGENTS.length;
+                render();
+                continue;
+            }
+            if (chunk === "\x1b[C") {
+                if (view === "list") {
+                    view = "details";
+                    render();
+                }
+                continue;
+            }
+            if (chunk === "\x1b[D" || chunk === "\x1b") {
+                if (view === "details") {
+                    view = "list";
+                    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") {
+                    if (selected.size === 0 && options.requireAtLeastOne) {
+                        errorMessage = "Select at least one agent before continuing.";
+                        render();
+                        continue;
+                    }
+                    cleanup(true);
+                    const picked = AGENTS.filter((a) => selected.has(a.id));
+                    const summary = picked.length > 0
+                        ? picked.map((p) => p.label).join(", ")
+                        : `${DIM}none${RESET}`;
+                    process.stdout.write(`${CYAN}?${RESET} ${BOLD}${headerLabel}${RESET}  ${DIM}›${RESET} ${summary}\n`);
+                    return picked.map((p) => p.id);
+                }
+                if (ch === " ") {
+                    // clear any prior "select at least one" warning once they interact
+                    errorMessage = "";
+                    const item = AGENTS[cursor];
+                    if (disabled.has(item.id))
+                        continue;
+                    if (selected.has(item.id))
+                        selected.delete(item.id);
+                    else
+                        selected.add(item.id);
+                    render();
+                    continue;
+                }
+                if (ch === "a") {
+                    errorMessage = "";
+                    for (const a of AGENTS) {
+                        if (!disabled.has(a.id))
+                            selected.add(a.id);
+                    }
+                    render();
+                    continue;
+                }
+                if (ch === "n") {
+                    // clearing all is allowed; if requireAtLeastOne, Enter will surface the warning.
+                    selected.clear();
+                    render();
+                    continue;
+                }
+            }
+        }
+    }
+    catch (err) {
+        cleanup(true);
+        throw err;
+    }
+}

package/dist/agentforge-config.js

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+export const CURRENT_CONFIG_VERSION = 1;
+const CONFIG_PATH = "agentforge/config.json";
+export const MASTER_DIR_REL = "agentforge/skills";
+export function configPath(root) {
+    return join(root, CONFIG_PATH);
+}
+export function masterDir(root) {
+    return join(root, MASTER_DIR_REL);
+}
+/**
+ * Read the workspace config, or print a friendly error and exit if the
+ * directory hasn't been initialized as an agentforge workspace.
+ */
+export function requireWorkspace(root) {
+    const cfg = readConfig(root);
+    if (cfg)
+        return cfg;
+    const YELLOW = "\x1b[33m";
+    const CYAN = "\x1b[36m";
+    const DIM = "\x1b[2m";
+    const RESET = "\x1b[0m";
+    process.stderr.write(`\n${YELLOW}⚠${RESET} Not an agentforge workspace yet.\n` +
+        `  ${DIM}${root}${RESET}\n\n` +
+        `  Run ${CYAN}agentforge init${RESET} here first to set one up.\n\n`);
+    process.exit(1);
+}
+export function readConfig(root) {
+    const p = configPath(root);
+    if (!existsSync(p))
+        return null;
+    // Guard against config.json being a directory (or other non-file).
+    try {
+        if (!statSync(p).isFile()) {
+            throw new Error(`${p} exists but is not a regular file — remove it and re-run \`agentforge init --force\``);
+        }
+    }
+    catch (e) {
+        throw new Error(`failed to read ${p}: ${e.message}`);
+    }
+    try {
+        const raw = JSON.parse(readFileSync(p, "utf8"));
+        if (!raw || typeof raw !== "object")
+            return null;
+        if (raw.version !== CURRENT_CONFIG_VERSION) {
+            // future: migrate
+            throw new Error(`unsupported agentforge/config.json version: ${raw.version}`);
+        }
+        const rawLang = raw.lang ?? "en";
+        if (rawLang !== "en" && rawLang !== "ko" && rawLang !== "ja") {
+            throw new Error(`unsupported lang "${rawLang}" — agentforge supports en | ko | ja. Fix \`lang:\` in agentforge/config.json or re-run \`agentforge init --force-skills\`.`);
+        }
+        const agents = Array.isArray(raw.agents)
+            ? raw.agents.filter((a) => a === "claude" || a === "cursor" || a === "codex")
+            : [];
+        return { version: 1, lang: rawLang, agents };
+    }
+    catch (err) {
+        throw new Error(`failed to read ${p}: ${err.message}`);
+    }
+}
+export function writeConfig(root, cfg) {
+    const p = configPath(root);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, `${JSON.stringify(cfg, null, 2)}\n`);
+}
+/** Merge a partial update into the existing config (or create a fresh one). */
+export function upsertConfig(root, patch) {
+    const existing = readConfig(root);
+    const next = existing
+        ? {
+            version: 1,
+            lang: patch.lang ?? existing.lang,
+            agents: mergeAgents(existing.agents, patch.agents ?? []),
+        }
+        : {
+            version: 1,
+            lang: patch.lang ?? "en",
+            agents: patch.agents ?? [],
+        };
+    writeConfig(root, next);
+    return next;
+}
+/** Replace the agents list outright (used by remove-agent). */
+export function setAgents(root, agents) {
+    const existing = readConfig(root);
+    const next = {
+        version: 1,
+        lang: existing?.lang ?? "en",
+        agents,
+    };
+    writeConfig(root, next);
+    return next;
+}
+function mergeAgents(prev, next) {
+    const seen = new Set();
+    const out = [];
+    for (const a of [...prev, ...next]) {
+        if (!seen.has(a)) {
+            seen.add(a);
+            out.push(a);
+        }
+    }
+    return out;
+}

package/dist/agents/claude.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { ensureDir, renderTemplate, writeRendered } from "./io.js";
+export const ClaudeAdapter = {
+    id: "claude",
+    label: "Claude Code",
+    outputSummary: ".claude/skills/ + CLAUDE.md",
+    details: {
+        en: [
+            "Writes `.claude/skills/<skill-id>/SKILL.md` for each master skill and a root `CLAUDE.md` guide.",
+            "",
+            "Auto-loaded by Claude Code from this workspace. The frontmatter `description` of each skill is what triggers it on matching natural-language prompts — strongest auto-matching of the three.",
+        ].join("\n"),
+        ko: [
+            "각 마스터 스킬을 `.claude/skills/<skill-id>/SKILL.md` 로, 워크스페이스 가이드를 `CLAUDE.md` 로 작성합니다.",
+            "",
+            "Claude Code 가 자동 로드. 각 스킬의 frontmatter `description` 이 자연어 요청에 자동 매칭됩니다 — 셋 중 가장 강한 자동 발동.",
+        ].join("\n"),
+        ja: [
+            "各マスタースキルを `.claude/skills/<skill-id>/SKILL.md` に、ワークスペースガイドを `CLAUDE.md` に書き出します。",
+            "",
+            "Claude Code が自動的に読み込みます。各スキルの frontmatter `description` が自然言語のリクエストに自動マッチします — 三つの中で最も強い自動発動。",
+        ].join("\n"),
+    },
+    install(params) {
+        const { root, masterSkills, forceSkills, forceClaude } = params;
+        ensureDir(join(root, ".claude/skills"), ".claude/skills");
+        for (const s of masterSkills) {
+            ensureDir(join(root, ".claude/skills", s.id), `.claude/skills/${s.id}`);
+        }
+        // root guide
+        const claudeMd = renderGuide(params);
+        writeRendered(join(root, "CLAUDE.md"), "CLAUDE.md", claudeMd, forceClaude);
+        // each skill — master raw content is already language-substituted; write as-is.
+        for (const s of masterSkills) {
+            const destRel = `.claude/skills/${s.id}/SKILL.md`;
+            writeRendered(join(root, destRel), destRel, s.raw, forceSkills);
+        }
+    },
+};
+/**
+ * Workspace guide for Claude Code, rendered from the package template
+ * (separate from master skills).
+ */
+function renderGuide(params) {
+    return renderTemplate("CLAUDE.md.tpl", params.lang);
+}

package/dist/agents/codex.js

@@ -0,0 +1,67 @@
+import { join } from "node:path";
+import { ensureDir, renderTemplate, writeRendered } from "./io.js";
+/**
+ * Convert a master skill into a standalone Codex skill file:
+ *   - drop YAML frontmatter
+ *   - top heading is `# <skill-id>`
+ *   - second paragraph is the original description as plain text
+ *   - then the body, untouched
+ */
+function skillToCodex(skill) {
+    const description = skill.frontmatter["description"] ?? "";
+    return `# ${skill.id}\n\n${description}\n\n${skill.body}`;
+}
+/**
+ * Build AGENTS.md = workspace guide (from CLAUDE.md.tpl) + a Skills section that
+ * lists each master skill with its short description and reference path.
+ */
+function buildAgentsMd(guideBody, skills) {
+    const skillsSection = [
+        "## Skills",
+        "",
+        "This workspace ships skill briefs under `.agents/skills/`. When a user request",
+        "matches a skill's purpose, load and follow that file. The skills:",
+        "",
+        ...skills.map((s) => `- **${s.id}** — ${s.frontmatter["description"] ?? ""}\n  See \`.agents/skills/${s.id}.md\`.`),
+        "",
+        "Auto-discovery on this layout is best-effort. If a skill doesn't trigger,",
+        "say \"use the <skill-id> skill\" to invoke it explicitly.",
+    ].join("\n");
+    return [guideBody.trimEnd(), "", skillsSection, ""].join("\n");
+}
+export const CodexAdapter = {
+    id: "codex",
+    label: "OpenAI Codex CLI",
+    outputSummary: ".agents/skills/ + AGENTS.md",
+    details: {
+        en: [
+            "Writes `.agents/skills/<skill-id>.md` per master skill and a root `AGENTS.md` guide that lists each skill (description + reference path).",
+            "",
+            "Codex auto-loads AGENTS.md from the workspace root. From there it discovers the skill briefs by reference. Auto-matching is best-effort — say \"use the <skill-id> skill\" if a trigger phrase doesn't catch.",
+        ].join("\n"),
+        ko: [
+            "각 마스터 스킬을 `.agents/skills/<skill-id>.md` 로, 워크스페이스 가이드를 `AGENTS.md` 로 작성 (가이드에 각 스킬 description + reference path 나열).",
+            "",
+            "Codex 가 AGENTS.md 를 워크스페이스 루트에서 자동 로드. 거기서 referenced 파일들을 발견하는 흐름. 자동 매칭은 best-effort — 발동 안 되면 \"use the <skill-id> skill\" 식으로 명시.",
+        ].join("\n"),
+        ja: [
+            "各マスタースキルを `.agents/skills/<skill-id>.md` に、ワークスペースガイドを `AGENTS.md` に書き出します (ガイドに各スキルの description + reference path を列挙)。",
+            "",
+            "Codex は AGENTS.md をワークスペースルートから自動ロード。そこから referenced ファイルを発見する流れ。自動マッチングは best-effort — 発動しない場合は「use the <skill-id> skill」と明示。",
+        ].join("\n"),
+    },
+    install(params) {
+        const { root, masterSkills, lang, forceSkills, forceClaude } = params;
+        ensureDir(join(root, ".agents/skills"), ".agents/skills");
+        // 1) per-skill files
+        for (const s of masterSkills) {
+            const codexSkill = skillToCodex(s);
+            const destRel = `.agents/skills/${s.id}.md`;
+            writeRendered(join(root, destRel), destRel, codexSkill, forceSkills);
+        }
+        // 2) AGENTS.md guide with Skills directory
+        const guideBody = renderTemplate("CLAUDE.md.tpl", lang);
+        const content = buildAgentsMd(guideBody, masterSkills);
+        writeRendered(join(root, "AGENTS.md"), "AGENTS.md", content, forceClaude);
+    },
+};

package/dist/agents/cursor.js

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import { ensureDir, renderTemplate, writeRendered } from "./io.js";
+/**
+ * Convert a master skill into a Cursor MDC rule:
+ *   - drop `name:` (filename serves as the identifier)
+ *   - keep `description:` for Cursor 1.0+ auto-matching on intent
+ *   - add `alwaysApply: false` (safe default for older Cursors)
+ *   - body unchanged
+ */
+function skillToMdc(skill) {
+    const description = skill.frontmatter["description"] ?? "";
+    const fmLines = [
+        "---",
+        `description: ${description}`,
+        "alwaysApply: false",
+        "---",
+        "",
+    ];
+    return fmLines.join("\n") + skill.body;
+}
+export const CursorAdapter = {
+    id: "cursor",
+    label: "Cursor",
+    outputSummary: ".cursor/rules/ + .cursorrules",
+    details: {
+        en: [
+            "Writes `.cursor/rules/<skill-id>.mdc` per master skill and a root `.cursorrules` guide.",
+            "",
+            "Each MDC keeps the original description so Cursor 1.0+ can auto-match on intent. `alwaysApply: false` keeps older Cursors safe (rule loads on request, not always).",
+        ].join("\n"),
+        ko: [
+            "각 마스터 스킬을 `.cursor/rules/<skill-id>.mdc` 로, 워크스페이스 가이드를 `.cursorrules` 로 작성합니다.",
+            "",
+            "MDC 가 원본 description 을 유지하므로 Cursor 1.0+ 이 의도 기반 자동 매칭. `alwaysApply: false` 로 옛 Cursor 에서도 안전 (요청 시에만 로드).",
+        ].join("\n"),
+        ja: [
+            "各マスタースキルを `.cursor/rules/<skill-id>.mdc` に、ワークスペースガイドを `.cursorrules` に書き出します。",
+            "",
+            "MDC は元の description を保持するため Cursor 1.0+ が意図ベースで自動マッチ。`alwaysApply: false` で古い Cursor でも安全 (要求時のみロード)。",
+        ].join("\n"),
+    },
+    install(params) {
+        const { root, masterSkills, lang, forceSkills, forceClaude } = params;
+        ensureDir(join(root, ".cursor/rules"), ".cursor/rules");
+        // root guide → .cursorrules (re-use the CLAUDE.md.tpl body)
+        writeRendered(join(root, ".cursorrules"), ".cursorrules", renderTemplate("CLAUDE.md.tpl", lang), forceClaude);
+        // each master skill → .mdc
+        for (const s of masterSkills) {
+            const mdc = skillToMdc(s);
+            const destRel = `.cursor/rules/${s.id}.mdc`;
+            writeRendered(join(root, destRel), destRel, mdc, forceSkills);
+        }
+    },
+};

package/dist/agents/index.js

@@ -0,0 +1,15 @@
+import { ClaudeAdapter } from "./claude.js";
+import { CodexAdapter } from "./codex.js";
+import { CursorAdapter } from "./cursor.js";
+export const AGENTS = [
+    ClaudeAdapter,
+    CursorAdapter,
+    CodexAdapter,
+];
+export const AGENT_IDS = AGENTS.map((a) => a.id);
+export function getAgent(id) {
+    const a = AGENTS.find((x) => x.id === id);
+    if (!a)
+        throw new Error(`unknown agent id: ${id}`);
+    return a;
+}