agent-proteus 0.1.0

package/dist/cli.js

@@ -0,0 +1,2359 @@
+#!/usr/bin/env node
+import {
+  scanExistingAgents,
+  updateAgentRegistry
+} from "./chunk-XNEZQVEV.js";
+
+// src/cli.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/detectors/stack.ts
+import fs from "fs/promises";
+import path from "path";
+async function createContext(cwd) {
+  const entries = await fs.readdir(cwd, { withFileTypes: true });
+  const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+  const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  return {
+    cwd,
+    files,
+    hasFile: (name) => files.includes(name),
+    hasDir: (name) => dirs.includes(name),
+    readJson: async (name) => {
+      try {
+        const content = await fs.readFile(path.join(cwd, name), "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    },
+    readFile: async (name) => {
+      try {
+        return await fs.readFile(path.join(cwd, name), "utf-8");
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+async function detectLanguage(ctx) {
+  if (ctx.hasFile("tsconfig.json")) {
+    const pkg2 = await ctx.readJson("package.json");
+    const version = pkg2?.devDependencies?.typescript?.replace("^", "").replace("~", "");
+    return { language: "typescript", version };
+  }
+  if (ctx.hasFile("go.mod")) {
+    const goMod = await ctx.readFile("go.mod");
+    const match = goMod?.match(/^go\s+(\d+\.\d+)/m);
+    return { language: "go", version: match?.[1] };
+  }
+  if (ctx.hasFile("pyproject.toml") || ctx.hasFile("requirements.txt") || ctx.hasFile("setup.py")) {
+    return { language: "python" };
+  }
+  if (ctx.hasFile("Cargo.toml")) {
+    return { language: "rust" };
+  }
+  if (ctx.hasFile("Gemfile")) {
+    return { language: "ruby" };
+  }
+  if (ctx.hasFile("pom.xml") || ctx.hasFile("build.gradle") || ctx.hasFile("build.gradle.kts")) {
+    return { language: "java" };
+  }
+  if (ctx.hasFile("composer.json")) {
+    return { language: "php" };
+  }
+  if (ctx.hasFile("package.json")) {
+    return { language: "javascript" };
+  }
+  return { language: "unknown" };
+}
+async function detectFramework(ctx, language) {
+  if (language === "typescript" || language === "javascript") {
+    const pkg2 = await ctx.readJson("package.json");
+    const deps = { ...pkg2?.dependencies, ...pkg2?.devDependencies };
+    if (deps?.next) {
+      return { framework: "nextjs", version: deps.next.replace("^", "").replace("~", "") };
+    }
+    if (deps?.react && !deps?.next) {
+      if (deps?.["@remix-run/react"]) return { framework: "react", version: deps.react };
+      return { framework: "react", version: deps.react.replace("^", "").replace("~", "") };
+    }
+    if (deps?.vue) {
+      return { framework: "vue", version: deps.vue.replace("^", "").replace("~", "") };
+    }
+    if (deps?.["@angular/core"]) {
+      return { framework: "angular", version: deps["@angular/core"].replace("^", "").replace("~", "") };
+    }
+    if (deps?.svelte) {
+      return { framework: "svelte", version: deps.svelte.replace("^", "").replace("~", "") };
+    }
+    if (deps?.["@nestjs/core"]) {
+      return { framework: "nestjs", version: deps["@nestjs/core"].replace("^", "").replace("~", "") };
+    }
+    if (deps?.express) {
+      return { framework: "express", version: deps.express.replace("^", "").replace("~", "") };
+    }
+    if (deps?.fastify) {
+      return { framework: "fastify", version: deps.fastify.replace("^", "").replace("~", "") };
+    }
+  }
+  if (language === "go") {
+    const goMod = await ctx.readFile("go.mod");
+    if (goMod?.includes("github.com/gin-gonic/gin")) {
+      return { framework: "gin" };
+    }
+    if (goMod?.includes("github.com/labstack/echo")) {
+      return { framework: "echo" };
+    }
+    if (goMod?.includes("github.com/gofiber/fiber")) {
+      return { framework: "fiber" };
+    }
+  }
+  if (language === "python") {
+    const requirements = await ctx.readFile("requirements.txt");
+    const pyproject = await ctx.readFile("pyproject.toml");
+    const content = (requirements || "") + (pyproject || "");
+    if (content.includes("django")) return { framework: "django" };
+    if (content.includes("fastapi")) return { framework: "fastapi" };
+    if (content.includes("flask")) return { framework: "flask" };
+  }
+  if (language === "ruby") {
+    const gemfile = await ctx.readFile("Gemfile");
+    if (gemfile?.includes("rails")) return { framework: "rails" };
+  }
+  if (language === "rust") {
+    const cargo = await ctx.readFile("Cargo.toml");
+    if (cargo?.includes("actix-web")) return { framework: "actix" };
+    if (cargo?.includes("axum")) return { framework: "axum" };
+  }
+  return { framework: "unknown" };
+}
+async function detectTestFramework(ctx, language) {
+  if (language === "typescript" || language === "javascript") {
+    const pkg2 = await ctx.readJson("package.json");
+    const deps = { ...pkg2?.dependencies, ...pkg2?.devDependencies };
+    if (deps?.vitest || ctx.hasFile("vitest.config.ts") || ctx.hasFile("vitest.config.js")) {
+      return "vitest";
+    }
+    if (deps?.jest || ctx.hasFile("jest.config.js") || ctx.hasFile("jest.config.ts")) {
+      return "jest";
+    }
+    if (deps?.mocha) {
+      return "mocha";
+    }
+  }
+  if (language === "go") {
+    return "go-test";
+  }
+  if (language === "python") {
+    const content = (await ctx.readFile("requirements.txt") || "") + (await ctx.readFile("pyproject.toml") || "");
+    if (content.includes("pytest")) return "pytest";
+  }
+  if (language === "ruby") {
+    const gemfile = await ctx.readFile("Gemfile");
+    if (gemfile?.includes("rspec")) return "rspec";
+  }
+  return "unknown";
+}
+async function detectPackageManager(ctx, language) {
+  if (language === "typescript" || language === "javascript") {
+    if (ctx.hasFile("bun.lockb")) return "bun";
+    if (ctx.hasFile("pnpm-lock.yaml")) return "pnpm";
+    if (ctx.hasFile("yarn.lock")) return "yarn";
+    if (ctx.hasFile("package-lock.json")) return "npm";
+    return "npm";
+  }
+  if (language === "go") return "go-modules";
+  if (language === "python") {
+    if (ctx.hasFile("poetry.lock")) return "poetry";
+    return "pip";
+  }
+  if (language === "rust") return "cargo";
+  if (language === "ruby") return "bundler";
+  if (language === "java") {
+    if (ctx.hasFile("pom.xml")) return "maven";
+    return "gradle";
+  }
+  if (language === "php") return "composer";
+  return "unknown";
+}
+async function detectAdditionalTools(ctx, language) {
+  const tools = [];
+  let styling;
+  let database;
+  if (language === "typescript" || language === "javascript") {
+    const pkg2 = await ctx.readJson("package.json");
+    const deps = { ...pkg2?.dependencies, ...pkg2?.devDependencies };
+    if (deps?.tailwindcss || ctx.hasFile("tailwind.config.js") || ctx.hasFile("tailwind.config.ts")) {
+      styling = "Tailwind CSS";
+    } else if (deps?.["styled-components"]) {
+      styling = "styled-components";
+    } else if (deps?.["@emotion/react"]) {
+      styling = "Emotion";
+    } else if (ctx.files.some((f) => f.endsWith(".module.css") || f.endsWith(".module.scss"))) {
+      styling = "CSS Modules";
+    }
+    if (deps?.prisma || deps?.["@prisma/client"]) {
+      database = "Prisma";
+      tools.push("Prisma");
+    }
+    if (deps?.drizzle || deps?.["drizzle-orm"]) {
+      database = "Drizzle";
+      tools.push("Drizzle");
+    }
+    if (deps?.zustand) tools.push("Zustand");
+    if (deps?.["@reduxjs/toolkit"] || deps?.redux) tools.push("Redux");
+    if (deps?.jotai) tools.push("Jotai");
+    if (deps?.recoil) tools.push("Recoil");
+    if (deps?.["@tanstack/react-query"]) tools.push("React Query");
+    if (deps?.swr) tools.push("SWR");
+    if (deps?.axios) tools.push("Axios");
+    if (deps?.zod) tools.push("Zod");
+    if (deps?.yup) tools.push("Yup");
+    if (deps?.eslint || ctx.files.some((f) => f.startsWith(".eslintrc"))) tools.push("ESLint");
+    if (deps?.prettier || ctx.hasFile(".prettierrc") || ctx.hasFile("prettier.config.js")) tools.push("Prettier");
+    if (deps?.biome || ctx.hasFile("biome.json")) tools.push("Biome");
+    if (ctx.hasFile("docker-compose.yml") || ctx.hasFile("docker-compose.yaml")) tools.push("Docker");
+    if (ctx.hasFile(".github")) tools.push("GitHub Actions");
+  }
+  return { styling, database, additionalTools: tools };
+}
+async function detectStack(cwd) {
+  const ctx = await createContext(cwd);
+  const { language, version: languageVersion } = await detectLanguage(ctx);
+  const { framework, version: frameworkVersion } = await detectFramework(ctx, language);
+  const testFramework = await detectTestFramework(ctx, language);
+  const packageManager = await detectPackageManager(ctx, language);
+  const { styling, database, additionalTools } = await detectAdditionalTools(ctx, language);
+  return {
+    language,
+    languageVersion,
+    framework,
+    frameworkVersion,
+    testFramework,
+    packageManager,
+    styling,
+    database,
+    additionalTools
+  };
+}
+
+// src/detectors/patterns.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import fg from "fast-glob";
+function detectNamingConvention(samples) {
+  if (samples.length === 0) return "mixed";
+  const patterns = {
+    camelCase: /^[a-z][a-zA-Z0-9]*$/,
+    PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+    snake_case: /^[a-z][a-z0-9_]*$/,
+    "kebab-case": /^[a-z][a-z0-9-]*$/,
+    SCREAMING_SNAKE_CASE: /^[A-Z][A-Z0-9_]*$/
+  };
+  const counts = {
+    camelCase: 0,
+    PascalCase: 0,
+    snake_case: 0,
+    "kebab-case": 0,
+    SCREAMING_SNAKE_CASE: 0,
+    mixed: 0
+  };
+  for (const sample of samples) {
+    const name = path2.basename(sample).replace(/\.[^.]+$/, "");
+    let matched = false;
+    for (const [convention, regex] of Object.entries(patterns)) {
+      if (regex.test(name)) {
+        counts[convention]++;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      counts.mixed++;
+    }
+  }
+  let maxCount = 0;
+  let dominant = "mixed";
+  for (const [convention, count] of Object.entries(counts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominant = convention;
+    }
+  }
+  if (maxCount < samples.length * 0.6) {
+    return "mixed";
+  }
+  return dominant;
+}
+async function detectNamingPatterns(cwd, stack) {
+  const patterns = {
+    files: {},
+    code: {
+      functions: "camelCase",
+      variables: "camelCase",
+      constants: "SCREAMING_SNAKE_CASE"
+    }
+  };
+  if (stack.language === "typescript" || stack.language === "javascript") {
+    const componentFiles = await fg(["**/components/**/*.{tsx,jsx}", "**/Components/**/*.{tsx,jsx}"], {
+      cwd,
+      ignore: ["**/node_modules/**"],
+      onlyFiles: true
+    });
+    if (componentFiles.length > 0) {
+      patterns.files.components = detectNamingConvention(componentFiles);
+      patterns.code.components = "PascalCase";
+    }
+    const utilFiles = await fg(["**/utils/**/*.{ts,js}", "**/lib/**/*.{ts,js}", "**/helpers/**/*.{ts,js}"], {
+      cwd,
+      ignore: ["**/node_modules/**"],
+      onlyFiles: true
+    });
+    if (utilFiles.length > 0) {
+      patterns.files.utilities = detectNamingConvention(utilFiles);
+    }
+    const testFiles = await fg(["**/*.test.{ts,tsx,js,jsx}", "**/*.spec.{ts,tsx,js,jsx}"], {
+      cwd,
+      ignore: ["**/node_modules/**"],
+      onlyFiles: true
+    });
+    if (testFiles.length > 0) {
+      const hasSpec = testFiles.some((f) => f.includes(".spec."));
+      const hasTest = testFiles.some((f) => f.includes(".test."));
+      patterns.files.tests = hasSpec && !hasTest ? "*.spec.ts" : "*.test.ts";
+    }
+    if (stack.language === "typescript") {
+      patterns.code.types = "PascalCase";
+    }
+  }
+  if (stack.language === "go") {
+    patterns.code.functions = "camelCase";
+    patterns.code.variables = "camelCase";
+    patterns.code.constants = "PascalCase";
+    patterns.files.utilities = "snake_case";
+  }
+  if (stack.language === "python") {
+    patterns.code.functions = "snake_case";
+    patterns.code.variables = "snake_case";
+    patterns.code.constants = "SCREAMING_SNAKE_CASE";
+    patterns.files.utilities = "snake_case";
+  }
+  return patterns;
+}
+async function detectDirectoryStructure(cwd, stack) {
+  const structure = {
+    type: "unknown",
+    sourceDir: ".",
+    keyDirectories: []
+  };
+  const sourceDirs = ["src", "app", "lib", "pkg", "internal", "cmd"];
+  for (const dir of sourceDirs) {
+    try {
+      const stat = await fs2.stat(path2.join(cwd, dir));
+      if (stat.isDirectory()) {
+        structure.sourceDir = dir;
+        break;
+      }
+    } catch {
+    }
+  }
+  const testDirs = ["test", "tests", "__tests__", "spec"];
+  for (const dir of testDirs) {
+    try {
+      const stat = await fs2.stat(path2.join(cwd, dir));
+      if (stat.isDirectory()) {
+        structure.testDir = dir;
+        break;
+      }
+    } catch {
+    }
+  }
+  const dirs = await fg(["**/"], {
+    cwd: path2.join(cwd, structure.sourceDir),
+    onlyDirectories: true,
+    deep: 2,
+    ignore: ["**/node_modules/**", "**/.git/**"]
+  });
+  const hasComponents = dirs.some((d) => d.includes("components"));
+  const hasFeatures = dirs.some((d) => d.includes("features"));
+  const hasModules = dirs.some((d) => d.includes("modules"));
+  const hasServices = dirs.some((d) => d.includes("services"));
+  const hasControllers = dirs.some((d) => d.includes("controllers"));
+  const hasRepositories = dirs.some((d) => d.includes("repositories"));
+  const hasHandlers = dirs.some((d) => d.includes("handlers"));
+  if (hasFeatures || hasModules) {
+    structure.type = "feature-based";
+  } else if ((hasControllers || hasHandlers) && (hasServices || hasRepositories)) {
+    structure.type = "layer-based";
+  } else if (hasComponents && !hasServices) {
+    structure.type = "flat";
+  } else if (hasComponents && hasServices) {
+    structure.type = "hybrid";
+  }
+  const keyDirPatterns = [
+    { pattern: "components", purpose: "UI Components" },
+    { pattern: "features", purpose: "Feature modules" },
+    { pattern: "services", purpose: "Business logic" },
+    { pattern: "hooks", purpose: "Custom React hooks" },
+    { pattern: "utils", purpose: "Utility functions" },
+    { pattern: "lib", purpose: "Library code" },
+    { pattern: "api", purpose: "API routes/handlers" },
+    { pattern: "pages", purpose: "Page components (Pages Router)" },
+    { pattern: "app", purpose: "App Router pages" },
+    { pattern: "controllers", purpose: "Request handlers" },
+    { pattern: "models", purpose: "Data models" },
+    { pattern: "repositories", purpose: "Data access layer" },
+    { pattern: "handlers", purpose: "HTTP handlers" },
+    { pattern: "middleware", purpose: "Middleware functions" },
+    { pattern: "types", purpose: "Type definitions" },
+    { pattern: "config", purpose: "Configuration" },
+    { pattern: "constants", purpose: "Constants and enums" }
+  ];
+  for (const { pattern, purpose } of keyDirPatterns) {
+    const matches = dirs.filter((d) => d.includes(pattern));
+    if (matches.length > 0) {
+      structure.keyDirectories.push({
+        path: matches[0],
+        purpose
+      });
+    }
+  }
+  return structure;
+}
+async function detectAdditionalPatterns(cwd, stack) {
+  const additional = {};
+  if (stack.language === "typescript" || stack.language === "javascript") {
+    try {
+      const tsconfig = await fs2.readFile(path2.join(cwd, "tsconfig.json"), "utf-8");
+      const config = JSON.parse(tsconfig);
+      if (config.compilerOptions?.paths) {
+        additional.imports = {
+          style: "absolute",
+          aliases: config.compilerOptions.paths
+        };
+      } else if (config.compilerOptions?.baseUrl) {
+        additional.imports = { style: "absolute" };
+      } else {
+        additional.imports = { style: "relative" };
+      }
+    } catch {
+      additional.imports = { style: "relative" };
+    }
+    const sampleFiles = await fg(["src/**/*.{ts,tsx}", "app/**/*.{ts,tsx}"], {
+      cwd,
+      ignore: ["**/node_modules/**"],
+      onlyFiles: true
+    });
+    let defaultExports = 0;
+    let namedExports = 0;
+    for (const file of sampleFiles.slice(0, 10)) {
+      try {
+        const content = await fs2.readFile(path2.join(cwd, file), "utf-8");
+        if (content.includes("export default")) defaultExports++;
+        if (content.match(/export\s+(const|function|class|interface|type)\s+/)) namedExports++;
+      } catch {
+      }
+    }
+    if (defaultExports > namedExports * 2) {
+      additional.exports = { style: "default" };
+    } else if (namedExports > defaultExports * 2) {
+      additional.exports = { style: "named" };
+    } else {
+      additional.exports = { style: "mixed" };
+    }
+  }
+  return additional;
+}
+async function detectPatterns(cwd, stack) {
+  const naming = await detectNamingPatterns(cwd, stack);
+  const structure = await detectDirectoryStructure(cwd, stack);
+  const additional = await detectAdditionalPatterns(cwd, stack);
+  return {
+    naming,
+    structure,
+    ...additional
+  };
+}
+
+// src/detectors/commands.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function detectCommands(cwd, stack) {
+  const commands = {};
+  if (stack.language === "typescript" || stack.language === "javascript") {
+    try {
+      const pkgContent = await fs3.readFile(path3.join(cwd, "package.json"), "utf-8");
+      const pkg2 = JSON.parse(pkgContent);
+      if (pkg2.scripts) {
+        const devCmd = pkg2.scripts.dev || pkg2.scripts.start || pkg2.scripts.serve;
+        if (devCmd) {
+          commands.dev = findScriptRunner(cwd, stack) + " run dev";
+        }
+        if (pkg2.scripts.build) {
+          commands.build = findScriptRunner(cwd, stack) + " run build";
+        }
+        if (pkg2.scripts.test) {
+          commands.test = findScriptRunner(cwd, stack) + " run test";
+        }
+        if (pkg2.scripts.lint) {
+          commands.lint = findScriptRunner(cwd, stack) + " run lint";
+        }
+        if (pkg2.scripts.format) {
+          commands.format = findScriptRunner(cwd, stack) + " run format";
+        }
+        if (pkg2.scripts.typecheck || pkg2.scripts["type-check"]) {
+          commands.typecheck = findScriptRunner(cwd, stack) + " run typecheck";
+        }
+      }
+    } catch {
+      commands.dev = "npm run dev";
+      commands.build = "npm run build";
+      commands.test = "npm test";
+    }
+  }
+  if (stack.language === "go") {
+    commands.build = "go build ./...";
+    commands.test = "go test ./...";
+    commands.lint = "golangci-lint run";
+    try {
+      const makefile = await fs3.readFile(path3.join(cwd, "Makefile"), "utf-8");
+      if (makefile.includes("run:")) commands.dev = "make run";
+      if (makefile.includes("build:")) commands.build = "make build";
+      if (makefile.includes("test:")) commands.test = "make test";
+      if (makefile.includes("lint:")) commands.lint = "make lint";
+    } catch {
+    }
+  }
+  if (stack.language === "python") {
+    commands.test = "pytest";
+    commands.lint = "ruff check .";
+    commands.format = "ruff format .";
+    if (stack.framework === "django") {
+      commands.dev = "python manage.py runserver";
+    } else if (stack.framework === "fastapi") {
+      commands.dev = "uvicorn main:app --reload";
+    } else if (stack.framework === "flask") {
+      commands.dev = "flask run";
+    }
+  }
+  if (stack.language === "ruby") {
+    if (stack.framework === "rails") {
+      commands.dev = "rails server";
+      commands.test = "rails test";
+      commands.lint = "rubocop";
+    }
+  }
+  if (stack.language === "rust") {
+    commands.build = "cargo build";
+    commands.test = "cargo test";
+    commands.lint = "cargo clippy";
+    commands.dev = "cargo run";
+  }
+  return commands;
+}
+function findScriptRunner(cwd, stack) {
+  switch (stack.packageManager) {
+    case "pnpm":
+      return "pnpm";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun";
+    default:
+      return "npm";
+  }
+}
+
+// src/detectors/documents.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import fg2 from "fast-glob";
+function extractSection(content, headerPatterns) {
+  const lines = [];
+  let inSection = false;
+  for (const line of content.split("\n")) {
+    const isTargetHeader = headerPatterns.some((pattern) => {
+      const regex = new RegExp(`^##\\s*${pattern}\\s*$`, "i");
+      return regex.test(line.trim());
+    });
+    if (isTargetHeader) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^##\s/.test(line)) {
+      break;
+    }
+    if (inSection) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
+        lines.push(trimmed.slice(2).trim());
+      } else if (/^\d+\.\s/.test(trimmed)) {
+        lines.push(trimmed.replace(/^\d+\.\s*/, "").trim());
+      }
+    }
+  }
+  return lines;
+}
+function extractCustomSections(content) {
+  const sections = {};
+  const lines = content.split("\n");
+  let currentHeader = "";
+  let currentContent = [];
+  const knownHeaders = [
+    "rules",
+    "\u30EB\u30FC\u30EB",
+    "conventions",
+    "\u898F\u7D04",
+    "must do",
+    "prefer",
+    "warnings",
+    "\u6CE8\u610F",
+    "tech stack",
+    "commands",
+    "project structure"
+  ];
+  for (const line of lines) {
+    const headerMatch = line.match(/^##\s+(.+)$/);
+    if (headerMatch) {
+      if (currentHeader && !knownHeaders.some(
+        (h) => currentHeader.toLowerCase().includes(h)
+      )) {
+        sections[currentHeader] = currentContent.join("\n").trim();
+      }
+      currentHeader = headerMatch[1].trim();
+      currentContent = [];
+    } else if (currentHeader) {
+      currentContent.push(line);
+    }
+  }
+  if (currentHeader && !knownHeaders.some(
+    (h) => currentHeader.toLowerCase().includes(h)
+  )) {
+    sections[currentHeader] = currentContent.join("\n").trim();
+  }
+  return sections;
+}
+async function parseClaudeMd(filePath) {
+  const content = await fs4.readFile(filePath, "utf-8");
+  return {
+    path: filePath,
+    content,
+    rules: extractSection(content, ["Rules", "\u30EB\u30FC\u30EB", "Project Rules"]),
+    conventions: extractSection(content, ["Conventions", "\u898F\u7D04", "Code Conventions"]),
+    warnings: extractSection(content, ["Warnings", "\u6CE8\u610F", "\u8B66\u544A", "Cautions"]),
+    mustDo: extractSection(content, ["Must Do", "\u5FC5\u9808", "Required"]),
+    prefer: extractSection(content, ["Prefer", "\u63A8\u5968", "Recommended"]),
+    customSections: extractCustomSections(content)
+  };
+}
+async function parseReadme(filePath) {
+  const content = await fs4.readFile(filePath, "utf-8");
+  const lines = content.split("\n");
+  let description = "";
+  let foundTitle = false;
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      foundTitle = true;
+      continue;
+    }
+    if (foundTitle && line.trim() && !line.startsWith("!") && !line.startsWith("[")) {
+      if (!line.includes("![") && !line.includes("[![")) {
+        description = line.trim();
+        break;
+      }
+    }
+  }
+  const badges = [];
+  const badgeRegex = /\[!\[.+?\]\(.+?\)\]\(.+?\)/g;
+  const matches = content.match(badgeRegex);
+  if (matches) {
+    badges.push(...matches);
+  }
+  return {
+    path: filePath,
+    content,
+    description,
+    badges
+  };
+}
+async function detectExistingAgents(cwd) {
+  const agents = [];
+  let agentDirectory;
+  let skillDirectory;
+  const agentDirs = [
+    { path: ".claude/agents", type: "agent" },
+    { path: ".agents", type: "agent" }
+  ];
+  const skillDirs = [
+    { path: ".claude/skills", type: "skill" },
+    { path: ".skills", type: "skill" }
+  ];
+  for (const dir of agentDirs) {
+    const fullPath = path4.join(cwd, dir.path);
+    try {
+      const stat = await fs4.stat(fullPath);
+      if (stat.isDirectory()) {
+        if (!agentDirectory) agentDirectory = dir.path;
+        const files = await fg2(["*.md"], {
+          cwd: fullPath,
+          onlyFiles: true
+        });
+        for (const file of files) {
+          if (file.startsWith("_")) continue;
+          const filePath = path4.join(fullPath, file);
+          const content = await fs4.readFile(filePath, "utf-8");
+          const name = path4.basename(file, ".md");
+          agents.push({
+            path: filePath,
+            name,
+            content,
+            type: "agent"
+          });
+        }
+        break;
+      }
+    } catch {
+    }
+  }
+  for (const dir of skillDirs) {
+    const fullPath = path4.join(cwd, dir.path);
+    try {
+      const stat = await fs4.stat(fullPath);
+      if (stat.isDirectory()) {
+        if (!skillDirectory) skillDirectory = dir.path;
+        const files = await fg2(["*.md"], {
+          cwd: fullPath,
+          onlyFiles: true
+        });
+        for (const file of files) {
+          if (file.startsWith("_") || file === "SKILL.md") continue;
+          const filePath = path4.join(fullPath, file);
+          const content = await fs4.readFile(filePath, "utf-8");
+          const name = path4.basename(file, ".md");
+          const isSkill = content.startsWith("---");
+          agents.push({
+            path: filePath,
+            name,
+            content,
+            type: isSkill ? "skill" : "agent"
+          });
+        }
+        break;
+      }
+    } catch {
+    }
+  }
+  return { agents, agentDirectory, skillDirectory };
+}
+async function detectProjectDocuments(cwd) {
+  const result = {
+    existingAgents: []
+  };
+  const claudeMdPaths = ["CLAUDE.md", "claude.md", ".claude/CLAUDE.md"];
+  for (const claudePath of claudeMdPaths) {
+    const fullPath = path4.join(cwd, claudePath);
+    try {
+      await fs4.access(fullPath);
+      result.claudeMd = await parseClaudeMd(fullPath);
+      break;
+    } catch {
+    }
+  }
+  const readmePaths = ["README.md", "readme.md", "Readme.md"];
+  for (const readmePath of readmePaths) {
+    const fullPath = path4.join(cwd, readmePath);
+    try {
+      await fs4.access(fullPath);
+      result.readme = await parseReadme(fullPath);
+      break;
+    } catch {
+    }
+  }
+  const { agents, agentDirectory, skillDirectory } = await detectExistingAgents(cwd);
+  result.existingAgents = agents;
+  result.agentDirectory = agentDirectory;
+  result.skillDirectory = skillDirectory;
+  if (result.claudeMd) {
+    result.claudeMdRawContent = result.claudeMd.content;
+  }
+  return result;
+}
+
+// src/claude-bridge.ts
+import { execSync, spawnSync } from "child_process";
+var LANGUAGE_NAMES = {
+  en: "English",
+  ja: "Japanese",
+  zh: "Chinese",
+  ko: "Korean",
+  es: "Spanish",
+  fr: "French",
+  de: "German"
+};
+function isClaudeAvailable() {
+  try {
+    const result = spawnSync("claude", ["--version"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function callClaude(prompt, options = {}) {
+  const { timeout = 12e4, verbose = false } = options;
+  if (verbose) {
+    console.log("\u{1F4E4} Sending to Claude Code...");
+  }
+  try {
+    const result = execSync(`claude -p "${escapeForShell(prompt)}"`, {
+      encoding: "utf-8",
+      timeout,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    });
+    return result.trim();
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Claude Code call failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function suggestAgents(analysis, documents, options = {}) {
+  const prompt = buildAgentSuggestionPrompt(analysis, documents, options.lang || "en");
+  const response = callClaude(prompt, options);
+  return parseAgentSuggestions(response);
+}
+function generateClaudeMdContent(analysis, documents, options = {}) {
+  const prompt = buildClaudeMdPrompt(analysis, documents, options.lang || "en");
+  return callClaude(prompt, options);
+}
+function generateAgentContent(agentName, agentDescription, analysis, documents, options = {}) {
+  const prompt = buildAgentPrompt(agentName, agentDescription, analysis, documents, options.lang || "en");
+  return callClaude(prompt, options);
+}
+function buildAgentSuggestionPrompt(analysis, documents, lang) {
+  const existingRules = documents.claudeMd?.rules || [];
+  const existingAgentsList = documents.existingAgents.filter((a) => a.type === "agent");
+  const existingAgentNames = existingAgentsList.map((a) => a.name);
+  const existingAgentsStr = existingAgentNames.length > 0 ? existingAgentNames.join(", ") : "none";
+  const langName = LANGUAGE_NAMES[lang];
+  const keyDirs = analysis.patterns.structure.keyDirectories || [];
+  const existingCount = existingAgentNames.length;
+  let suggestCount;
+  let suggestNote;
+  if (existingCount === 0) {
+    suggestCount = 5;
+    suggestNote = "This project has no agents yet. Suggest 5 agents to provide good coverage.";
+  } else if (existingCount <= 2) {
+    suggestCount = 3;
+    suggestNote = `This project has ${existingCount} agent(s). Suggest up to 3 MORE agents that complement the existing ones.`;
+  } else if (existingCount <= 4) {
+    suggestCount = 2;
+    suggestNote = `This project has ${existingCount} agents. Only suggest 1-2 MORE agents if there are clear gaps.`;
+  } else {
+    suggestCount = 1;
+    suggestNote = `This project already has ${existingCount} agents. Only suggest 0-1 agents if there's a critical gap. Return empty array [] if coverage is sufficient.`;
+  }
+  return `You are a project analysis expert. Based on the following project information, suggest Claude Code agents specifically tailored for this project.
+
+**IMPORTANT: All output text (description, focus, reason) must be in ${langName}.**
+
+## Suggestion Guidelines
+
+${suggestNote}
+
+**Maximum suggestions: ${suggestCount}**
+**If existing agents already cover the project well, return an EMPTY array: []**
+
+## Project Information
+
+- **Name**: ${analysis.projectName}
+- **Description**: ${analysis.description || "Not specified"}
+- **Language**: ${analysis.stack.language} ${analysis.stack.languageVersion || ""}
+- **Framework**: ${analysis.stack.framework}${analysis.stack.frameworkVersion ? " " + analysis.stack.frameworkVersion : ""}
+- **Test Framework**: ${analysis.stack.testFramework}
+- **Package Manager**: ${analysis.stack.packageManager}
+- **Additional Tools**: ${analysis.stack.additionalTools.join(", ") || "none"}
+- **Project Structure**: ${analysis.patterns.structure.type}
+- **Source Directory**: ${analysis.patterns.structure.sourceDir}
+- **Test Directory**: ${analysis.patterns.structure.testDir || "same as source"}
+
+## Key Directories
+${keyDirs.length > 0 ? keyDirs.map((d) => `- \`${d.path}\`: ${d.purpose}`).join("\n") : "Not analyzed"}
+
+## Commands
+- Build: \`${analysis.commands.build || "N/A"}\`
+- Test: \`${analysis.commands.test || "N/A"}\`
+- Lint: \`${analysis.commands.lint || "N/A"}\`
+
+## Code Patterns
+- Import Style: ${analysis.patterns.imports?.style || "mixed"}
+- Export Style: ${analysis.patterns.exports?.style || "mixed"}
+- Naming: functions=${analysis.patterns.naming.code.functions}, types=${analysis.patterns.naming.code.types || "PascalCase"}
+
+## Existing Rules/Conventions
+${existingRules.length > 0 ? existingRules.map((r) => `- ${r}`).join("\n") : "None specified"}
+
+## Existing Agents (NEVER duplicate these names)
+${existingAgentsStr}
+
+## Requirements
+
+1. **NEVER suggest agents with same names as existing agents**
+2. **HIGHLY PERSONALIZED**: Agents must be specific to THIS project, not generic
+3. **Complementary**: New agents should fill gaps, not overlap with existing ones
+4. **Practical focus**: Each agent should address a REAL need based on the project's stack
+5. **Write all descriptions in ${langName}**
+6. **Return empty array [] if existing agents are sufficient**
+
+## What makes a GOOD agent suggestion:
+- \u2705 "nextjs-app-router-optimizer" for a Next.js 14 project
+- \u2705 "vitest-coverage-improver" for a project using Vitest
+- \u274C "code-reviewer" (too generic)
+- \u274C Anything that overlaps with existing agents
+
+## Output Format (JSON)
+
+\`\`\`json
+[
+  {
+    "name": "specific-descriptive-name",
+    "description": "One-line description in ${langName}",
+    "focus": "The specific domain in ${langName}",
+    "reason": "Why valuable for THIS project specifically in ${langName}"
+  }
+]
+\`\`\`
+
+Output ONLY the JSON. Return [] if no new agents needed.`;
+}
+function buildClaudeMdPrompt(analysis, documents, lang) {
+  const existingContent = documents.claudeMd?.rawContent || "";
+  const langName = LANGUAGE_NAMES[lang];
+  return `You are a project documentation expert. Based on the following project information, generate a CLAUDE.md file (project description file for Claude Code).
+
+**IMPORTANT: Write the entire document in ${langName}.**
+
+## Project Information
+
+- **Name**: ${analysis.projectName}
+- **Description**: ${analysis.description || "Unknown"}
+- **Language**: ${analysis.stack.language} ${analysis.stack.languageVersion || ""}
+- **Framework**: ${analysis.stack.framework} ${analysis.stack.frameworkVersion || ""}
+- **Test Framework**: ${analysis.stack.testFramework}
+- **Package Manager**: ${analysis.stack.packageManager}
+- **Additional Tools**: ${analysis.stack.additionalTools.join(", ") || "none"}
+
+## Project Structure
+- Type: ${analysis.patterns.structure.type}
+- Source Directory: ${analysis.patterns.structure.sourceDir}
+- Test Directory: ${analysis.patterns.structure.testDir || "none"}
+
+## Commands
+- Development: ${analysis.commands.dev || "none"}
+- Build: ${analysis.commands.build || "none"}
+- Test: ${analysis.commands.test || "none"}
+- Lint: ${analysis.commands.lint || "none"}
+
+## Naming Conventions
+- Component Files: ${analysis.patterns.naming.files.components || "unknown"}
+- Test Files: ${analysis.patterns.naming.files.tests || "unknown"}
+- Functions: ${analysis.patterns.naming.code.functions}
+- Variables: ${analysis.patterns.naming.code.variables}
+
+${existingContent ? `## Existing CLAUDE.md Content (for reference)
+${existingContent}` : ""}
+
+## Requirements
+
+1. Create content that helps Claude Code understand and work effectively with this project
+2. Include important rules, conventions, and best practices
+3. Output in clear, readable Markdown format
+4. If existing content exists, improve upon it while preserving valuable information
+5. **Write the entire document in ${langName}**
+
+Output ONLY the Markdown content.`;
+}
+function buildAgentPrompt(agentName, agentDescription, analysis, documents, lang) {
+  const existingRules = documents.claudeMd?.rules || [];
+  const conventions = documents.claudeMd?.conventions || [];
+  const langName = LANGUAGE_NAMES[lang];
+  const keyDirs = analysis.patterns.structure.keyDirectories || [];
+  const existingAgentNames = documents.existingAgents.map((a) => a.name);
+  const claudeMdContent = documents.claudeMd?.rawContent || "";
+  return `You are a Claude Code agent design expert. Generate a HIGHLY PERSONALIZED agent definition for this specific project.
+
+**IMPORTANT: Write the entire agent definition in ${langName}.**
+
+## Agent to Generate
+- **Name**: ${agentName}
+- **Description**: ${agentDescription}
+
+## Project Context
+
+### Basic Info
+- **Project**: ${analysis.projectName}
+- **Description**: ${analysis.description || "Not specified"}
+- **Language**: ${analysis.stack.language} ${analysis.stack.languageVersion || ""}
+- **Framework**: ${analysis.stack.framework}${analysis.stack.frameworkVersion ? " " + analysis.stack.frameworkVersion : ""}
+- **Test Framework**: ${analysis.stack.testFramework}
+- **Package Manager**: ${analysis.stack.packageManager}
+
+### Project Structure
+- **Type**: ${analysis.patterns.structure.type}
+- **Source**: \`${analysis.patterns.structure.sourceDir}\`
+- **Tests**: \`${analysis.patterns.structure.testDir || analysis.patterns.structure.sourceDir}\`
+
+### Key Directories (IMPORTANT - reference these in the agent!)
+${keyDirs.length > 0 ? keyDirs.map((d) => `- \`${d.path}\`: ${d.purpose}`).join("\n") : "- Standard structure"}
+
+### Commands
+- Build: \`${analysis.commands.build || "npm run build"}\`
+- Test: \`${analysis.commands.test || "npm test"}\`
+- Lint: \`${analysis.commands.lint || "npm run lint"}\`
+- Typecheck: \`${analysis.commands.typecheck || "npm run typecheck"}\`
+
+### Code Conventions
+- Functions: ${analysis.patterns.naming.code.functions}
+- Variables: ${analysis.patterns.naming.code.variables}
+- Constants: ${analysis.patterns.naming.code.constants}
+- Types: ${analysis.patterns.naming.code.types || "PascalCase"}
+- Test files: ${analysis.patterns.naming.files.tests || "*.test.ts"}
+- Import style: ${analysis.patterns.imports?.style || "relative"}
+- Export style: ${analysis.patterns.exports?.style || "named"}
+
+### Project Rules (from CLAUDE.md)
+${existingRules.length > 0 ? existingRules.map((r) => `- ${r}`).join("\n") : "No explicit rules defined"}
+
+### Project Practices
+${conventions.length > 0 ? conventions.map((c) => `- ${c}`).join("\n") : "No explicit conventions defined"}
+
+${claudeMdContent ? `### Full CLAUDE.md Content (for deep context)
+\`\`\`
+${claudeMdContent.slice(0, 2e3)}${claudeMdContent.length > 2e3 ? "\n...(truncated)" : ""}
+\`\`\`` : ""}
+
+### Related Agents (for potential collaboration)
+${existingAgentNames.length > 0 ? existingAgentNames.map((n) => `- ${n}`).join("\n") : "This is the first agent"}
+
+## Generation Requirements
+
+1. **Be EXTREMELY specific** to this project:
+   - Reference actual directory paths (e.g., "when working in \`${analysis.patterns.structure.sourceDir}\`...")
+   - Mention the specific framework/versions
+   - Use the project's actual commands
+
+2. **Include project-specific code examples**:
+   - Show examples using the project's naming conventions
+   - Use the project's test framework syntax
+   - Follow the import/export style
+
+3. **Reference other agents** if relevant:
+   - Mention when to hand off to other agents
+   - Describe complementary workflows
+
+4. **Constraints must be actionable**:
+   - Include verification commands (e.g., "Run \`${analysis.commands.test}\` after changes")
+   - Reference project-specific limits or rules
+
+5. **Usage Examples must be concrete**:
+   - Use realistic file paths from this project
+   - Show actual commands the user would run
+
+## Output Format
+
+\`\`\`markdown
+# {Agent Name}
+
+{One-line description connecting to ${analysis.projectName}}
+
+## Role
+
+{Role specific to this ${analysis.stack.language}/${analysis.stack.framework} project}
+
+## Expertise
+
+{Bulleted list of expertise areas, referencing project specifics}
+
+## Instructions
+
+{Step-by-step instructions with project-specific details}
+{Include subsections for different scenarios}
+{Reference actual paths like \`${analysis.patterns.structure.sourceDir}/...\`}
+
+## Constraints
+
+{Numbered constraints with verification steps}
+{Include commands like \`${analysis.commands.test}\`, \`${analysis.commands.lint}\`}
+
+## Usage Examples
+
+{3+ concrete examples with:}
+- Realistic prompts a user might give
+- Expected behavior referencing project structure
+\`\`\`
+
+Output ONLY the Markdown content, no code fences around it.`;
+}
+function escapeForShell(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`").replace(/\n/g, "\\n");
+}
+function parseAgentSuggestions(response) {
+  try {
+    const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) || response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      console.warn("Could not parse agent suggestions from response");
+      return [];
+    }
+    const jsonStr = jsonMatch[1] || jsonMatch[0];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.map((item) => ({
+      name: String(item.name || ""),
+      description: String(item.description || ""),
+      focus: String(item.focus || ""),
+      reason: String(item.reason || "")
+    })).filter((s) => s.name && s.description);
+  } catch (error) {
+    console.warn("Failed to parse agent suggestions:", error);
+    return [];
+  }
+}
+
+// src/generator.ts
+function generateClaudeMd(result, options) {
+  const documents = options.documents || { existingAgents: [] };
+  if (isClaudeAvailable()) {
+    try {
+      if (options.verbose) {
+        console.log("\u{1F916} Generating CLAUDE.md using Claude Code...");
+      }
+      return generateClaudeMdContent(result, documents, { verbose: options.verbose, lang: options.lang });
+    } catch (error) {
+      console.warn("\u26A0\uFE0F Claude Code call failed, using fallback");
+      if (options.verbose && error instanceof Error) {
+        console.warn(`  Details: ${error.message}`);
+      }
+    }
+  } else if (options.verbose) {
+    console.log("\u2139\uFE0F Claude Code not available, using template");
+  }
+  if (options.template === "minimal") {
+    return generateMinimalFallback(result);
+  }
+  return generateFullFallback(result, options);
+}
+function generateMinimalFallback(result) {
+  const { projectName, stack, commands, patterns } = result;
+  const lines = [];
+  lines.push(`# ${projectName}`);
+  lines.push("");
+  lines.push("## Tech Stack");
+  lines.push(`- **Language**: ${formatLanguage(stack.language)}${stack.languageVersion ? ` ${stack.languageVersion}` : ""}`);
+  if (stack.framework !== "unknown") {
+    lines.push(`- **Framework**: ${formatFramework(stack.framework)}${stack.frameworkVersion ? ` ${stack.frameworkVersion}` : ""}`);
+  }
+  if (stack.testFramework !== "unknown") {
+    lines.push(`- **Testing**: ${formatTestFramework(stack.testFramework)}`);
+  }
+  lines.push("");
+  if (Object.keys(commands).length > 0) {
+    lines.push("## Commands");
+    lines.push("```bash");
+    if (commands.dev) lines.push(`# Development
+${commands.dev}`);
+    if (commands.build) lines.push(`
+# Build
+${commands.build}`);
+    if (commands.test) lines.push(`
+# Test
+${commands.test}`);
+    if (commands.lint) lines.push(`
+# Lint
+${commands.lint}`);
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Conventions");
+  if (patterns.naming.files.components) {
+    lines.push(`- Component files: ${patterns.naming.files.components}`);
+  }
+  if (patterns.naming.files.tests) {
+    lines.push(`- Test files: ${patterns.naming.files.tests}`);
+  }
+  if (patterns.structure.type !== "unknown") {
+    lines.push(`- Project structure: ${formatStructureType(patterns.structure.type)}`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push(`*Generated by Proteus (fallback mode) on ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}*`);
+  return lines.join("\n");
+}
+function generateFullFallback(result, options) {
+  const { projectName, description, stack, commands, patterns, confidence } = result;
+  const lines = [];
+  lines.push(`# ${projectName}`);
+  lines.push("");
+  if (description) {
+    lines.push(`> ${description}`);
+    lines.push("");
+  }
+  lines.push("## Tech Stack");
+  lines.push("");
+  lines.push("| Category | Technology | Version |");
+  lines.push("|----------|------------|---------|");
+  lines.push(`| Language | ${formatLanguage(stack.language)} | ${stack.languageVersion || "-"} |`);
+  if (stack.framework !== "unknown") {
+    lines.push(`| Framework | ${formatFramework(stack.framework)} | ${stack.frameworkVersion || "-"} |`);
+  }
+  if (stack.testFramework !== "unknown") {
+    lines.push(`| Testing | ${formatTestFramework(stack.testFramework)} | - |`);
+  }
+  lines.push(`| Package Manager | ${stack.packageManager} | - |`);
+  lines.push("");
+  if (stack.additionalTools.length > 0) {
+    lines.push("### Additional Tools");
+    lines.push(stack.additionalTools.map((t) => `- ${t}`).join("\n"));
+    lines.push("");
+  }
+  lines.push("## Project Structure");
+  lines.push("");
+  lines.push(`- **Type**: ${formatStructureType(patterns.structure.type)}`);
+  lines.push(`- **Source Directory**: \`${patterns.structure.sourceDir}/\``);
+  if (patterns.structure.testDir) {
+    lines.push(`- **Test Directory**: \`${patterns.structure.testDir}/\``);
+  }
+  lines.push("");
+  if (Object.keys(commands).length > 0) {
+    lines.push("## Commands");
+    lines.push("");
+    lines.push("| Command | Description |");
+    lines.push("|---------|-------------|");
+    if (commands.dev) lines.push(`| \`${commands.dev}\` | Start development server |`);
+    if (commands.build) lines.push(`| \`${commands.build}\` | Build for production |`);
+    if (commands.test) lines.push(`| \`${commands.test}\` | Run tests |`);
+    if (commands.lint) lines.push(`| \`${commands.lint}\` | Run linter |`);
+    lines.push("");
+  }
+  lines.push("## Code Conventions");
+  lines.push("");
+  lines.push("### Naming");
+  lines.push("");
+  lines.push("| Type | Convention |");
+  lines.push("|------|------------|");
+  lines.push(`| Functions | ${patterns.naming.code.functions} |`);
+  lines.push(`| Variables | ${patterns.naming.code.variables} |`);
+  lines.push(`| Constants | ${patterns.naming.code.constants} |`);
+  if (patterns.naming.code.types) {
+    lines.push(`| Types/Interfaces | ${patterns.naming.code.types} |`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Proteus Metadata");
+  lines.push("");
+  lines.push("```yaml");
+  lines.push(`version: ${options.version}`);
+  lines.push(`generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`confidence: ${Math.round(confidence.overall * 100)}%`);
+  lines.push("mode: fallback (Claude Code not available)");
+  lines.push("```");
+  lines.push("");
+  lines.push("*This file was generated by [Proteus](https://github.com/ischca/proteus) in fallback mode.*");
+  lines.push("*Re-run with Claude Code available for better results.*");
+  return lines.join("\n");
+}
+function formatLanguage(lang) {
+  const map = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    go: "Go",
+    python: "Python",
+    rust: "Rust",
+    ruby: "Ruby",
+    java: "Java",
+    php: "PHP"
+  };
+  return map[lang] || lang;
+}
+function formatFramework(fw) {
+  const map = {
+    nextjs: "Next.js",
+    react: "React",
+    vue: "Vue.js",
+    angular: "Angular",
+    svelte: "Svelte",
+    express: "Express",
+    fastify: "Fastify",
+    nestjs: "NestJS",
+    gin: "Gin",
+    echo: "Echo",
+    fiber: "Fiber",
+    django: "Django",
+    flask: "Flask",
+    fastapi: "FastAPI",
+    rails: "Ruby on Rails",
+    spring: "Spring",
+    laravel: "Laravel",
+    actix: "Actix Web",
+    axum: "Axum"
+  };
+  return map[fw] || fw;
+}
+function formatTestFramework(tf) {
+  const map = {
+    jest: "Jest",
+    vitest: "Vitest",
+    mocha: "Mocha",
+    pytest: "pytest",
+    "go-test": "Go testing",
+    rspec: "RSpec",
+    junit: "JUnit",
+    phpunit: "PHPUnit"
+  };
+  return map[tf] || tf;
+}
+function formatStructureType(type) {
+  const map = {
+    flat: "Flat (simple)",
+    "feature-based": "Feature-based (modular)",
+    "layer-based": "Layer-based (MVC/Clean)",
+    hybrid: "Hybrid"
+  };
+  return map[type] || type;
+}
+
+// src/agent-generator.ts
+function suggestAgents2(analysis, documents, options = {}) {
+  if (!isClaudeAvailable()) {
+    if (options.verbose) {
+      console.log("\u26A0\uFE0F Claude Code not available, using default suggestions");
+    }
+    return getDefaultSuggestions(analysis);
+  }
+  try {
+    if (options.verbose) {
+      console.log("\u{1F916} Querying Claude Code for agent suggestions...");
+    }
+    return suggestAgents(analysis, documents, { verbose: options.verbose, lang: options.lang });
+  } catch (error) {
+    if (options.verbose) {
+      console.warn("\u26A0\uFE0F Claude Code call failed, using default suggestions");
+      if (error instanceof Error) {
+        console.warn(`  Details: ${error.message}`);
+      }
+    }
+    return getDefaultSuggestions(analysis);
+  }
+}
+function generateAgent(suggestion, analysis, documents, options = {}) {
+  const outputDir = options.outputDir || ".claude/agents";
+  if (!isClaudeAvailable()) {
+    if (options.verbose) {
+      console.log(`\u26A0\uFE0F Claude Code not available, using fallback for ${suggestion.name}`);
+    }
+    return {
+      name: suggestion.name,
+      description: suggestion.description,
+      content: generateFallbackAgent(suggestion, analysis, documents),
+      path: `${outputDir}/${suggestion.name}.md`
+    };
+  }
+  try {
+    if (options.verbose) {
+      console.log(`\u{1F916} Generating ${suggestion.name} agent...`);
+    }
+    const content = generateAgentContent(
+      suggestion.name,
+      suggestion.description,
+      analysis,
+      documents,
+      { verbose: options.verbose, lang: options.lang }
+    );
+    return {
+      name: suggestion.name,
+      description: suggestion.description,
+      content,
+      path: `${outputDir}/${suggestion.name}.md`
+    };
+  } catch (error) {
+    if (options.verbose) {
+      console.warn(`\u26A0\uFE0F Failed to generate ${suggestion.name}, using fallback`);
+      if (error instanceof Error) {
+        console.warn(`  Details: ${error.message}`);
+      }
+    }
+    return {
+      name: suggestion.name,
+      description: suggestion.description,
+      content: generateFallbackAgent(suggestion, analysis, documents),
+      path: `${outputDir}/${suggestion.name}.md`
+    };
+  }
+}
+function getDefaultSuggestions(analysis) {
+  const suggestions = [];
+  const { stack } = analysis;
+  suggestions.push({
+    name: "code-reviewer",
+    description: `${formatLanguage2(stack.language)} code review specialist`,
+    focus: "Code quality, best practices, security",
+    reason: "Code review is valuable for all projects"
+  });
+  if (stack.testFramework !== "unknown") {
+    suggestions.push({
+      name: "test-writer",
+      description: `${formatTestFramework2(stack.testFramework)} test writing specialist`,
+      focus: "Unit tests, integration tests, test coverage",
+      reason: `${formatTestFramework2(stack.testFramework)} detected in project`
+    });
+  }
+  if (stack.framework !== "unknown") {
+    if (["react", "vue", "svelte", "angular"].includes(stack.framework)) {
+      suggestions.push({
+        name: "component-builder",
+        description: `${formatFramework2(stack.framework)} component design specialist`,
+        focus: "Component design, state management, performance",
+        reason: `${formatFramework2(stack.framework)} frontend project`
+      });
+    } else if (["express", "fastify", "nestjs", "fastapi", "gin"].includes(stack.framework)) {
+      suggestions.push({
+        name: "api-designer",
+        description: `${formatFramework2(stack.framework)} API endpoint design specialist`,
+        focus: "API design, validation, error handling",
+        reason: `${formatFramework2(stack.framework)} backend project`
+      });
+    }
+  }
+  suggestions.push({
+    name: "docs-writer",
+    description: "Documentation writing specialist",
+    focus: "README, API docs, code comments",
+    reason: "Documentation is important for all projects"
+  });
+  suggestions.push({
+    name: "refactorer",
+    description: `${formatLanguage2(stack.language)} refactoring specialist`,
+    focus: "Code improvement, design patterns, technical debt",
+    reason: "Continuous code improvement"
+  });
+  return suggestions.slice(0, 5);
+}
+function generateFallbackAgent(suggestion, analysis, documents) {
+  const { stack, patterns, projectName } = analysis;
+  const rules = documents.claudeMd?.rules || [];
+  const conventions = documents.claudeMd?.conventions || [];
+  const lines = [];
+  lines.push(`# ${suggestion.name}`);
+  lines.push("");
+  lines.push(`> ${suggestion.description}`);
+  lines.push("");
+  lines.push("## Role");
+  lines.push("");
+  lines.push(`Handles ${suggestion.focus} for the ${projectName} project.`);
+  lines.push("");
+  lines.push("## Project Information");
+  lines.push("");
+  lines.push(`- **Language**: ${formatLanguage2(stack.language)}${stack.languageVersion ? ` ${stack.languageVersion}` : ""}`);
+  if (stack.framework !== "unknown") {
+    lines.push(`- **Framework**: ${formatFramework2(stack.framework)}`);
+  }
+  if (stack.testFramework !== "unknown") {
+    lines.push(`- **Testing**: ${formatTestFramework2(stack.testFramework)}`);
+  }
+  lines.push(`- **Structure**: ${patterns.structure.type}`);
+  lines.push("");
+  if (rules.length > 0 || conventions.length > 0) {
+    lines.push("## Project Rules");
+    lines.push("");
+    lines.push("Follow these rules:");
+    lines.push("");
+    [...rules, ...conventions].forEach((rule) => {
+      lines.push(`- ${rule}`);
+    });
+    lines.push("");
+  }
+  lines.push("## Instructions");
+  lines.push("");
+  lines.push(`This agent specializes in ${suggestion.focus}.`);
+  lines.push(`Follow ${formatLanguage2(stack.language)} best practices.`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by Proteus (fallback mode)*");
+  return lines.join("\n");
+}
+function formatLanguage2(lang) {
+  const map = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    go: "Go",
+    python: "Python",
+    rust: "Rust",
+    ruby: "Ruby",
+    java: "Java",
+    php: "PHP"
+  };
+  return map[lang] || lang;
+}
+function formatFramework2(fw) {
+  const map = {
+    nextjs: "Next.js",
+    react: "React",
+    vue: "Vue.js",
+    angular: "Angular",
+    svelte: "Svelte",
+    express: "Express",
+    fastify: "Fastify",
+    nestjs: "NestJS",
+    gin: "Gin",
+    echo: "Echo",
+    fiber: "Fiber",
+    django: "Django",
+    flask: "Flask",
+    fastapi: "FastAPI",
+    rails: "Ruby on Rails",
+    spring: "Spring",
+    laravel: "Laravel",
+    actix: "Actix Web",
+    axum: "Axum"
+  };
+  return map[fw] || fw;
+}
+function formatTestFramework2(tf) {
+  const map = {
+    jest: "Jest",
+    vitest: "Vitest",
+    mocha: "Mocha",
+    pytest: "pytest",
+    "go-test": "Go testing",
+    rspec: "RSpec",
+    junit: "JUnit",
+    phpunit: "PHPUnit"
+  };
+  return map[tf] || tf;
+}
+
+// src/skill-generator.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var I18N = {
+  en: {
+    skillName: "proteus",
+    skillDescription: "Select and delegate tasks to project-specific agents based on your needs",
+    roleTitle: "Role",
+    roleDescription: "You are a task router that analyzes user requests and delegates them to the most appropriate project-specific agent. Each agent is specialized for a particular aspect of this project.",
+    availableAgentsTitle: "Available Agents",
+    instructionsTitle: "Instructions",
+    instructions: [
+      "Analyze the user's request to understand the task type",
+      "Select the SINGLE most appropriate agent from the list below",
+      "Delegate the task to that agent using @agent-name",
+      "If no agent fits, handle the task directly or suggest which agent might be needed"
+    ],
+    examplesTitle: "Examples",
+    examples: [
+      'User: "Review this GraphQL resolver" \u2192 Delegate to the GraphQL-related agent',
+      'User: "Write tests for this endpoint" \u2192 Delegate to the test-writing agent',
+      'User: "Check if this follows our patterns" \u2192 Delegate to the pattern/style enforcement agent'
+    ]
+  },
+  ja: {
+    skillName: "proteus",
+    skillDescription: "\u30E6\u30FC\u30B6\u30FC\u306E\u30CB\u30FC\u30BA\u306B\u57FA\u3065\u3044\u3066\u3001\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u5C02\u7528\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u30BF\u30B9\u30AF\u3092\u59D4\u8B72\u3057\u307E\u3059",
+    roleTitle: "\u5F79\u5272",
+    roleDescription: "\u3042\u306A\u305F\u306F\u30BF\u30B9\u30AF\u30EB\u30FC\u30BF\u30FC\u3067\u3059\u3002\u30E6\u30FC\u30B6\u30FC\u306E\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u5206\u6790\u3057\u3001\u6700\u3082\u9069\u5207\u306A\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u5C02\u7528\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u59D4\u8B72\u3057\u307E\u3059\u3002\u5404\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306F\u3053\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u7279\u5B9A\u306E\u5074\u9762\u306B\u7279\u5316\u3057\u3066\u3044\u307E\u3059\u3002",
+    availableAgentsTitle: "\u5229\u7528\u53EF\u80FD\u306A\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8",
+    instructionsTitle: "\u624B\u9806",
+    instructions: [
+      "\u30E6\u30FC\u30B6\u30FC\u306E\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u5206\u6790\u3057\u3066\u30BF\u30B9\u30AF\u306E\u7A2E\u985E\u3092\u7406\u89E3\u3059\u308B",
+      "\u4EE5\u4E0B\u306E\u30EA\u30B9\u30C8\u304B\u3089\u6700\u3082\u9069\u5207\u306A\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u30921\u3064\u9078\u629E\u3059\u308B",
+      "@agent-name \u3092\u4F7F\u7528\u3057\u3066\u305D\u306E\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u30BF\u30B9\u30AF\u3092\u59D4\u8B72\u3059\u308B",
+      "\u9069\u5207\u306A\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u306A\u3044\u5834\u5408\u306F\u3001\u76F4\u63A5\u30BF\u30B9\u30AF\u3092\u51E6\u7406\u3059\u308B\u304B\u3001\u5FC5\u8981\u306A\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u63D0\u6848\u3059\u308B"
+    ],
+    examplesTitle: "\u4F7F\u7528\u4F8B",
+    examples: [
+      "\u30E6\u30FC\u30B6\u30FC: \u300C\u3053\u306EGraphQL\u30EA\u30BE\u30EB\u30D0\u3092\u30EC\u30D3\u30E5\u30FC\u3057\u3066\u300D\u2192 GraphQL\u95A2\u9023\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u59D4\u8B72",
+      "\u30E6\u30FC\u30B6\u30FC: \u300C\u3053\u306E\u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8\u306E\u30C6\u30B9\u30C8\u3092\u66F8\u3044\u3066\u300D\u2192 \u30C6\u30B9\u30C8\u4F5C\u6210\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u59D4\u8B72",
+      "\u30E6\u30FC\u30B6\u30FC: \u300C\u3053\u308C\u304C\u30D1\u30BF\u30FC\u30F3\u306B\u5F93\u3063\u3066\u3044\u308B\u304B\u78BA\u8A8D\u3057\u3066\u300D\u2192 \u30D1\u30BF\u30FC\u30F3/\u30B9\u30BF\u30A4\u30EB\u9069\u7528\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u59D4\u8B72"
+    ]
+  },
+  zh: {
+    skillName: "proteus",
+    skillDescription: "\u6839\u636E\u60A8\u7684\u9700\u6C42\u9009\u62E9\u5E76\u5C06\u4EFB\u52A1\u59D4\u6D3E\u7ED9\u9879\u76EE\u4E13\u7528\u4EE3\u7406",
+    roleTitle: "\u89D2\u8272",
+    roleDescription: "\u60A8\u662F\u4E00\u4E2A\u4EFB\u52A1\u8DEF\u7531\u5668\uFF0C\u5206\u6790\u7528\u6237\u8BF7\u6C42\u5E76\u5C06\u5176\u59D4\u6D3E\u7ED9\u6700\u5408\u9002\u7684\u9879\u76EE\u4E13\u7528\u4EE3\u7406\u3002\u6BCF\u4E2A\u4EE3\u7406\u90FD\u4E13\u95E8\u9488\u5BF9\u6B64\u9879\u76EE\u7684\u7279\u5B9A\u65B9\u9762\u3002",
+    availableAgentsTitle: "\u53EF\u7528\u4EE3\u7406",
+    instructionsTitle: "\u8BF4\u660E",
+    instructions: [
+      "\u5206\u6790\u7528\u6237\u8BF7\u6C42\u4EE5\u4E86\u89E3\u4EFB\u52A1\u7C7B\u578B",
+      "\u4ECE\u4E0B\u9762\u7684\u5217\u8868\u4E2D\u9009\u62E9\u6700\u5408\u9002\u7684\u5355\u4E2A\u4EE3\u7406",
+      "\u4F7F\u7528 @agent-name \u5C06\u4EFB\u52A1\u59D4\u6D3E\u7ED9\u8BE5\u4EE3\u7406",
+      "\u5982\u679C\u6CA1\u6709\u5408\u9002\u7684\u4EE3\u7406\uFF0C\u76F4\u63A5\u5904\u7406\u4EFB\u52A1\u6216\u5EFA\u8BAE\u53EF\u80FD\u9700\u8981\u7684\u4EE3\u7406"
+    ],
+    examplesTitle: "\u793A\u4F8B",
+    examples: [
+      '\u7528\u6237\uFF1A"\u5BA1\u67E5\u8FD9\u4E2AGraphQL\u89E3\u6790\u5668" \u2192 \u59D4\u6D3E\u7ED9GraphQL\u76F8\u5173\u4EE3\u7406',
+      '\u7528\u6237\uFF1A"\u4E3A\u8FD9\u4E2A\u7AEF\u70B9\u7F16\u5199\u6D4B\u8BD5" \u2192 \u59D4\u6D3E\u7ED9\u6D4B\u8BD5\u7F16\u5199\u4EE3\u7406',
+      '\u7528\u6237\uFF1A"\u68C0\u67E5\u8FD9\u662F\u5426\u7B26\u5408\u6211\u4EEC\u7684\u6A21\u5F0F" \u2192 \u59D4\u6D3E\u7ED9\u6A21\u5F0F/\u98CE\u683C\u6267\u884C\u4EE3\u7406'
+    ]
+  },
+  ko: {
+    skillName: "proteus",
+    skillDescription: "\uC0AC\uC6A9\uC790\uC758 \uC694\uAD6C\uC5D0 \uB530\uB77C \uD504\uB85C\uC81D\uD2B8 \uC804\uC6A9 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC791\uC5C5\uC744 \uC704\uC784\uD569\uB2C8\uB2E4",
+    roleTitle: "\uC5ED\uD560",
+    roleDescription: "\uC0AC\uC6A9\uC790 \uC694\uCCAD\uC744 \uBD84\uC11D\uD558\uACE0 \uAC00\uC7A5 \uC801\uC808\uD55C \uD504\uB85C\uC81D\uD2B8 \uC804\uC6A9 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC704\uC784\uD558\uB294 \uC791\uC5C5 \uB77C\uC6B0\uD130\uC785\uB2C8\uB2E4. \uAC01 \uC5D0\uC774\uC804\uD2B8\uB294 \uC774 \uD504\uB85C\uC81D\uD2B8\uC758 \uD2B9\uC815 \uCE21\uBA74\uC5D0 \uD2B9\uD654\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.",
+    availableAgentsTitle: "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uC5D0\uC774\uC804\uD2B8",
+    instructionsTitle: "\uC9C0\uCE68",
+    instructions: [
+      "\uC0AC\uC6A9\uC790 \uC694\uCCAD\uC744 \uBD84\uC11D\uD558\uC5EC \uC791\uC5C5 \uC720\uD615 \uD30C\uC545",
+      "\uC544\uB798 \uBAA9\uB85D\uC5D0\uC11C \uAC00\uC7A5 \uC801\uC808\uD55C \uC5D0\uC774\uC804\uD2B8 \uD558\uB098 \uC120\uD0DD",
+      "@agent-name\uC744 \uC0AC\uC6A9\uD558\uC5EC \uD574\uB2F9 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC791\uC5C5 \uC704\uC784",
+      "\uC801\uC808\uD55C \uC5D0\uC774\uC804\uD2B8\uAC00 \uC5C6\uC73C\uBA74 \uC9C1\uC811 \uC791\uC5C5\uC744 \uCC98\uB9AC\uD558\uAC70\uB098 \uD544\uC694\uD55C \uC5D0\uC774\uC804\uD2B8 \uC81C\uC548"
+    ],
+    examplesTitle: "\uC608\uC2DC",
+    examples: [
+      '\uC0AC\uC6A9\uC790: "\uC774 GraphQL \uB9AC\uC878\uBC84 \uAC80\uD1A0\uD574\uC918" \u2192 GraphQL \uAD00\uB828 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC704\uC784',
+      '\uC0AC\uC6A9\uC790: "\uC774 \uC5D4\uB4DC\uD3EC\uC778\uD2B8 \uD14C\uC2A4\uD2B8 \uC791\uC131\uD574\uC918" \u2192 \uD14C\uC2A4\uD2B8 \uC791\uC131 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC704\uC784',
+      '\uC0AC\uC6A9\uC790: "\uC774\uAC83\uC774 \uD328\uD134\uC744 \uB530\uB974\uB294\uC9C0 \uD655\uC778\uD574\uC918" \u2192 \uD328\uD134/\uC2A4\uD0C0\uC77C \uC801\uC6A9 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC704\uC784'
+    ]
+  },
+  es: {
+    skillName: "proteus",
+    skillDescription: "Selecciona y delega tareas a agentes espec\xEDficos del proyecto seg\xFAn sus necesidades",
+    roleTitle: "Rol",
+    roleDescription: "Eres un enrutador de tareas que analiza las solicitudes del usuario y las delega al agente espec\xEDfico del proyecto m\xE1s apropiado. Cada agente est\xE1 especializado en un aspecto particular de este proyecto.",
+    availableAgentsTitle: "Agentes Disponibles",
+    instructionsTitle: "Instrucciones",
+    instructions: [
+      "Analizar la solicitud del usuario para comprender el tipo de tarea",
+      "Seleccionar el agente m\xE1s apropiado de la lista siguiente",
+      "Delegar la tarea a ese agente usando @agent-name",
+      "Si ning\xFAn agente es adecuado, manejar la tarea directamente o sugerir qu\xE9 agente podr\xEDa necesitarse"
+    ],
+    examplesTitle: "Ejemplos",
+    examples: [
+      'Usuario: "Revisa este resolver de GraphQL" \u2192 Delegar al agente relacionado con GraphQL',
+      'Usuario: "Escribe pruebas para este endpoint" \u2192 Delegar al agente de escritura de pruebas',
+      'Usuario: "Verifica si esto sigue nuestros patrones" \u2192 Delegar al agente de aplicaci\xF3n de patrones/estilos'
+    ]
+  },
+  fr: {
+    skillName: "proteus",
+    skillDescription: "S\xE9lectionne et d\xE9l\xE8gue les t\xE2ches aux agents sp\xE9cifiques au projet selon vos besoins",
+    roleTitle: "R\xF4le",
+    roleDescription: "Vous \xEAtes un routeur de t\xE2ches qui analyse les demandes des utilisateurs et les d\xE9l\xE8gue \xE0 l'agent sp\xE9cifique au projet le plus appropri\xE9. Chaque agent est sp\xE9cialis\xE9 dans un aspect particulier de ce projet.",
+    availableAgentsTitle: "Agents Disponibles",
+    instructionsTitle: "Instructions",
+    instructions: [
+      "Analyser la demande de l'utilisateur pour comprendre le type de t\xE2che",
+      "S\xE9lectionner l'agent le plus appropri\xE9 dans la liste ci-dessous",
+      "D\xE9l\xE9guer la t\xE2che \xE0 cet agent en utilisant @agent-name",
+      "Si aucun agent ne convient, g\xE9rer la t\xE2che directement ou sugg\xE9rer quel agent pourrait \xEAtre n\xE9cessaire"
+    ],
+    examplesTitle: "Exemples",
+    examples: [
+      `Utilisateur : "R\xE9vise ce r\xE9solveur GraphQL" \u2192 D\xE9l\xE9guer \xE0 l'agent li\xE9 \xE0 GraphQL`,
+      `Utilisateur : "\xC9cris des tests pour ce endpoint" \u2192 D\xE9l\xE9guer \xE0 l'agent d'\xE9criture de tests`,
+      `Utilisateur : "V\xE9rifie si cela suit nos patterns" \u2192 D\xE9l\xE9guer \xE0 l'agent d'application des patterns/styles`
+    ]
+  },
+  de: {
+    skillName: "proteus",
+    skillDescription: "W\xE4hlt und delegiert Aufgaben an projektspezifische Agenten basierend auf Ihren Anforderungen",
+    roleTitle: "Rolle",
+    roleDescription: "Sie sind ein Aufgaben-Router, der Benutzeranfragen analysiert und sie an den am besten geeigneten projektspezifischen Agenten delegiert. Jeder Agent ist auf einen bestimmten Aspekt dieses Projekts spezialisiert.",
+    availableAgentsTitle: "Verf\xFCgbare Agenten",
+    instructionsTitle: "Anweisungen",
+    instructions: [
+      "Analysieren Sie die Anfrage des Benutzers, um den Aufgabentyp zu verstehen",
+      "W\xE4hlen Sie den am besten geeigneten Agenten aus der folgenden Liste",
+      "Delegieren Sie die Aufgabe an diesen Agenten mit @agent-name",
+      "Wenn kein Agent passt, bearbeiten Sie die Aufgabe direkt oder schlagen Sie vor, welcher Agent ben\xF6tigt werden k\xF6nnte"
+    ],
+    examplesTitle: "Beispiele",
+    examples: [
+      'Benutzer: "\xDCberpr\xFCfe diesen GraphQL-Resolver" \u2192 An den GraphQL-bezogenen Agenten delegieren',
+      'Benutzer: "Schreibe Tests f\xFCr diesen Endpoint" \u2192 An den Test-Schreib-Agenten delegieren',
+      'Benutzer: "Pr\xFCfe, ob dies unseren Mustern folgt" \u2192 An den Muster-/Stil-Durchsetzungs-Agenten delegieren'
+    ]
+  }
+};
+function generateProteusSkillContent(options) {
+  const { projectName, agents, lang = "en" } = options;
+  const t = I18N[lang];
+  const agentList = agents.filter((a) => a.type === "agent");
+  const agentListContent = agentList.map((agent) => {
+    const description = extractAgentDescription(agent.content);
+    return `- **@${agent.name}**: ${description}`;
+  }).join("\n");
+  const content = `---
+name: ${t.skillName}
+description: ${t.skillDescription}
+---
+
+# Proteus
+
+${t.roleDescription}
+
+**Project**: ${projectName}
+
+## ${t.availableAgentsTitle}
+
+${agentListContent || "_No agents available yet. Run `proteus` to generate project-specific agents._"}
+
+## ${t.instructionsTitle}
+
+${t.instructions.map((inst, i) => `${i + 1}. ${inst}`).join("\n")}
+
+## ${t.examplesTitle}
+
+${t.examples.map((ex) => `- ${ex}`).join("\n")}
+`;
+  return content;
+}
+function generateProteusSkill(options) {
+  const { outputDir = ".claude/skills", lang = "en" } = options;
+  const content = generateProteusSkillContent(options);
+  const skillDir = path5.join(outputDir, "proteus");
+  const skillPath = path5.join(skillDir, "SKILL.md");
+  return {
+    name: "proteus",
+    path: skillPath,
+    content
+  };
+}
+function saveProteusSkill(skill, projectPath) {
+  const fullDir = path5.join(projectPath, path5.dirname(skill.path));
+  const fullPath = path5.join(projectPath, skill.path);
+  if (!fs5.existsSync(fullDir)) {
+    fs5.mkdirSync(fullDir, { recursive: true });
+  }
+  fs5.writeFileSync(fullPath, skill.content, "utf-8");
+}
+function extractAgentDescription(content) {
+  const lines = content.split("\n");
+  let foundH1 = false;
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      foundH1 = true;
+      continue;
+    }
+    if (foundH1 && line.trim() && !line.startsWith("#")) {
+      return line.trim();
+    }
+  }
+  return "Project-specific agent";
+}
+
+// src/cli.ts
+var REASON_LABEL = {
+  en: "Reason",
+  ja: "\u7406\u7531",
+  zh: "\u539F\u56E0",
+  ko: "\uC774\uC720",
+  es: "Raz\xF3n",
+  fr: "Raison",
+  de: "Grund"
+};
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var pkgPath = path6.join(__dirname, "..", "package.json");
+var pkg = JSON.parse(await fs6.readFile(pkgPath, "utf-8"));
+var VERSION = pkg.version;
+var LOGO = `
+${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk.cyan("\u2551")}  ${chalk.bold.white("\u{1F531} PROTEUS")}                            ${chalk.cyan("\u2551")}
+${chalk.cyan("\u2551")}  ${chalk.gray("Shape-shifting project intelligence")}   ${chalk.cyan("\u2551")}
+${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+async function analyze(cwd) {
+  const spinner = ora("Detecting tech stack...").start();
+  const stack = await detectStack(cwd);
+  spinner.text = `Found: ${chalk.cyan(stack.language)} / ${chalk.cyan(stack.framework)}`;
+  spinner.succeed();
+  spinner.start("Analyzing code patterns...");
+  const patterns = await detectPatterns(cwd, stack);
+  spinner.succeed("Code patterns analyzed");
+  spinner.start("Detecting commands...");
+  const commands = await detectCommands(cwd, stack);
+  spinner.succeed("Commands detected");
+  const projectName = await getProjectName(cwd);
+  const confidence = calculateConfidence(stack, patterns);
+  return {
+    projectName,
+    projectPath: cwd,
+    stack,
+    patterns,
+    commands,
+    confidence
+  };
+}
+async function getProjectName(cwd) {
+  try {
+    const pkg2 = await fs6.readFile(path6.join(cwd, "package.json"), "utf-8");
+    const { name } = JSON.parse(pkg2);
+    if (name) return name;
+  } catch {
+  }
+  try {
+    const goMod = await fs6.readFile(path6.join(cwd, "go.mod"), "utf-8");
+    const match = goMod.match(/^module\s+(.+)$/m);
+    if (match) {
+      const parts = match[1].split("/");
+      return parts[parts.length - 1];
+    }
+  } catch {
+  }
+  try {
+    const cargo = await fs6.readFile(path6.join(cwd, "Cargo.toml"), "utf-8");
+    const match = cargo.match(/^name\s*=\s*"(.+)"/m);
+    if (match) return match[1];
+  } catch {
+  }
+  return path6.basename(cwd);
+}
+function calculateConfidence(stack, patterns) {
+  let stackScore = 0;
+  if (stack.language !== "unknown") stackScore += 0.4;
+  if (stack.framework !== "unknown") stackScore += 0.3;
+  if (stack.testFramework !== "unknown") stackScore += 0.2;
+  if (stack.packageManager !== "unknown") stackScore += 0.1;
+  let patternsScore = 0;
+  if (patterns.structure.type !== "unknown") patternsScore += 0.4;
+  if (patterns.structure.keyDirectories.length > 0) patternsScore += 0.3;
+  if (patterns.naming.files.components || patterns.naming.files.utilities) patternsScore += 0.3;
+  return {
+    stack: stackScore,
+    patterns: patternsScore,
+    overall: (stackScore + patternsScore) / 2
+  };
+}
+async function runTransform(options) {
+  console.log(LOGO);
+  const cwd = process.cwd();
+  const claudeAvailable = isClaudeAvailable();
+  if (claudeAvailable) {
+    console.log(chalk.green("\u2713 Claude Code detected - using AI-powered generation\n"));
+  } else {
+    console.log(chalk.yellow("\u26A0 Claude Code not found - using fallback templates\n"));
+    console.log(chalk.gray("  Install Claude Code for better results: https://claude.ai/code\n"));
+  }
+  let lang = options.lang || "en";
+  if (!options.lang && options.interactive && !options.force) {
+    const { selectedLang } = await prompts({
+      type: "select",
+      name: "selectedLang",
+      message: "Output language for generated files?",
+      choices: [
+        { title: "English", value: "en" },
+        { title: "\u65E5\u672C\u8A9E (Japanese)", value: "ja" },
+        { title: "\u4E2D\u6587 (Chinese)", value: "zh" },
+        { title: "\uD55C\uAD6D\uC5B4 (Korean)", value: "ko" },
+        { title: "Espa\xF1ol (Spanish)", value: "es" },
+        { title: "Fran\xE7ais (French)", value: "fr" },
+        { title: "Deutsch (German)", value: "de" }
+      ],
+      initial: 0
+    });
+    lang = selectedLang || "en";
+  }
+  console.log(chalk.gray(`
+Analyzing ${cwd}...
+`));
+  const analysis = await analyze(cwd);
+  const spinner = ora("Reading existing documents...").start();
+  let docs = await detectProjectDocuments(cwd);
+  if (docs.claudeMd) {
+    spinner.succeed(`Found CLAUDE.md with ${docs.claudeMd.rules.length} rules`);
+  } else {
+    spinner.succeed("No existing CLAUDE.md found");
+  }
+  const existingAgentCount = docs.existingAgents.filter((a) => a.type === "agent").length;
+  const existingSkillCount = docs.existingAgents.filter((a) => a.type === "skill").length;
+  if (existingAgentCount > 0 && docs.agentDirectory) {
+    console.log(chalk.gray(`  Found ${existingAgentCount} existing agent(s) in ${docs.agentDirectory}/`));
+  }
+  if (existingSkillCount > 0 && docs.skillDirectory) {
+    console.log(chalk.gray(`  Found ${existingSkillCount} existing skill(s) in ${docs.skillDirectory}/`));
+  }
+  printSummary(analysis);
+  if (!docs.claudeMd) {
+    let shouldGenerateClaudeMd = options.includeClaudeMd;
+    if (!shouldGenerateClaudeMd && options.interactive && !options.force) {
+      const { generateClaudeMd: userChoice } = await prompts({
+        type: "confirm",
+        name: "generateClaudeMd",
+        message: "No CLAUDE.md found. Generate one first? (Recommended for better agent generation)",
+        initial: true
+      });
+      shouldGenerateClaudeMd = userChoice;
+    }
+    if (shouldGenerateClaudeMd) {
+      console.log(chalk.cyan("\n\u{1F4C4} Generating CLAUDE.md...\n"));
+      const generatorOptions = {
+        template: "full",
+        includeExamples: true,
+        includeComments: true,
+        version: VERSION
+      };
+      const claudeContent = generateClaudeMd(analysis, { ...generatorOptions, documents: docs, verbose: options.verbose, lang });
+      await fs6.writeFile(path6.join(cwd, "CLAUDE.md"), claudeContent);
+      console.log(chalk.green("\u2705 Created CLAUDE.md\n"));
+      docs = await detectProjectDocuments(cwd);
+    }
+  }
+  console.log(chalk.cyan("\n\u{1F916} Generating agent suggestions...\n"));
+  const suggestions = suggestAgents2(analysis, docs, { verbose: options.verbose, lang });
+  if (suggestions.length === 0) {
+    if (existingAgentCount > 0) {
+      console.log(chalk.green(`\u2713 Project already has ${existingAgentCount} agent(s) with good coverage.`));
+      console.log(chalk.gray("  No additional agents recommended.\n"));
+      if (options.interactive && !options.force) {
+        const { generateSkillOnly } = await prompts({
+          type: "confirm",
+          name: "generateSkillOnly",
+          message: "Generate /proteus skill to use existing agents?",
+          initial: true
+        });
+        if (generateSkillOnly) {
+          const skillSpinner = ora("Generating proteus skill...").start();
+          try {
+            const existingAgentsForSkill = docs.existingAgents.filter((a) => a.type === "agent");
+            const skill = generateProteusSkill({
+              projectName: analysis.projectName,
+              agents: existingAgentsForSkill,
+              lang,
+              outputDir: ".claude/skills"
+            });
+            saveProteusSkill(skill, cwd);
+            skillSpinner.succeed("Created .claude/skills/proteus/SKILL.md");
+          } catch (error) {
+            skillSpinner.fail("Failed to generate proteus skill");
+          }
+        }
+      }
+      return;
+    } else {
+      console.log(chalk.yellow("No agent suggestions available. Try running with --verbose for details."));
+      return;
+    }
+  }
+  const existingAgentNames = docs.existingAgents.filter((a) => a.type === "agent").map((a) => a.name);
+  const duplicates = suggestions.filter((s) => existingAgentNames.includes(s.name));
+  if (duplicates.length > 0) {
+    console.log(chalk.yellow(`\u26A0 Warning: ${duplicates.length} suggested agent(s) already exist:`));
+    for (const d of duplicates) {
+      console.log(chalk.yellow(`  - ${d.name}`));
+    }
+    console.log("");
+  }
+  let selectedSuggestions;
+  const reasonLabel = REASON_LABEL[lang];
+  if (options.interactive && !options.force) {
+    console.log(chalk.bold("Recommended agents for this project:\n"));
+    for (let i = 0; i < suggestions.length; i++) {
+      const s = suggestions[i];
+      const isDuplicate = existingAgentNames.includes(s.name);
+      const nameDisplay = isDuplicate ? `${chalk.bold(s.name)} ${chalk.yellow("(exists)")}` : chalk.bold(s.name);
+      console.log(`  ${chalk.cyan(`${i + 1}.`)} ${nameDisplay}`);
+      console.log(`     ${chalk.white(s.description)}`);
+      console.log(`     ${chalk.gray(`${reasonLabel}: ${s.reason}`)}`);
+      console.log("");
+    }
+    const { selected } = await prompts({
+      type: "multiselect",
+      name: "selected",
+      message: "Select agents to generate",
+      choices: suggestions.map((s, i) => {
+        const isDuplicate = existingAgentNames.includes(s.name);
+        return {
+          title: isDuplicate ? `${s.name} (overwrite) - ${s.description}` : `${s.name} - ${s.description}`,
+          value: i,
+          selected: !isDuplicate
+          // Don't select duplicates by default
+        };
+      }),
+      hint: "- Space to toggle, Enter to confirm"
+    });
+    if (!selected || selected.length === 0) {
+      console.log(chalk.gray("No agents selected. Cancelled."));
+      return;
+    }
+    selectedSuggestions = selected.map((i) => suggestions[i]);
+    const selectedDuplicates = selectedSuggestions.filter((s) => existingAgentNames.includes(s.name));
+    if (selectedDuplicates.length > 0) {
+      const { confirmOverwrite } = await prompts({
+        type: "confirm",
+        name: "confirmOverwrite",
+        message: `Overwrite ${selectedDuplicates.length} existing agent(s)?`,
+        initial: false
+      });
+      if (!confirmOverwrite) {
+        selectedSuggestions = selectedSuggestions.filter((s) => !existingAgentNames.includes(s.name));
+        if (selectedSuggestions.length === 0) {
+          console.log(chalk.gray("No new agents to generate. Cancelled."));
+          return;
+        }
+      }
+    }
+  } else {
+    selectedSuggestions = options.force ? suggestions : suggestions.filter((s) => !existingAgentNames.includes(s.name));
+    if (selectedSuggestions.length === 0) {
+      console.log(chalk.yellow("All suggested agents already exist. Use --force to overwrite."));
+      return;
+    }
+    console.log(chalk.cyan("Agents to generate:"));
+    for (const s of selectedSuggestions) {
+      console.log(`  - ${chalk.white(s.name)}: ${s.description}`);
+    }
+  }
+  const outputDir = options.outputDir || ".claude/agents";
+  console.log(chalk.gray(`
+Output directory: ${outputDir}/`));
+  console.log(chalk.cyan("\n\u{1F531} Generating agents...\n"));
+  const agents = [];
+  const total = selectedSuggestions.length;
+  for (let i = 0; i < total; i++) {
+    const suggestion = selectedSuggestions[i];
+    const progress = `[${i + 1}/${total}]`;
+    const agentSpinner = ora(`${progress} Generating ${chalk.cyan(suggestion.name)}...`).start();
+    try {
+      const agent = generateAgent(suggestion, analysis, docs, {
+        outputDir,
+        verbose: false,
+        // Suppress verbose output during spinner
+        lang
+      });
+      agents.push(agent);
+      agentSpinner.succeed(`${progress} ${chalk.cyan(suggestion.name)} generated`);
+    } catch (error) {
+      agentSpinner.fail(`${progress} Failed to generate ${suggestion.name}`);
+      if (options.verbose && error instanceof Error) {
+        console.warn(chalk.gray(`  ${error.message}`));
+      }
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk.gray("\n--- Generated Agents (dry run) ---\n"));
+    for (const agent of agents) {
+      console.log(chalk.bold.cyan(`
+=== ${agent.name}.md ===
+`));
+      console.log(agent.content);
+    }
+    console.log(chalk.gray("\n--- End of preview ---\n"));
+    return;
+  }
+  if (options.interactive && !options.force) {
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: `Generate ${agents.length} agents in ${outputDir}/?`,
+      initial: true
+    });
+    if (!confirm) {
+      console.log(chalk.gray("Cancelled"));
+      return;
+    }
+  }
+  const fullOutputDir = path6.join(cwd, outputDir);
+  await fs6.mkdir(fullOutputDir, { recursive: true });
+  for (const agent of agents) {
+    const filePath = path6.join(fullOutputDir, `${agent.name}.md`);
+    await fs6.writeFile(filePath, agent.content);
+    console.log(chalk.green(`\u2705 Created ${outputDir}/${agent.name}.md`));
+  }
+  let registryUpdated = false;
+  if (options.interactive && !options.force) {
+    const { updateRegistry } = await prompts({
+      type: "confirm",
+      name: "updateRegistry",
+      message: "Update agent list in CLAUDE.md or agents.md?",
+      initial: true
+    });
+    if (updateRegistry) {
+      const registrySpinner = ora("Updating agent registry...").start();
+      try {
+        const result = updateAgentRegistry({
+          projectPath: cwd,
+          agentDir: outputDir,
+          lang
+        }, selectedSuggestions);
+        if (result) {
+          registrySpinner.succeed(`Agent list ${result.action} in ${result.file} (${result.agentCount} agents)`);
+          registryUpdated = true;
+        } else {
+          registrySpinner.warn("Could not update agent registry");
+        }
+      } catch (error) {
+        registrySpinner.fail("Failed to update agent registry");
+        if (options.verbose && error instanceof Error) {
+          console.warn(chalk.gray(`  ${error.message}`));
+        }
+      }
+    }
+  }
+  let skillGenerated = false;
+  if (options.interactive && !options.force) {
+    const { generateSkill } = await prompts({
+      type: "confirm",
+      name: "generateSkill",
+      message: "Generate /proteus skill to easily use these agents?",
+      initial: true
+    });
+    if (generateSkill) {
+      const skillSpinner = ora("Generating proteus skill...").start();
+      try {
+        const allAgents = scanExistingAgents(fullOutputDir);
+        const skill = generateProteusSkill({
+          projectName: analysis.projectName,
+          agents: allAgents.map((a) => ({ ...a, type: "agent", path: a.path, content: "" })),
+          lang,
+          outputDir: ".claude/skills"
+        });
+        const agentsWithContent = await Promise.all(
+          allAgents.map(async (a) => {
+            const content = await fs6.readFile(path6.join(fullOutputDir, a.path), "utf-8");
+            return { ...a, type: "agent", content };
+          })
+        );
+        const skillWithContent = generateProteusSkill({
+          projectName: analysis.projectName,
+          agents: agentsWithContent,
+          lang,
+          outputDir: ".claude/skills"
+        });
+        saveProteusSkill(skillWithContent, cwd);
+        skillSpinner.succeed(`Created .claude/skills/proteus/SKILL.md`);
+        skillGenerated = true;
+      } catch (error) {
+        skillSpinner.fail("Failed to generate proteus skill");
+        if (options.verbose && error instanceof Error) {
+          console.warn(chalk.gray(`  ${error.message}`));
+        }
+      }
+    }
+  }
+  console.log(chalk.gray("\n\u{1F531} Transformation complete!"));
+  console.log(chalk.gray("\nNext steps:"));
+  console.log(chalk.gray(`  1. Review agents in ${outputDir}/`));
+  if (skillGenerated) {
+    console.log(chalk.gray("  2. Use /proteus to route tasks to the right agent"));
+  }
+  console.log(chalk.gray(`  ${skillGenerated ? "3" : "2"}. Customize based on your needs`));
+  if (!registryUpdated) {
+    console.log(chalk.gray(`  ${skillGenerated ? "4" : "3"}. Run \`proteus registry\` to update agent list in docs`));
+  }
+}
+async function runInit(options) {
+  console.log(LOGO);
+  const cwd = process.cwd();
+  const claudeMdPath = path6.join(cwd, options.output || "CLAUDE.md");
+  let existingContent = null;
+  try {
+    existingContent = await fs6.readFile(claudeMdPath, "utf-8");
+  } catch {
+  }
+  if (existingContent && !options.force) {
+    console.log(chalk.yellow("\u26A0\uFE0F  CLAUDE.md already exists"));
+    if (options.interactive) {
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { title: "Overwrite", value: "overwrite" },
+          { title: "Run transform instead", value: "transform" },
+          { title: "Cancel", value: "cancel" }
+        ]
+      });
+      if (action === "cancel") {
+        console.log(chalk.gray("Cancelled"));
+        return;
+      }
+      if (action === "transform") {
+        await runTransform({
+          dryRun: options.dryRun,
+          force: options.force,
+          interactive: options.interactive,
+          includeClaudeMd: false,
+          verbose: false
+        });
+        return;
+      }
+    } else {
+      console.log(chalk.gray("Use --force to overwrite, or run `proteus transform`"));
+      return;
+    }
+  }
+  console.log(chalk.gray(`
+Analyzing ${cwd}...
+`));
+  const result = await analyze(cwd);
+  const docs = await detectProjectDocuments(cwd);
+  printSummary(result);
+  const generatorOptions = {
+    template: options.template,
+    includeExamples: true,
+    includeComments: true,
+    version: VERSION
+  };
+  const content = generateClaudeMd(result, { ...generatorOptions, documents: docs });
+  if (options.dryRun) {
+    console.log(chalk.gray("\n--- Generated CLAUDE.md (dry run) ---\n"));
+    console.log(content);
+    console.log(chalk.gray("\n--- End of preview ---\n"));
+    return;
+  }
+  if (options.interactive && !options.force) {
+    console.log(chalk.gray("\n--- Preview ---\n"));
+    console.log(content.split("\n").slice(0, 30).join("\n"));
+    console.log(chalk.gray("...\n"));
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: "Save CLAUDE.md?",
+      initial: true
+    });
+    if (!confirm) {
+      console.log(chalk.gray("Cancelled"));
+      return;
+    }
+  }
+  await fs6.writeFile(claudeMdPath, content);
+  console.log(chalk.green(`
+\u2705 Saved ${claudeMdPath}`));
+  console.log(chalk.gray("\nTip: Run `proteus` to generate project-specific agents!"));
+}
+function printSummary(result) {
+  const { stack, patterns, confidence } = result;
+  console.log(chalk.bold("\n\u{1F4CA} Analysis Summary\n"));
+  console.log(chalk.cyan("Tech Stack:"));
+  console.log(`  Language:    ${chalk.white(stack.language)}${stack.languageVersion ? ` (${stack.languageVersion})` : ""}`);
+  console.log(`  Framework:   ${chalk.white(stack.framework)}${stack.frameworkVersion ? ` (${stack.frameworkVersion})` : ""}`);
+  console.log(`  Testing:     ${chalk.white(stack.testFramework)}`);
+  console.log(`  Package Mgr: ${chalk.white(stack.packageManager)}`);
+  if (stack.styling) {
+    console.log(`  Styling:     ${chalk.white(stack.styling)}`);
+  }
+  if (stack.additionalTools.length > 0) {
+    console.log(`  Tools:       ${chalk.white(stack.additionalTools.join(", "))}`);
+  }
+  console.log(chalk.cyan("\nProject Structure:"));
+  console.log(`  Type:        ${chalk.white(patterns.structure.type)}`);
+  console.log(`  Source:      ${chalk.white(patterns.structure.sourceDir + "/")}`);
+  if (patterns.structure.keyDirectories.length > 0) {
+    console.log(`  Key dirs:    ${chalk.white(patterns.structure.keyDirectories.map((d) => d.path).join(", "))}`);
+  }
+  const confidenceColor = confidence.overall > 0.7 ? chalk.green : confidence.overall > 0.4 ? chalk.yellow : chalk.red;
+  console.log(chalk.cyan("\nConfidence:"));
+  console.log(`  Overall:     ${confidenceColor(Math.round(confidence.overall * 100) + "%")}`);
+}
+var program = new Command();
+program.name("proteus").description("\u{1F531} Shape-shifting project intelligence - Generate project-specific agents").version(VERSION);
+program.command("transform", { isDefault: true }).description("Analyze project and generate specialized agents (powered by Claude Code)").option("-o, --output <dir>", "Output directory for agents").option("-l, --lang <code>", "Output language (en, ja, zh, ko, es, fr, de)").option("-d, --dry-run", "Preview without saving", false).option("-f, --force", "Skip confirmations", false).option("-i, --interactive", "Interactive mode with confirmations", true).option("--include-claude-md", "Also generate CLAUDE.md if not exists", false).option("-v, --verbose", "Verbose output", false).action(async (opts) => {
+  try {
+    await runTransform({
+      outputDir: opts.output,
+      dryRun: opts.dryRun,
+      force: opts.force,
+      interactive: opts.interactive,
+      includeClaudeMd: opts.includeClaudeMd,
+      verbose: opts.verbose,
+      lang: opts.lang
+    });
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("init").description("Generate CLAUDE.md only (legacy)").option("-o, --output <path>", "Output file path", "CLAUDE.md").option("-t, --template <type>", "Template type (minimal|full)", "full").option("-d, --dry-run", "Preview without saving", false).option("-i, --interactive", "Interactive mode with confirmations", true).option("-f, --force", "Overwrite existing file without confirmation", false).action(async (opts) => {
+  try {
+    await runInit(opts);
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("analyze").description("Analyze project without generating anything").action(async () => {
+  try {
+    console.log(LOGO);
+    const cwd = process.cwd();
+    console.log(chalk.gray(`Analyzing ${cwd}...
+`));
+    const result = await analyze(cwd);
+    const docs = await detectProjectDocuments(cwd);
+    printSummary(result);
+    if (docs.claudeMd) {
+      console.log(chalk.cyan("\nExisting CLAUDE.md:"));
+      console.log(`  Rules:       ${docs.claudeMd.rules.length}`);
+      console.log(`  Conventions: ${docs.claudeMd.conventions.length}`);
+    }
+    if (docs.existingAgents.length > 0) {
+      console.log(chalk.cyan("\nExisting Agents:"));
+      for (const agent of docs.existingAgents) {
+        console.log(`  - ${agent.name}`);
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("registry").description("Update agent list in CLAUDE.md or agents.md").option("-a, --agent-dir <dir>", "Agent directory", ".claude/agents").option("-f, --format <type>", "Output format (table|list)", "table").option("-l, --lang <code>", "Output language (en, ja, zh, ko, es, fr, de)", "en").option("--dry-run", "Preview without saving", false).action(async (opts) => {
+  try {
+    console.log(LOGO);
+    const cwd = process.cwd();
+    const agentDir = opts.agentDir || ".claude/agents";
+    const fullAgentDir = path6.join(cwd, agentDir);
+    const spinner = ora("Scanning agents...").start();
+    const agents = scanExistingAgents(fullAgentDir);
+    if (agents.length === 0) {
+      spinner.warn(`No agents found in ${agentDir}/`);
+      console.log(chalk.gray("\nRun `proteus` to generate agents first."));
+      return;
+    }
+    spinner.succeed(`Found ${agents.length} agent(s)`);
+    console.log(chalk.cyan("\nAgents found:"));
+    for (const agent of agents) {
+      console.log(`  - ${chalk.white(agent.name)}`);
+      if (agent.description) {
+        console.log(`    ${chalk.gray(agent.description)}`);
+      }
+    }
+    if (opts.dryRun) {
+      console.log(chalk.gray("\n--- Preview (dry run) ---"));
+      const { generateAgentListSection } = await import("./agent-registry-IWDWNZDN.js");
+      console.log(generateAgentListSection(agents, agentDir, opts.format, opts.lang));
+      return;
+    }
+    const updateSpinner = ora("Updating registry...").start();
+    const result = updateAgentRegistry({
+      projectPath: cwd,
+      agentDir,
+      format: opts.format,
+      lang: opts.lang
+    });
+    if (result) {
+      updateSpinner.succeed(`Agent list ${result.action} in ${result.file} (${result.agentCount} agents)`);
+    } else {
+      updateSpinner.fail("Failed to update registry");
+    }
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();