@nick848/ft 0.1.0

package/dist/index.js

@@ -0,0 +1,968 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import chalk2 from "chalk";
+import inquirer from "inquirer";
+import { execa as execa2 } from "execa";
+
+// src/core/detector.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync } from "fs";
+import path2 from "path";
+import { execa } from "execa";
+
+// src/core/paths.ts
+import { fileURLToPath } from "url";
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+function getPackageRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  while (dir !== path.dirname(dir)) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@nick848/ft") {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function getTemplatesDir() {
+  return path.join(getPackageRoot(), "templates");
+}
+function getRulesTemplatesDir() {
+  return path.join(getPackageRoot(), "rules-templates");
+}
+function getLocalesDir() {
+  return path.join(getPackageRoot(), "locales");
+}
+
+// src/core/detector.ts
+var KARPATHY_PATHS = [
+  ".cursor/rules/karpathy-guidelines.mdc",
+  ".codex/rules/karpathy-guidelines.md",
+  ".opencode/rules/karpathy-guidelines.md"
+];
+var PLATFORM_DIRS = {
+  cursor: ".cursor",
+  codex: ".codex",
+  opencode: ".opencode"
+};
+async function detectComet() {
+  try {
+    const { stdout } = await execa("comet", ["--version"]);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function detectKarpathyRules(projectRoot = process.cwd()) {
+  if (KARPATHY_PATHS.some((p) => existsSync2(path2.join(projectRoot, p)))) {
+    return true;
+  }
+  const templatesDir = getRulesTemplatesDir();
+  return existsSync2(path2.join(templatesDir, "cursor.mdc"));
+}
+async function detectGitNexus() {
+  try {
+    const { stdout } = await execa("gitnexus", ["--version"]);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function detectPlatformsInProject(projectRoot = process.cwd()) {
+  const found = [];
+  for (const [id, dir] of Object.entries(PLATFORM_DIRS)) {
+    if (existsSync2(path2.join(projectRoot, dir))) {
+      found.push(id);
+    }
+  }
+  return found;
+}
+function detectPackageManager(projectRoot = process.cwd()) {
+  if (existsSync2(path2.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(path2.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync2(path2.join(projectRoot, "bun.lockb")) || existsSync2(path2.join(projectRoot, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync2(path2.join(projectRoot, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function detectProjectMeta(projectRoot = process.cwd()) {
+  const pkgPath = path2.join(projectRoot, "package.json");
+  let name = path2.basename(projectRoot);
+  let scripts = "[NEEDS LLM INPUT]";
+  let workspaces = "[NEEDS LLM INPUT]";
+  let framework = "unknown";
+  let language = "JavaScript";
+  let monorepo = "\u5426";
+  if (existsSync2(pkgPath)) {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    name = pkg.name ?? name;
+    if (pkg.scripts) {
+      scripts = Object.entries(pkg.scripts).map(([k, v]) => `- \`${k}\`: ${v}`).join("\n");
+    }
+    if (pkg.workspaces) {
+      monorepo = "\u662F";
+      workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces.join(", ") : JSON.stringify(pkg.workspaces);
+    }
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["next"]) framework = "Next.js";
+    else if (deps["nuxt"]) framework = "Nuxt";
+    else if (deps["vue"]) framework = "Vue";
+    else if (deps["react"]) framework = "React";
+    else if (deps["@angular/core"]) framework = "Angular";
+    else if (deps["svelte"]) framework = "Svelte";
+    if (deps["typescript"] || existsSync2(path2.join(projectRoot, "tsconfig.json"))) {
+      language = "TypeScript";
+    }
+  }
+  return {
+    name,
+    packageManager: detectPackageManager(projectRoot),
+    framework,
+    language,
+    monorepo,
+    workspaces,
+    scripts
+  };
+}
+function isStdoutTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function agentsMdHasPendingPlaceholders(projectRoot = process.cwd()) {
+  const agentsPath = path2.join(projectRoot, "AGENTS.md");
+  if (!existsSync2(agentsPath)) return true;
+  const content = readFileSync2(agentsPath, "utf-8");
+  return content.includes("[NEEDS LLM INPUT]");
+}
+function gitNexusGraphExists(projectRoot = process.cwd()) {
+  const graphDir = path2.join(projectRoot, ".gitnexus");
+  return existsSync2(graphDir);
+}
+function countGitNexusIndexFiles(projectRoot = process.cwd()) {
+  const graphDir = path2.join(projectRoot, ".gitnexus");
+  if (!existsSync2(graphDir)) return 0;
+  try {
+    return readdirSync(graphDir).length;
+  } catch {
+    return 0;
+  }
+}
+
+// src/core/config.ts
+import { cosmiconfig } from "cosmiconfig";
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
+import path3 from "path";
+import YAML from "yaml";
+var MODULE_NAME = "ft";
+var DEFAULT_CONFIG = {
+  language: "zh-CN",
+  rtk: {
+    enabled: true,
+    auto_trigger_lines: 500,
+    exclude_patterns: ["--json", "--format json", "--xml"]
+  },
+  tools: ["cursor", "codex", "opencode"],
+  gitnexus: {
+    graph_path: ".gitnexus/",
+    auto_prompt_in_agents: true
+  }
+};
+function mergeConfig(partial) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...partial,
+    rtk: { ...DEFAULT_CONFIG.rtk, ...partial?.rtk },
+    gitnexus: { ...DEFAULT_CONFIG.gitnexus, ...partial?.gitnexus },
+    tools: partial?.tools ?? DEFAULT_CONFIG.tools
+  };
+}
+async function loadConfig(projectRoot = process.cwd()) {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: [
+      ".ft/config.yaml",
+      ".ft/config.yml",
+      ".ft/config.json",
+      "ft.config.yaml",
+      "ft.config.json"
+    ]
+  });
+  const result = await explorer.search(projectRoot);
+  if (!result?.config) {
+    return { ...DEFAULT_CONFIG };
+  }
+  return mergeConfig(result.config);
+}
+function resolveLanguage(cliLang, configLang) {
+  if (cliLang === "en" || cliLang === "zh-CN") {
+    return cliLang;
+  }
+  if (configLang) {
+    return configLang;
+  }
+  return "zh-CN";
+}
+function writeDefaultConfig(projectRoot, config) {
+  const ftDir = path3.join(projectRoot, ".ft");
+  if (!existsSync3(ftDir)) {
+    mkdirSync(ftDir, { recursive: true });
+  }
+  const configPath = path3.join(ftDir, "config.yaml");
+  writeFileSync(configPath, YAML.stringify(config), "utf-8");
+}
+
+// src/core/agents.ts
+import Handlebars from "handlebars";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync4 } from "fs";
+import path4 from "path";
+
+// src/core/template.ts
+function getGitNexusCondition(lang) {
+  if (lang === "en") {
+    return "If GitNexus is installed in this project, AI **must prioritize** GitNexus MCP tools (e.g. `gitnexus_get_symbol`) for code scanning and dependency analysis. If not installed, ignore this rule.";
+  }
+  return "\u5982\u679C\u5F53\u524D\u5DE5\u7A0B\u5DF2\u5B89\u88C5 GitNexus\uFF0CAI \u5728\u8FDB\u884C\u4EE3\u7801\u626B\u63CF\u548C\u5206\u6790\u65F6**\u5FC5\u987B\u4F18\u5148\u4F7F\u7528** GitNexus MCP \u5DE5\u5177\uFF08\u5982 `gitnexus_get_symbol`\uFF09\u83B7\u53D6\u7B26\u53F7\u7EA7\u4F9D\u8D56\u5173\u7CFB\u3002\u82E5\u672A\u5B89\u88C5\uFF0C\u8BF7\u5FFD\u7565\u6B64\u6761\u3002";
+}
+function buildAgentsTemplateData(meta, lang) {
+  return {
+    projectName: meta.name,
+    packageManager: meta.packageManager,
+    framework: meta.framework,
+    language: meta.language,
+    monorepo: meta.monorepo,
+    workspaces: meta.workspaces,
+    scripts: meta.scripts,
+    gitnexus_condition: getGitNexusCondition(lang)
+  };
+}
+
+// src/core/agents.ts
+function renderAgentsMd(meta, lang) {
+  const templateName = lang === "en" ? "AGENTS.md.en.hbs" : "AGENTS.md.zh.hbs";
+  const templatePath = path4.join(getTemplatesDir(), templateName);
+  const source = readFileSync4(templatePath, "utf-8");
+  const template = Handlebars.compile(source);
+  const data = buildAgentsTemplateData(meta, lang);
+  return template(data);
+}
+function generateAgentsMd(meta, lang, projectRoot = process.cwd()) {
+  const agentsPath = path4.join(projectRoot, "AGENTS.md");
+  const backupPath = path4.join(projectRoot, "AGENTS-BAK.md");
+  if (existsSync4(agentsPath)) {
+    renameSync(agentsPath, backupPath);
+  }
+  const content = renderAgentsMd(meta, lang);
+  writeFileSync2(agentsPath, content, "utf-8");
+}
+function updateGraphTimestampInAgents(projectRoot = process.cwd(), timestamp) {
+  const agentsPath = path4.join(projectRoot, "AGENTS.md");
+  if (!existsSync4(agentsPath)) return;
+  const ts = timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  let content = readFileSync4(agentsPath, "utf-8");
+  const marker = "\u56FE\u8C31\u6700\u540E\u5237\u65B0\u65F6\u95F4";
+  const enMarker = "Graph last refreshed";
+  const isEnglish = content.includes("## AI Working Guide");
+  const line = isEnglish ? `- ${enMarker}: ${ts}` : `- ${marker}: ${ts}`;
+  const regex = /- (图谱最后刷新时间|Graph last refreshed): .+/;
+  if (regex.test(content)) {
+    content = content.replace(regex, line);
+  } else if (content.includes("## AI \u5DE5\u4F5C\u6307\u5357") || isEnglish) {
+    const sectionRegex = /(## AI (工作指南|Working Guide)\n)/;
+    content = content.replace(sectionRegex, `$1${line}
+`);
+  } else {
+    content += `
+## AI \u5DE5\u4F5C\u6307\u5357
+${line}
+`;
+  }
+  writeFileSync2(agentsPath, content, "utf-8");
+}
+
+// src/core/i18n.ts
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import path5 from "path";
+var cache = {};
+function loadLocale(lang) {
+  if (cache[lang]) return cache[lang];
+  const filePath = path5.join(getLocalesDir(), `${lang}.json`);
+  if (!existsSync5(filePath)) {
+    return {};
+  }
+  cache[lang] = JSON.parse(readFileSync5(filePath, "utf-8"));
+  return cache[lang];
+}
+function t(key, lang = "zh-CN") {
+  const locale = loadLocale(lang);
+  return locale[key] ?? key;
+}
+function tf(key, lang, vars) {
+  let text = t(key, lang);
+  if (!vars) return text;
+  for (const [k, v] of Object.entries(vars)) {
+    text = text.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v);
+  }
+  return text;
+}
+
+// src/adapters/index.ts
+import { homedir } from "os";
+import path6 from "path";
+import {
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync6,
+  copyFileSync
+} from "fs";
+import deepmerge from "deepmerge";
+var GITNEXUS_SNIPPET = {
+  gitnexus: {
+    command: "gitnexus",
+    args: ["mcp"],
+    disabled: false
+  }
+};
+function readJsonFile(filePath) {
+  if (!existsSync6(filePath)) {
+    return { mcpServers: {} };
+  }
+  const raw = readFileSync6(filePath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path6.dirname(filePath);
+  if (!existsSync6(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync3(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function ensureMcpServersShape(config) {
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    config.mcpServers = {};
+  }
+  return config;
+}
+function createAdapter(id, rulesTargetPath, rulesTemplateName, mcpConfigPath) {
+  return {
+    id,
+    rulesTargetPath,
+    rulesTemplateName,
+    mcpConfigPath,
+    getGitNexusMcpEntry() {
+      return { ...GITNEXUS_SNIPPET };
+    },
+    mergeGitNexusMcp(config) {
+      const base = ensureMcpServersShape({ ...config });
+      const servers = base.mcpServers;
+      if (servers.gitnexus) {
+        return base;
+      }
+      return deepmerge(base, { mcpServers: GITNEXUS_SNIPPET });
+    },
+    hasGitNexusMcp(config) {
+      const servers = config.mcpServers;
+      return Boolean(servers?.gitnexus);
+    },
+    injectRules(projectRoot) {
+      const target = path6.join(projectRoot, rulesTargetPath);
+      const source = path6.join(getRulesTemplatesDir(), rulesTemplateName);
+      const dir = path6.dirname(target);
+      if (!existsSync6(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      copyFileSync(source, target);
+    },
+    async configureMcp() {
+      const configPath = mcpConfigPath;
+      const snippet = JSON.stringify(GITNEXUS_SNIPPET, null, 2);
+      try {
+        const existing = readJsonFile(configPath);
+        if (this.hasGitNexusMcp(existing)) {
+          return { success: true, path: configPath, snippet };
+        }
+        const merged = this.mergeGitNexusMcp(existing);
+        writeJsonFile(configPath, merged);
+        return { success: true, path: configPath, snippet };
+      } catch {
+        return { success: false, path: configPath, snippet };
+      }
+    }
+  };
+}
+var cursorAdapter = createAdapter(
+  "cursor",
+  ".cursor/rules/karpathy-guidelines.mdc",
+  "cursor.mdc",
+  path6.join(homedir(), ".cursor", "mcp.json")
+);
+var codexAdapter = createAdapter(
+  "codex",
+  ".codex/rules/karpathy-guidelines.md",
+  "codex.md",
+  path6.join(homedir(), ".codex", "mcp.json")
+);
+var opencodeAdapter = createAdapter(
+  "opencode",
+  ".opencode/rules/karpathy-guidelines.md",
+  "opencode.md",
+  path6.join(homedir(), ".config", "opencode", "mcp.json")
+);
+var adapters = {
+  cursor: cursorAdapter,
+  codex: codexAdapter,
+  opencode: opencodeAdapter
+};
+function getAdaptersForPlatforms(platforms) {
+  return platforms.map((p) => adapters[p]);
+}
+
+// src/adapters/mcp-setup.ts
+import chalk from "chalk";
+import readline from "readline";
+async function configureMcpForAdapters(adapterList, lang) {
+  for (const adapter of adapterList) {
+    const result = await adapter.configureMcp();
+    if (result.success) {
+      console.log(chalk.green(tf("mcp.writeSuccess", lang, { path: result.path })));
+    } else {
+      await promptManualMcpConfig(adapter, lang, result.path, result.snippet);
+    }
+  }
+}
+async function promptManualMcpConfig(_adapter, lang, configPath, snippet) {
+  const border = "\u2550".repeat(60);
+  console.log(chalk.yellow(`
+${border}`));
+  console.log(chalk.yellow.bold(tf("mcp.manualTitle", lang, { path: configPath })));
+  console.log(chalk.cyan(snippet));
+  console.log(chalk.yellow(`${border}
+`));
+  console.log(chalk.gray(tf("mcp.pressKey", lang)));
+  await new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.once("data", () => {
+      rl.close();
+      process.stdin.setRawMode?.(false);
+      resolve();
+    });
+  });
+}
+
+// src/cli/commands/init.ts
+async function selectPlatforms(mode, lang) {
+  if (mode === "all") {
+    return ["cursor", "codex", "opencode"];
+  }
+  if (mode === "auto") {
+    const detected = detectPlatformsInProject();
+    if (detected.length > 0) return detected;
+    return ["cursor", "codex", "opencode"];
+  }
+  const { platforms } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "platforms",
+      message: t("init.selectPlatforms", lang),
+      choices: [
+        { name: "Cursor", value: "cursor" },
+        { name: "Codex", value: "codex" },
+        { name: "OpenCode", value: "opencode" }
+      ],
+      validate: (v) => v.length > 0 ? true : t("init.selectAtLeastOne", lang)
+    }
+  ]);
+  return platforms;
+}
+async function selectInjectMode(lang) {
+  const { mode } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "mode",
+      message: t("init.injectModeQuestion", lang),
+      choices: [
+        { name: t("init.injectModeManual", lang), value: "manual" },
+        { name: t("init.injectModeAuto", lang), value: "auto" },
+        { name: t("init.injectModeAll", lang), value: "all" }
+      ]
+    }
+  ]);
+  return mode;
+}
+async function runInit(options) {
+  const projectRoot = process.cwd();
+  const existingConfig = await loadConfig(projectRoot);
+  const language = resolveLanguage(options.lang, existingConfig.language);
+  const cometVersion = await detectComet();
+  if (!cometVersion) {
+    console.error(chalk2.red(t("error.cometMissing", language)));
+    process.exit(1);
+  }
+  if (!detectKarpathyRules(projectRoot)) {
+    console.error(chalk2.red(t("error.karpathyMissing", language)));
+    process.exit(1);
+  }
+  const gitnexusVersion = await detectGitNexus();
+  const gitnexusInstalled = Boolean(gitnexusVersion);
+  if (!gitnexusInstalled) {
+    console.log(chalk2.gray(t("hint.gitnexusOptional", language)));
+  }
+  const injectMode = await selectInjectMode(language);
+  const selectedPlatforms = await selectPlatforms(injectMode, language);
+  const adapterList = getAdaptersForPlatforms(selectedPlatforms);
+  for (const adapter of adapterList) {
+    adapter.injectRules(projectRoot);
+    console.log(chalk2.green(tf("init.rulesInjected", language, { path: adapter.rulesTargetPath })));
+  }
+  if (gitnexusInstalled) {
+    await configureMcpForAdapters(adapterList, language);
+  }
+  const meta = detectProjectMeta(projectRoot);
+  generateAgentsMd(meta, language, projectRoot);
+  console.log(chalk2.green(t("init.agentsGenerated", language)));
+  const config = mergeConfig({
+    ...existingConfig,
+    language,
+    tools: selectedPlatforms
+  });
+  writeDefaultConfig(projectRoot, config);
+  console.log(chalk2.blue(t("init.runningComet", language)));
+  await execa2("comet", ["init"], { stdio: "inherit", cwd: projectRoot });
+  console.log(chalk2.green.bold(t("init.success", language)));
+  console.log(chalk2.cyan(t("init.nextStep", language)));
+}
+
+// src/cli/commands/update.ts
+import { execa as execa3 } from "execa";
+async function runUpdate() {
+  await execa3("npm", ["update", "-g", "@nick848/ft"], { stdio: "inherit" });
+}
+
+// src/cli/commands/version.ts
+import { readFileSync as readFileSync7 } from "fs";
+import path7 from "path";
+function getFtVersion() {
+  try {
+    const pkgPath = path7.join(getPackageRoot(), "package.json");
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function runVersion() {
+  const ftVersion = getFtVersion();
+  const cometVersion = await detectComet();
+  const gitnexusVersion = await detectGitNexus();
+  console.log(`FT:       ${ftVersion}`);
+  console.log(`Comet:    ${cometVersion ?? "not installed"}`);
+  console.log(`GitNexus: ${gitnexusVersion ?? "not installed"}`);
+}
+
+// src/cli/commands/help.ts
+function printHelp() {
+  console.log(`
+FT (Frontend Toolkit) \u2014 CLI orchestration for Comet, Karpathy rules, and GitNexus
+
+Usage:
+  ft init [--lang en|zh-CN]   Full project initialization pipeline
+  ft update                   Update @nick848/ft globally
+  ft version                  Show FT, Comet, and GitNexus versions
+  ft help                     Show this help
+  ft slash <command> [args]   Run IDE slash command (internal)
+
+Slash commands (use via IDE, maps to ft slash):
+  fill-context    Output prompt recipe to fill AGENTS.md
+  open            Comet open (passthrough)
+  design          Comet design (passthrough)
+  build           Comet build (passthrough)
+  verify          Comet verify (passthrough)
+  archive         Comet archive (passthrough)
+  hotfix          Comet hotfix (passthrough)
+  tweak           Comet tweak (passthrough)
+  graph-setup     GitNexus install guide + MCP retry
+  graph-init      gitnexus analyze
+  graph-refresh   gitnexus analyze --force
+  graph-handoff   Graph summary + prompt + AGENTS timestamp
+  graph-status    Check GitNexus installation and graph state
+`);
+}
+
+// src/cli/commands/slash.ts
+import chalk7 from "chalk";
+
+// src/slash/fill-context.ts
+import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import path8 from "path";
+var PLACEHOLDER = "[NEEDS LLM INPUT]";
+var SECTION_HINTS = {
+  "\u7ED3\u6784": { zh: "\u8BF7\u904D\u5386 src/ \u751F\u6210\u6811\u5F62\u76EE\u5F55\u7ED3\u6784", en: "Traverse src/ and produce a tree directory structure" },
+  "Structure": { zh: "\u8BF7\u904D\u5386 src/ \u751F\u6210\u6811\u5F62\u76EE\u5F55\u7ED3\u6784", en: "Traverse src/ and produce a tree directory structure" },
+  "\u89C4\u8303": { zh: "\u8BF7\u6839\u636E .eslintrc / prettier \u7B49\u914D\u7F6E\u6587\u4EF6\u603B\u7ED3\u4EE3\u7801\u89C4\u8303", en: "Summarize code conventions from eslint/prettier configs" },
+  "Conventions": { zh: "\u8BF7\u6839\u636E .eslintrc / prettier \u7B49\u914D\u7F6E\u6587\u4EF6\u603B\u7ED3\u4EE3\u7801\u89C4\u8303", en: "Summarize code conventions from eslint/prettier configs" },
+  "\u8DEF\u7531": { zh: "\u8BF7\u6839\u636E\u8DEF\u7531\u914D\u7F6E\u6587\u4EF6\u5217\u51FA\u4E3B\u8981\u8DEF\u7531", en: "List main routes from routing config" },
+  "Routing": { zh: "\u8BF7\u6839\u636E\u8DEF\u7531\u914D\u7F6E\u6587\u4EF6\u5217\u51FA\u4E3B\u8981\u8DEF\u7531", en: "List main routes from routing config" }
+};
+function extractSections(content) {
+  const lines = content.split("\n");
+  const results = [];
+  let currentSection = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line.replace(/^##\s+/, "").trim();
+    }
+    if (line.includes(PLACEHOLDER)) {
+      results.push({ section: currentSection, line: i + 1 });
+    }
+  }
+  return results;
+}
+function findSectionInBackup(section, backup) {
+  if (!section) return "";
+  const regex = new RegExp(`## ${section}[\\s\\n]+([\\s\\S]*?)(?=\\n## |$)`, "m");
+  const match = backup.match(regex);
+  return match?.[1]?.trim() ?? "";
+}
+async function runFillContext(config) {
+  const projectRoot = process.cwd();
+  const agentsPath = path8.join(projectRoot, "AGENTS.md");
+  const lang = config.language;
+  if (!existsSync7(agentsPath)) {
+    console.log(t("fillContext.noAgents", lang));
+    return;
+  }
+  const agentsContent = readFileSync8(agentsPath, "utf-8");
+  const placeholders = extractSections(agentsContent);
+  const backupPath = path8.join(projectRoot, "AGENTS-BAK.md");
+  const backupContent = existsSync7(backupPath) ? readFileSync8(backupPath, "utf-8") : "";
+  const langLabel = lang === "en" ? "English" : "\u7B80\u4F53\u4E2D\u6587";
+  console.log(`# ${t("fillContext.title", lang)}
+`);
+  console.log(t("fillContext.goal", lang));
+  console.log(`
+**${t("fillContext.langConstraint", lang)}**: ${langLabel}
+`);
+  if (placeholders.length === 0) {
+    console.log(t("fillContext.noPlaceholders", lang));
+    return;
+  }
+  console.log(`## ${t("fillContext.taskList", lang)}
+`);
+  for (const { section, line } of placeholders) {
+    const hint = SECTION_HINTS[section];
+    const guide = lang === "en" ? hint?.en ?? "Replace placeholder with accurate project-specific content" : hint?.zh ?? "\u5C06\u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u51C6\u786E\u7684\u9879\u76EE\u76F8\u5173\u5185\u5BB9";
+    console.log(`### ${section || "General"} (line ${line})`);
+    console.log(`- **${t("fillContext.placeholder", lang)}**: ${PLACEHOLDER}`);
+    console.log(`- **${t("fillContext.guide", lang)}**: ${guide}`);
+    if (backupContent && section) {
+      const ref = findSectionInBackup(section, backupContent);
+      if (ref) {
+        console.log(`- **${t("fillContext.reference", lang)}**:
+`);
+        console.log(ref);
+      }
+    }
+    console.log("");
+  }
+  if (backupContent) {
+    console.log(`## ${t("fillContext.backupNote", lang)}
+`);
+    console.log(t("fillContext.backupMerge", lang));
+  }
+}
+
+// src/core/rtk-bridge.ts
+import { execa as execa4 } from "execa";
+
+// src/core/rtk.ts
+var HEAD_LINES = 200;
+var TAIL_LINES = 100;
+function shouldBypassRtk(commandArgs, config) {
+  const joined = commandArgs.join(" ");
+  return config.rtk.exclude_patterns.some((pattern) => joined.includes(pattern));
+}
+function truncateMiddle(text, headLines = HEAD_LINES, tailLines = TAIL_LINES) {
+  const lines = text.split("\n");
+  const total = lines.length;
+  const threshold = headLines + tailLines;
+  if (total <= threshold) {
+    return text;
+  }
+  const omitted = total - headLines - tailLines;
+  const head = lines.slice(0, headLines);
+  const tail = lines.slice(-tailLines);
+  const marker = `...... (\u5DF2\u7701\u7565 ${omitted} \u884C) ......`;
+  return [...head, marker, ...tail].join("\n");
+}
+function compressOutputIfNeeded(text, config, rtkDisabled) {
+  if (rtkDisabled) return text;
+  const lines = text.split("\n");
+  const shouldCompress = config.rtk.enabled || lines.length > config.rtk.auto_trigger_lines;
+  if (!shouldCompress) return text;
+  return truncateMiddle(text);
+}
+
+// src/core/rtk-bridge.ts
+async function runWithRtk(command, args, config, options = {}) {
+  const bypass = shouldBypassRtk(args, config);
+  const ttyPassthrough = options.inheritStdio ?? false;
+  const rtkOff = options.rtkDisabled || bypass || ttyPassthrough;
+  if (ttyPassthrough) {
+    const subprocess = execa4(command, args, {
+      cwd: options.cwd,
+      stdio: "inherit",
+      reject: false
+    });
+    const result2 = await subprocess;
+    return {
+      stdout: "",
+      stderr: "",
+      exitCode: result2.exitCode ?? (result2.failed ? 1 : 0)
+    };
+  }
+  const result = await execa4(command, args, {
+    cwd: options.cwd,
+    reject: false,
+    all: true
+  });
+  const combined = result.all ?? `${result.stdout}
+${result.stderr}`;
+  const processed = compressOutputIfNeeded(combined, config, rtkOff);
+  if (processed !== combined) {
+    process.stdout.write(processed);
+    if (!processed.endsWith("\n")) process.stdout.write("\n");
+  } else {
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+  }
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 1
+  };
+}
+async function runCometPassthrough(subcommand, extraArgs, config, options = {}) {
+  const args = [subcommand, ...extraArgs];
+  const isTTY = isStdoutTTY() && isStdinTTY();
+  if (isTTY) {
+    const result = await runWithRtk("comet", args, config, {
+      ...options,
+      inheritStdio: true,
+      rtkDisabled: true
+    });
+    return result.exitCode;
+  }
+  const withNonInteractive = ["--non-interactive", ...args];
+  try {
+    const result = await runWithRtk("comet", withNonInteractive, config, options);
+    if (result.exitCode === 0) return 0;
+    const retry = await runWithRtk("comet", args, config, options);
+    if (retry.exitCode !== 0) {
+      throw new Error("NON_INTERACTIVE_FAILED");
+    }
+    return 0;
+  } catch (err) {
+    if (err.message?.includes("ENOENT")) {
+      throw new Error("COMET_NOT_FOUND");
+    }
+    throw err;
+  }
+}
+function isStdinTTY() {
+  return Boolean(process.stdin.isTTY);
+}
+
+// src/slash/comet-passthrough.ts
+import chalk3 from "chalk";
+var COMET_MAP = {
+  open: "open",
+  design: "design",
+  build: "build",
+  verify: "verify",
+  archive: "archive",
+  hotfix: "hotfix",
+  tweak: "tweak"
+};
+async function runCometSlash(subcommand, args, config) {
+  const mapped = COMET_MAP[subcommand];
+  if (!mapped) return 1;
+  try {
+    return await runCometPassthrough(mapped, args, config);
+  } catch (err) {
+    const message = err.message;
+    if (message === "NON_INTERACTIVE_FAILED") {
+      console.error(chalk3.red(t("error.cometNonInteractive", config.language)));
+      console.error(chalk3.yellow(t("error.cometUseTerminal", config.language)));
+      return 1;
+    }
+    console.error(chalk3.red(String(err)));
+    return 1;
+  }
+}
+
+// src/slash/graph-setup.ts
+import chalk4 from "chalk";
+async function runGraphSetup(config) {
+  const lang = config.language;
+  const installed = await detectGitNexus();
+  if (!installed) {
+    console.log(chalk4.yellow(t("graph.setupGuide", lang)));
+    console.log(chalk4.cyan("npm install -g gitnexus"));
+  } else {
+    console.log(chalk4.green(t("graph.alreadyInstalled", lang)));
+  }
+  const adapterList = getAdaptersForPlatforms(config.tools);
+  await configureMcpForAdapters(adapterList, lang);
+}
+
+// src/slash/graph-init.ts
+async function runGraphInit(config) {
+  const result = await runWithRtk("gitnexus", ["analyze"], config);
+  process.exit(result.exitCode);
+}
+
+// src/slash/graph-refresh.ts
+async function runGraphRefresh(config) {
+  const result = await runWithRtk("gitnexus", ["analyze", "--force"], config);
+  process.exit(result.exitCode);
+}
+
+// src/slash/graph-handoff.ts
+import chalk5 from "chalk";
+async function runGraphHandoff(config) {
+  const lang = config.language;
+  console.log(chalk5.bold(`## A. ${t("graph.handoffSummary", lang)}
+`));
+  const summary = await runWithRtk("gitnexus", ["query", "--summary"], config);
+  if (summary.exitCode !== 0) {
+    console.log(chalk5.yellow(t("graph.summaryFailed", lang)));
+  }
+  console.log(chalk5.bold(`
+## B. ${t("graph.handoffPrompt", lang)}
+`));
+  console.log(t("graph.handoffPromptBody", lang));
+  console.log(chalk5.bold(`
+## C. ${t("graph.handoffTimestamp", lang)}
+`));
+  updateGraphTimestampInAgents();
+  console.log(chalk5.green(t("graph.timestampUpdated", lang)));
+}
+
+// src/slash/graph-status.ts
+import chalk6 from "chalk";
+async function runGraphStatus(config) {
+  const lang = config.language;
+  const version = await detectGitNexus();
+  const graphExists = gitNexusGraphExists();
+  const indexCount = countGitNexusIndexFiles();
+  console.log(chalk6.bold(t("graph.statusTitle", lang)));
+  console.log(`${t("graph.statusInstalled", lang)}: ${version ? chalk6.green(version) : chalk6.red("no")}`);
+  console.log(`${t("graph.statusGraph", lang)}: ${graphExists ? chalk6.green("yes") : chalk6.yellow("no")}`);
+  console.log(`${t("graph.statusIndexFiles", lang)}: ${indexCount}`);
+}
+
+// src/cli/commands/slash.ts
+var COMET_COMMANDS = [
+  "open",
+  "design",
+  "build",
+  "verify",
+  "archive",
+  "hotfix",
+  "tweak"
+];
+var GRAPH_COMMANDS = [
+  "graph-setup",
+  "graph-init",
+  "graph-refresh",
+  "graph-handoff",
+  "graph-status"
+];
+var ALL_COMMANDS = [
+  "fill-context",
+  ...COMET_COMMANDS,
+  ...GRAPH_COMMANDS
+];
+function gateCometCommands(projectRoot, lang) {
+  if (agentsMdHasPendingPlaceholders(projectRoot)) {
+    console.error(chalk7.yellow(t("gate.fillContextFirst", lang)));
+    process.exit(1);
+  }
+}
+async function runSlash(command, args) {
+  if (!ALL_COMMANDS.includes(command)) {
+    console.error(chalk7.red(`Unknown slash command: ${command}`));
+    process.exit(1);
+  }
+  const projectRoot = process.cwd();
+  const config = await loadConfig(projectRoot);
+  const lang = config.language;
+  const slashCmd = command;
+  if (COMET_COMMANDS.includes(slashCmd)) {
+    gateCometCommands(projectRoot, lang);
+    const exitCode = await runCometSlash(slashCmd, args, config);
+    process.exit(exitCode);
+  }
+  switch (slashCmd) {
+    case "fill-context":
+      await runFillContext(config);
+      break;
+    case "graph-setup":
+      await runGraphSetup(config);
+      break;
+    case "graph-init":
+      await runGraphInit(config);
+      break;
+    case "graph-refresh":
+      await runGraphRefresh(config);
+      break;
+    case "graph-handoff":
+      await runGraphHandoff(config);
+      break;
+    case "graph-status":
+      await runGraphStatus(config);
+      break;
+    default:
+      process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("ft").description("Frontend Toolkit \u2014 orchestration layer for Comet and GitNexus").version("0.1.0");
+program.command("init").description("Full project initialization pipeline").option("--lang <lang>", "Language: zh-CN or en").action(async (options) => {
+  await runInit({ lang: options.lang });
+});
+program.command("update").description("Update @nick848/ft globally").action(async () => {
+  await runUpdate();
+});
+program.command("version").description("Show FT, Comet, and GitNexus versions").action(async () => {
+  await runVersion();
+});
+program.command("help").description("Show help").action(() => {
+  printHelp();
+});
+program.command("slash").description("Run IDE slash command").argument("<command>", "Slash subcommand name").argument("[args...]", "Additional arguments").action(async (command, args) => {
+  await runSlash(command, args);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map