@simoonfish/df-cli 1.0.0

package/dist/api/client.d.ts

@@ -0,0 +1,53 @@
+declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor();
+    /** 重置为环境变量/配置文件中的值 */
+    reset(): void;
+    /** 运行时覆盖（优先级高于环境变量/配置文件，用于 --api-key 等 CLI 参数） */
+    configure(opts: {
+        baseUrl?: string;
+        apiKey?: string;
+    }): void;
+    private headers;
+    private url;
+    get<T>(path: string, params?: Record<string, string | number | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    verifyKey(): Promise<{
+        valid: boolean;
+        user_id: number | null;
+    }>;
+    getWorkspace(id: number): Promise<{
+        code: number;
+        data: any;
+    }>;
+    getWorkspaceSkills(wsId: number): Promise<{
+        code: number;
+        data: any[];
+    }>;
+    getWorkspaceKnowledgeBases(wsId: number): Promise<{
+        code: number;
+        data: any[];
+    }>;
+    getWorkspaceRule(wsId: number): Promise<{
+        code: number;
+        data: any;
+    }>;
+    getSkill(id: number): Promise<{
+        code: number;
+        data: any;
+    }>;
+    getKnowledgeNodes(baseId: number): Promise<{
+        code: number;
+        data: any[];
+    }>;
+    syncReport(data: {
+        workspace_id: number;
+        hostname?: string;
+        local_dir?: string;
+        action: string;
+        detail?: string;
+    }): Promise<unknown>;
+}
+export declare const api: ApiClient;
+export {};

package/dist/api/client.js

@@ -0,0 +1,81 @@
+import { readConfig } from "../config.js";
+class ApiClient {
+    baseUrl;
+    apiKey;
+    constructor() {
+        this.reset();
+    }
+    /** 重置为环境变量/配置文件中的值 */
+    reset() {
+        const config = readConfig();
+        // 优先级: 环境变量 > 配置文件 > 默认值
+        this.baseUrl = process.env.DEVFORGE_API_URL || config?.api_url || "http://coding.bynway.com/api/v1";
+        this.apiKey = process.env.DEVFORGE_API_KEY || config?.api_key || "";
+    }
+    /** 运行时覆盖（优先级高于环境变量/配置文件，用于 --api-key 等 CLI 参数） */
+    configure(opts) {
+        if (opts.baseUrl)
+            this.baseUrl = opts.baseUrl;
+        if (opts.apiKey)
+            this.apiKey = opts.apiKey;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    url(path, params) {
+        const u = new URL(`${this.baseUrl}${path}`);
+        if (params) {
+            Object.entries(params).forEach(([k, v]) => {
+                if (v !== undefined)
+                    u.searchParams.set(k, String(v));
+            });
+        }
+        return u.toString();
+    }
+    async get(path, params) {
+        const res = await fetch(this.url(path, params), { headers: this.headers() });
+        if (!res.ok)
+            throw new Error(`API ${res.status}: ${res.statusText}`);
+        const json = await res.json();
+        return json;
+    }
+    async post(path, body) {
+        const res = await fetch(this.url(path), {
+            method: "POST",
+            headers: this.headers(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok)
+            throw new Error(`API ${res.status}: ${res.statusText}`);
+        const json = await res.json();
+        return json;
+    }
+    async verifyKey() {
+        return this.post("/auth/api-keys/verify");
+    }
+    async getWorkspace(id) {
+        return this.get(`/workspaces/${id}`);
+    }
+    async getWorkspaceSkills(wsId) {
+        return this.get(`/workspaces/${wsId}/skills`);
+    }
+    async getWorkspaceKnowledgeBases(wsId) {
+        return this.get(`/workspaces/${wsId}/knowledge-bases`);
+    }
+    async getWorkspaceRule(wsId) {
+        return this.get(`/workspaces/${wsId}/rule`);
+    }
+    async getSkill(id) {
+        return this.get(`/skills/${id}`);
+    }
+    async getKnowledgeNodes(baseId) {
+        return this.get("/knowledge-nodes", { base_id: baseId });
+    }
+    async syncReport(data) {
+        return this.post("/clients/sync-report", data);
+    }
+}
+export const api = new ApiClient();

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { readConfig, writeConfig } from "../config.js";
+import { api } from "../api/client.js";
+export const initCommand = new Command("init")
+    .description("初始化 DevForge CLI 配置（API 地址 + Key）")
+    .option("--api-url <url>", "平台 API 地址")
+    .option("--api-key <key>", "平台 API Key")
+    .option("--platform <name>", "AI 编码平台: claude_code | codex")
+    .action(async (opts, cmd) => {
+    const spinner = ora("正在验证...").start();
+    try {
+        // Load existing config
+        let config = readConfig();
+        // 优先级: CLI 参数 > 环境变量 > 配置文件 > 默认值
+        const parentOpts = cmd.parent?.optsWithGlobals() || {};
+        const apiUrl = opts.apiUrl || parentOpts.apiUrl || process.env.DEVFORGE_API_URL || config?.api_url || "http://coding.bynway.com/api/v1";
+        let apiKey = opts.apiKey || parentOpts.apiKey || process.env.DEVFORGE_API_KEY || config?.api_key || "";
+        if (!apiKey) {
+            spinner.fail("请通过 --api-key 或环境变量 DEVFORGE_API_KEY 提供 API Key");
+            process.exit(1);
+        }
+        // 将 CLI 参数同步到 API 客户端
+        api.configure({ baseUrl: apiUrl, apiKey });
+        // Verify key
+        spinner.text = "验证 API Key...";
+        const verifyResult = await api.verifyKey();
+        if (!verifyResult.valid) {
+            spinner.fail("API Key 无效，请检查后重试");
+            process.exit(1);
+        }
+        spinner.succeed("API Key 验证通过");
+        // Save config (no bindings — just url, key, platform)
+        if (!config) {
+            config = {
+                version: 1,
+                api_url: apiUrl,
+                api_key: apiKey,
+                platform: opts.platform || undefined,
+                bindings: [],
+            };
+        }
+        else {
+            config.api_url = apiUrl;
+            config.api_key = apiKey;
+            if (opts.platform)
+                config.platform = opts.platform;
+        }
+        writeConfig(config);
+        spinner.succeed("配置已保存到 ~/.devforge/config.json");
+        console.log(chalk.gray(`  平台地址: ${apiUrl}`));
+        console.log(chalk.gray(`  运行 ${chalk.white("devforge sync --workspace-id <id>")} 绑定工作区并同步`));
+    }
+    catch (e) {
+        spinner.fail(`初始化失败: ${e.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const installCommand: Command;

package/dist/commands/install.js

@@ -0,0 +1,129 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { readConfig, findBinding, getPlatform, getSkillInstallDir, getKnowledgeInstallDir, SUPPORTED_PLATFORMS } from "../config.js";
+import { api } from "../api/client.js";
+export const installCommand = new Command("install")
+    .description("安装指定 Skill 或知识库到工作区")
+    .argument("<type>", '资源类型: skill | knowledge')
+    .argument("<name>", "资源名称")
+    .option("--local-dir <path>", "指定本地工程目录（默认当前目录）")
+    .option("--platform <name>", `目标 AI 编码平台 (${SUPPORTED_PLATFORMS.join(" | ")})，覆盖配置中的平台`)
+    .option("--force", "当 platform 不匹配时强制安装")
+    .action(async (type, name, opts) => {
+    const spinner = ora().start();
+    try {
+        const config = readConfig();
+        if (!config) {
+            spinner.fail("未找到配置，请先运行 devforge init");
+            process.exit(1);
+        }
+        const binding = findBinding(config, opts.localDir);
+        if (!binding) {
+            spinner.fail("当前目录未绑定工作区，请运行 devforge init");
+            process.exit(1);
+        }
+        if (type === "skill") {
+            await installSkill(config, binding, name, opts);
+        }
+        else if (type === "knowledge") {
+            await installKnowledgeBase(config, binding, name, opts);
+        }
+        else {
+            spinner.fail(`未知资源类型: ${type} (支持: skill | knowledge)`);
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        spinner.fail(`安装失败: ${e.message}`);
+        process.exit(1);
+    }
+});
+async function installSkill(config, binding, name, opts) {
+    const spinner = ora().start();
+    // Search skill by name
+    spinner.text = `搜索 Skill "${name}"...`;
+    const res = await api.get("/skills", { keyword: name, pageSize: 20 });
+    const skills = res.data || [];
+    const skill = skills.find((s) => s.name === name || s.name.toLowerCase() === name.toLowerCase());
+    if (!skill) {
+        spinner.fail(`未找到名为 "${name}" 的 Skill`);
+        process.exit(1);
+    }
+    // Platform compatibility check
+    const currentPlatform = getPlatform(opts.platform);
+    const skillPlatform = skill.platform || "claude_code";
+    if (skillPlatform !== currentPlatform && !opts.force) {
+        spinner.warn(`Skill "${skill.name}" 的目标平台是 ${chalk.cyan(skillPlatform)}，` +
+            `当前环境是 ${chalk.cyan(currentPlatform)}`);
+        console.log(chalk.yellow(`  使用 ${chalk.white("--platform " + skillPlatform)} 切换平台`));
+        console.log(chalk.yellow(`  或使用 ${chalk.white("--force")} 强制安装`));
+        process.exit(1);
+    }
+    // Fetch full detail
+    spinner.text = `获取 Skill "${skill.name}" 详情...`;
+    const full = await api.getSkill(skill.id);
+    const detail = full.data || full;
+    const baseDir = getSkillInstallDir(binding.local_dir, skill.scope || "project", skill.platform);
+    const skillDir = join(baseDir, detail.name);
+    mkdirSync(skillDir, { recursive: true });
+    mkdirSync(join(skillDir, "files"), { recursive: true });
+    // Write manifest
+    writeFileSync(join(skillDir, "manifest.json"), JSON.stringify({
+        id: detail.id, name: detail.name, version: detail.version,
+        scope: detail.scope, status: detail.status,
+        platform: detail.platform, description: detail.description,
+    }, null, 2));
+    // Write prompt
+    if (detail.system_prompt) {
+        writeFileSync(join(skillDir, "SKILL.md"), detail.system_prompt);
+    }
+    // Download files
+    if (detail.files?.length > 0) {
+        for (const f of detail.files) {
+            spinner.text = `  下载附件 ${f.file_name}...`;
+            const blob = await fetch(`${config.api_url}/skills/${detail.id}/files/${f.id}/download`, { headers: { Authorization: `Bearer ${config.api_key}` } });
+            if (blob.ok) {
+                const buf = Buffer.from(await blob.arrayBuffer());
+                writeFileSync(join(skillDir, "files", f.file_name), buf);
+            }
+        }
+    }
+    spinner.succeed(`Skill "${skill.name}" 安装成功`);
+    console.log(chalk.gray(`  目录: ${skillDir}`));
+    console.log(chalk.gray(`  平台: ${chalk.cyan(skillPlatform)}`));
+}
+async function installKnowledgeBase(config, binding, name, _opts) {
+    const spinner = ora().start();
+    spinner.text = `搜索知识库 "${name}"...`;
+    const res = await api.get("/knowledge-bases", { keyword: name, pageSize: 20 });
+    const kbs = res.data || [];
+    const kb = kbs.find((k) => k.name === name || k.name.toLowerCase() === name.toLowerCase());
+    if (!kb) {
+        spinner.fail(`未找到名为 "${name}" 的知识库`);
+        process.exit(1);
+    }
+    const kbRootDir = getKnowledgeInstallDir(binding.local_dir);
+    mkdirSync(kbRootDir, { recursive: true });
+    const kbDir = join(kbRootDir, kb.name);
+    mkdirSync(kbDir, { recursive: true });
+    writeFileSync(join(kbDir, "manifest.json"), JSON.stringify({ id: kb.id, name: kb.name, path_in_repo: kb.path_in_repo }, null, 2));
+    const nodesRes = await api.get("/knowledge-nodes", { base_id: kb.id });
+    const nodes = nodesRes.data || [];
+    writeFileSync(join(kbDir, "index.json"), JSON.stringify(nodes.map((n) => ({
+        id: n.id, parent_id: n.parent_id, title: n.title,
+        type: n.type, path: n.path, sort_order: n.sort_order,
+    })), null, 2));
+    for (const node of nodes) {
+        if (node.type === "document" && node.content) {
+            const relPath = node.path || `${node.title}.md`;
+            const filePath = join(kbDir, relPath);
+            mkdirSync(join(filePath, ".."), { recursive: true });
+            writeFileSync(filePath, node.content);
+        }
+    }
+    spinner.succeed(`知识库 "${kb.name}" 安装成功`);
+    console.log(chalk.gray(`  目录: ${kbDir}`));
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { readConfig, findBinding, getAllSkillDirs, getKnowledgeInstallDir } from "../config.js";
+import { join } from "node:path";
+export const listCommand = new Command("list")
+    .description("列出已安装的 Skill 和知识库")
+    .option("--local-dir <path>", "指定本地工程目录（默认当前目录）")
+    .action((opts) => {
+    try {
+        const config = readConfig();
+        if (!config) {
+            console.log(chalk.yellow("未找到配置，请先运行 devforge init"));
+            return;
+        }
+        const localDir = opts.localDir || process.cwd();
+        const binding = findBinding(config, localDir);
+        if (!binding) {
+            console.log(chalk.yellow("当前目录未绑定工作区"));
+            return;
+        }
+        const platformLabel = {
+            claude_code: "Claude Code", codex: "Codex", qoder: "Qoder", trae: "Trae",
+        };
+        console.log(chalk.bold(`\n工作区: ${binding.workspace_name} (ID: ${binding.workspace_id})\n`));
+        // ── Skills: 扫描所有可能的安装目录 ──────────────────────────
+        console.log(chalk.cyan("Skills:"));
+        const seenSkills = new Set();
+        let hasSkill = false;
+        for (const skillDir of getAllSkillDirs(localDir)) {
+            if (!existsSync(skillDir))
+                continue;
+            const entries = readdirSync(skillDir, { withFileTypes: true });
+            const folders = entries.filter((e) => e.isDirectory());
+            for (const f of folders) {
+                try {
+                    const m = JSON.parse(readFileSync(join(skillDir, f.name, "manifest.json"), "utf-8"));
+                    const key = `${m.name}:${m.platform}:${m.scope}`;
+                    if (seenSkills.has(key))
+                        continue;
+                    seenSkills.add(key);
+                    hasSkill = true;
+                    const plat = platformLabel[m.platform] || m.platform || "";
+                    const scopeLabel = { project: "项目级", team: "团队级", enterprise: "企业级" }[m.scope] || m.scope;
+                    console.log(`  ${chalk.white(m.name)}  ${chalk.gray(`v${m.version}`)}  ${chalk.gray(scopeLabel)}  ${plat ? chalk.cyan(plat) : ""}`);
+                }
+                catch {
+                    // invalid manifest, skip
+                }
+            }
+        }
+        if (!hasSkill)
+            console.log(chalk.gray("  (无)"));
+        // ── Knowledge bases ────────────────────────────────────────
+        console.log(chalk.cyan("\n知识库:"));
+        const kbDir = getKnowledgeInstallDir(localDir);
+        if (existsSync(kbDir)) {
+            const entries = readdirSync(kbDir, { withFileTypes: true });
+            const folders = entries.filter((e) => e.isDirectory());
+            if (folders.length > 0) {
+                folders.forEach((f) => {
+                    try {
+                        const m = JSON.parse(readFileSync(join(kbDir, f.name, "manifest.json"), "utf-8"));
+                        const idx = JSON.parse(readFileSync(join(kbDir, f.name, "index.json"), "utf-8"));
+                        const docCount = idx.filter((n) => n.type === "document").length;
+                        console.log(`  ${chalk.white(m.name)}  ${chalk.gray(`${docCount} 篇文档`)}`);
+                    }
+                    catch {
+                        console.log(`  ${f.name}`);
+                    }
+                });
+            }
+            else {
+                console.log(chalk.gray("  (无)"));
+            }
+        }
+        else {
+            console.log(chalk.gray("  (无)"));
+        }
+        console.log("");
+    }
+    catch (e) {
+        console.error(chalk.red(`错误: ${e.message}`));
+    }
+});

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const statusCommand: Command;

package/dist/commands/status.js

@@ -0,0 +1,39 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { readConfig, findBinding } from "../config.js";
+export const statusCommand = new Command("status")
+    .description("查看当前工程绑定状态")
+    .option("--local-dir <path>", "指定本地工程目录（默认当前目录）")
+    .action((opts) => {
+    try {
+        const config = readConfig();
+        if (!config) {
+            console.log(chalk.yellow("未找到配置，请先运行 devforge init"));
+            return;
+        }
+        console.log(chalk.bold("\nDevForge CLI 状态\n"));
+        console.log(`平台地址:   ${chalk.blue(config.api_url)}`);
+        if (config.bindings.length === 0) {
+            console.log(chalk.yellow("暂无绑定"));
+            return;
+        }
+        const currentBinding = findBinding(config, opts.localDir);
+        if (currentBinding) {
+            console.log(`当前目录:   ${chalk.white(currentBinding.local_dir)}`);
+            console.log(`绑定工作区: ${chalk.green(currentBinding.workspace_name)} (ID: ${currentBinding.workspace_id})`);
+            console.log(`最后同步:   ${currentBinding.last_synced || "从未同步"}`);
+        }
+        else {
+            console.log(chalk.gray("当前目录未绑定工作区"));
+        }
+        console.log(chalk.cyan("\n所有绑定:"));
+        config.bindings.forEach((b) => {
+            const marker = b.local_dir === (opts.localDir || process.cwd()) ? chalk.green(" ▶") : "  ";
+            console.log(`${marker} ${chalk.white(b.local_dir)}  →  ${b.workspace_name} (ID:${b.workspace_id})  ${chalk.gray(b.last_synced || "未同步")}`);
+        });
+        console.log("");
+    }
+    catch (e) {
+        console.error(chalk.red(`错误: ${e.message}`));
+    }
+});

package/dist/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const syncCommand: Command;

package/dist/commands/sync.js

@@ -0,0 +1,179 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { readConfig, writeConfig, findBinding, getSkillInstallDir, getKnowledgeInstallDir, getDevForgeDir, getRuleFileName, getRulesCacheDir } from "../config.js";
+import { api } from "../api/client.js";
+export const syncCommand = new Command("sync")
+    .description("绑定工作区并同步 Skill + 知识库到本地")
+    .option("--local-dir <path>", "指定本地工程目录（默认当前目录）")
+    .option("--workspace-id <id>", "工作区 ID（首次绑定时必填）")
+    .option("--workspace <name>", "工作区名称（首次绑定时按名称搜索）")
+    .option("--skills", "仅同步 Skill")
+    .option("--knowledge", "仅同步知识库")
+    .action(async (opts) => {
+    const spinner = ora("加载配置...").start();
+    try {
+        const config = readConfig();
+        if (!config) {
+            spinner.fail("未找到配置，请先运行 devforge init");
+            process.exit(1);
+        }
+        const localDir = opts.localDir || process.cwd();
+        let binding = findBinding(config, localDir);
+        // ── 首次绑定 ─────────────────────────────────────────────
+        if (!binding) {
+            let wsId;
+            let wsName;
+            const workspaceId = opts.workspaceId ? Number(opts.workspaceId) : undefined;
+            const workspaceName = opts.workspace;
+            if (workspaceId) {
+                spinner.text = "查询工作区...";
+                const ws = await api.getWorkspace(workspaceId);
+                wsName = ws.data?.name || `工作区 #${workspaceId}`;
+                wsId = workspaceId;
+            }
+            else if (workspaceName) {
+                spinner.text = `搜索工作区 "${workspaceName}"...`;
+                const res = await api.get(`/workspaces?keyword=${encodeURIComponent(workspaceName)}&pageSize=5`);
+                if (!res.data?.length) {
+                    spinner.fail(`未找到名为 "${workspaceName}" 的工作区`);
+                    process.exit(1);
+                }
+                wsId = res.data[0].id;
+                wsName = res.data[0].name;
+            }
+            else {
+                spinner.fail("当前目录未绑定工作区，请通过 --workspace-id 或 --workspace 指定");
+                process.exit(1);
+            }
+            binding = { local_dir: localDir, workspace_id: wsId, workspace_name: wsName };
+            config.bindings.push(binding);
+            writeConfig(config);
+            spinner.succeed(`已绑定工作区: ${wsName} (ID: ${wsId})`);
+        }
+        else {
+            spinner.succeed(`已定位工作区: ${binding.workspace_name} (ID: ${binding.workspace_id})`);
+        }
+        // ── 同步到 local-dir/.devforge ────────────────────────────
+        mkdirSync(getDevForgeDir(binding.local_dir), { recursive: true });
+        const syncAll = !opts.skills && !opts.knowledge;
+        let skillCount = 0;
+        let kbCount = 0;
+        // Sync Skills — 按 scope + platform 安装到对应目录
+        if (syncAll || opts.skills) {
+            spinner.start(`同步 Skill... (工作区: ${binding.workspace_name})`);
+            const res = await api.getWorkspaceSkills(binding.workspace_id);
+            const skills = res.data || [];
+            for (const skill of skills) {
+                const baseDir = getSkillInstallDir(localDir, skill.scope || "project", skill.platform);
+                const skillDir = join(baseDir, skill.name);
+                mkdirSync(skillDir, { recursive: true });
+                mkdirSync(join(skillDir, "files"), { recursive: true });
+                // Fetch full skill with files
+                const full = await api.getSkill(skill.id);
+                const detail = full.data || full;
+                writeFileSync(join(skillDir, "manifest.json"), JSON.stringify({
+                    id: detail.id, name: detail.name, version: detail.version,
+                    scope: detail.scope, status: detail.status,
+                    platform: detail.platform, description: detail.description,
+                }, null, 2));
+                if (detail.system_prompt) {
+                    writeFileSync(join(skillDir, "SKILL.md"), detail.system_prompt);
+                }
+                if (detail.files?.length > 0) {
+                    for (const f of detail.files) {
+                        spinner.text = `  下载 ${f.file_name}...`;
+                        const blob = await fetch(`${config.api_url}/skills/${detail.id}/files/${f.id}/download`, { headers: { Authorization: `Bearer ${config.api_key}` } });
+                        if (blob.ok) {
+                            const buf = Buffer.from(await blob.arrayBuffer());
+                            writeFileSync(join(skillDir, "files", f.file_name), buf);
+                        }
+                    }
+                }
+                skillCount++;
+                spinner.text = `  ✓ ${skill.name} → ${skillDir}`;
+            }
+            spinner.succeed(`Skill 同步完成 (${skillCount} 个)`);
+        }
+        // Sync Knowledge bases — 统一安装到 local-dir/.devforge/knowledge/
+        if (syncAll || opts.knowledge) {
+            spinner.start(`同步知识库... (工作区: ${binding.workspace_name})`);
+            const res = await api.getWorkspaceKnowledgeBases(binding.workspace_id);
+            const kbs = res.data || [];
+            const kbRootDir = getKnowledgeInstallDir(localDir);
+            mkdirSync(kbRootDir, { recursive: true });
+            for (const kb of kbs) {
+                const kbDir = join(kbRootDir, kb.name);
+                mkdirSync(kbDir, { recursive: true });
+                writeFileSync(join(kbDir, "manifest.json"), JSON.stringify({ id: kb.id, name: kb.name, path_in_repo: kb.path_in_repo }, null, 2));
+                const nodesRes = await api.getKnowledgeNodes(kb.id);
+                const nodes = nodesRes.data || [];
+                writeFileSync(join(kbDir, "index.json"), JSON.stringify(nodes.map((n) => ({
+                    id: n.id, parent_id: n.parent_id, title: n.title,
+                    type: n.type, path: n.path, sort_order: n.sort_order,
+                })), null, 2));
+                for (const node of nodes) {
+                    if (node.type === "document" && node.content) {
+                        const relPath = node.path || `${node.title}.md`;
+                        const filePath = join(kbDir, relPath);
+                        mkdirSync(join(filePath, ".."), { recursive: true });
+                        writeFileSync(filePath, node.content);
+                    }
+                }
+                kbCount++;
+            }
+            spinner.succeed(`知识库同步完成 (${kbCount} 个)`);
+        }
+        let ruleCount = 0;
+        // Sync Rule — 写入工程根目录的 CLAUDE.md / .cursorrules
+        if (syncAll || opts.rules) {
+            spinner.start(`同步 AI 编码规则...`);
+            try {
+                const res = await api.getWorkspaceRule(binding.workspace_id);
+                const rule = res.data;
+                if (rule?.content) {
+                    const platform = config.platform || "claude_code";
+                    const fileName = getRuleFileName(platform);
+                    const rulePath = join(localDir, fileName);
+                    writeFileSync(rulePath, rule.content, "utf-8");
+                    ruleCount = 1;
+                    spinner.succeed(`规则已写入: ${rulePath}`);
+                    // 缓存元数据到 .devforge/rules/
+                    const cacheDir = getRulesCacheDir(localDir);
+                    mkdirSync(cacheDir, { recursive: true });
+                    writeFileSync(join(cacheDir, "manifest.json"), JSON.stringify({
+                        rule_id: rule.id,
+                        version: rule.version,
+                        template_name: rule.template_name || null,
+                        synced_at: new Date().toISOString(),
+                        knowledge_refs: rule.knowledge_refs || [],
+                    }, null, 2));
+                }
+                else {
+                    spinner.info("工作区未配置 AI 编码规则，跳过");
+                }
+            }
+            catch (e) {
+                spinner.warn(`规则同步失败: ${e.message}，跳过`);
+            }
+        }
+        // Update config
+        binding.last_synced = new Date().toISOString();
+        writeConfig(config);
+        // Report sync
+        await api.syncReport({
+            workspace_id: binding.workspace_id,
+            local_dir: binding.local_dir,
+            action: "sync",
+            detail: JSON.stringify({ skills: skillCount, knowledge: kbCount, rules: ruleCount }),
+        });
+        console.log(chalk.gray(`  工作区: ${binding.workspace_name} (ID: ${binding.workspace_id})`));
+        console.log(chalk.green(`  同步完成 — Skill ${skillCount}, 知识库 ${kbCount}`));
+    }
+    catch (e) {
+        spinner.fail(`同步失败: ${e.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/unbind.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const unbindCommand: Command;

package/dist/commands/unbind.js

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { readConfig, writeConfig } from "../config.js";
+export const unbindCommand = new Command("unbind")
+    .description("解绑当前目录或指定目录")
+    .option("--local-dir <path>", "指定本地工程目录（默认当前目录）")
+    .action((opts) => {
+    try {
+        const config = readConfig();
+        if (!config) {
+            console.log(chalk.yellow("未找到配置"));
+            return;
+        }
+        const dir = opts.localDir || process.cwd();
+        const idx = config.bindings.findIndex((b) => b.local_dir === dir);
+        if (idx === -1) {
+            console.log(chalk.yellow(`目录 ${dir} 未绑定工作区`));
+            return;
+        }
+        const binding = config.bindings[idx];
+        config.bindings.splice(idx, 1);
+        writeConfig(config);
+        console.log(chalk.green(`已解绑: ${binding.workspace_name} ← ${dir}`));
+    }
+    catch (e) {
+        console.error(chalk.red(`错误: ${e.message}`));
+    }
+});

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+export interface Binding {
+    local_dir: string;
+    workspace_id: number;
+    workspace_name: string;
+    last_synced?: string;
+}
+export interface DevForgeConfig {
+    version: number;
+    api_url: string;
+    api_key: string;
+    platform?: string;
+    bindings: Binding[];
+}
+export declare const SUPPORTED_PLATFORMS: readonly ["claude_code", "codex"];
+export type SupportedPlatform = (typeof SUPPORTED_PLATFORMS)[number];
+export declare function ensureConfigDir(): void;
+export declare function readConfig(): DevForgeConfig | null;
+export declare function writeConfig(config: DevForgeConfig): void;
+/** 确定当前运行的 AI 编码平台。优先级: 显式传入 > 配置文件 > 环境变量 > 默认 claude_code */
+export declare function getPlatform(override?: string): string;
+export declare function findBinding(config: DevForgeConfig, localDir?: string): Binding | null;
+export declare function getWorkspaceDir(workspaceId: number): string;
+export declare function ensureWorkspaceDir(workspaceId: number): string;
+/** 根据 Skill 的 scope + platform 计算安装目录 */
+export declare function getSkillInstallDir(localDir: string, scope: string, platform: string): string;
+/** 知识库安装目录（统一在 local-dir/.devforge/knowledge/） */
+export declare function getKnowledgeInstallDir(localDir: string): string;
+/** 扫描所有可能的 skill 安装目录，返回存在的目录列表 */
+export declare function getAllSkillDirs(localDir: string): string[];
+/** 返回 {localDir}/.devforge 根目录 */
+export declare function getDevForgeDir(localDir: string): string;
+export declare const RULE_FILE_NAMES: Record<string, string>;
+/** 根据 platform 返回规则文件名，默认 CLAUDE.md */
+export declare function getRuleFileName(platform: string): string;
+/** 规则元数据缓存目录 */
+export declare function getRulesCacheDir(localDir: string): string;

package/dist/config.js

@@ -0,0 +1,105 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".devforge");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export const SUPPORTED_PLATFORMS = ["claude_code", "codex"];
+export function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function readConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+/** 确定当前运行的 AI 编码平台。优先级: 显式传入 > 配置文件 > 环境变量 > 默认 claude_code */
+export function getPlatform(override) {
+    if (override && SUPPORTED_PLATFORMS.includes(override)) {
+        return override;
+    }
+    const config = readConfig();
+    if (config?.platform && SUPPORTED_PLATFORMS.includes(config.platform)) {
+        return config.platform;
+    }
+    const env = process.env.DEVFORGE_PLATFORM;
+    if (env && SUPPORTED_PLATFORMS.includes(env)) {
+        return env;
+    }
+    return "claude_code";
+}
+export function findBinding(config, localDir) {
+    const dir = localDir || process.cwd();
+    return config.bindings.find((b) => b.local_dir === dir) || null;
+}
+export function getWorkspaceDir(workspaceId) {
+    return join(CONFIG_DIR, "workspaces", String(workspaceId));
+}
+export function ensureWorkspaceDir(workspaceId) {
+    const dir = getWorkspaceDir(workspaceId);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/** 根据 Skill 的 scope + platform 计算安装目录 */
+export function getSkillInstallDir(localDir, scope, platform) {
+    const plat = platform || "claude_code";
+    const home = homedir();
+    if (scope === "project") {
+        // 项目级：安装到工程目录下
+        if (plat === "claude_code")
+            return join(localDir, ".claude", "skills");
+        if (plat === "codex")
+            return join(localDir, ".codex", "skills");
+        return join(localDir, ".claude", "skills"); // fallback
+    }
+    // team / enterprise → 用户级目录
+    if (plat === "claude_code")
+        return join(home, ".claude", "skills");
+    if (plat === "codex")
+        return join(home, ".codex", "skills");
+    return join(home, ".claude", "skills"); // fallback
+}
+/** 知识库安装目录（统一在 local-dir/.devforge/knowledge/） */
+export function getKnowledgeInstallDir(localDir) {
+    return join(localDir, ".devforge", "knowledge");
+}
+/** 扫描所有可能的 skill 安装目录，返回存在的目录列表 */
+export function getAllSkillDirs(localDir) {
+    const home = homedir();
+    return [
+        join(localDir, ".claude", "skills"),
+        join(localDir, ".codex", "skills"),
+        join(home, ".claude", "skills"),
+        join(home, ".codex", "skills"),
+    ];
+}
+/** 返回 {localDir}/.devforge 根目录 */
+export function getDevForgeDir(localDir) {
+    return join(localDir, ".devforge");
+}
+// ── Rule file names per platform ──────────────────────────────
+export const RULE_FILE_NAMES = {
+    claude_code: "CLAUDE.md",
+    cursor: ".cursorrules",
+    codex: "AGENTS.md",
+    windsurf: ".windsurfrules",
+    cline: ".clinerules",
+};
+/** 根据 platform 返回规则文件名，默认 CLAUDE.md */
+export function getRuleFileName(platform) {
+    return RULE_FILE_NAMES[platform] || "CLAUDE.md";
+}
+/** 规则元数据缓存目录 */
+export function getRulesCacheDir(localDir) {
+    return join(localDir, ".devforge", "rules");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { syncCommand } from "./commands/sync.js";
+import { installCommand } from "./commands/install.js";
+import { listCommand } from "./commands/list.js";
+import { statusCommand } from "./commands/status.js";
+import { unbindCommand } from "./commands/unbind.js";
+const program = new Command();
+program
+    .name("devforge")
+    .description("DevForge CLI — 将平台工作区、Skill 和知识库同步到本地开发工程")
+    .version("1.0.0")
+    .option("--api-url <url>", "平台 API 地址")
+    .option("--api-key <key>", "平台 API Key")
+    .option("--config <path>", "配置文件路径")
+    .addCommand(initCommand)
+    .addCommand(syncCommand)
+    .addCommand(installCommand)
+    .addCommand(listCommand)
+    .addCommand(statusCommand)
+    .addCommand(unbindCommand)
+    .hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    // require api-key for most commands except version/help
+    const cmdName = thisCommand.args[0];
+    const publicCommands = ["-V", "--version", "-h", "--help", "help"];
+    if (publicCommands.includes(cmdName))
+        return;
+});
+program.parse();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@simoonfish/df-cli",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "DevForge CLI — 将平台工作区、Skill 和知识库同步到本地开发工程",
+  "bin": {
+    "devforge": "./dist/index.js",
+    "df": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "type": "module",
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}