@agilsee/mcp-orchestrator 0.5.0

package/bin/cli.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, cpSync } from "fs";
+import { join, resolve, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+import { execSync } from "child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CLAUDE_HOME = join(
+  process.env.USERPROFILE ?? process.env.HOME ?? "~",
+  ".claude"
+);
+
+const TEMPLATES_DIR = resolve(__dirname, "..", "templates");
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q) => new Promise((r) => rl.question(q, r));
+
+const command = process.argv[2];
+
+// ─── DETECT STACK ──────────────────────────────────────────────
+
+function detectStack(projectPath) {
+  // Priority order: most specific first
+  // 1. Next.js
+  for (const f of ["next.config.js", "next.config.mjs", "next.config.ts"]) {
+    if (existsSync(join(projectPath, f))) return "nextjs";
+  }
+
+  // 2. Laravel
+  if (existsSync(join(projectPath, "artisan")) && existsSync(join(projectPath, "composer.json"))) {
+    return "laravel";
+  }
+
+  // 3. Check package.json deps
+  const pkgPath = join(projectPath, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      // Express
+      if (allDeps["express"]) return "express";
+
+      // React (but not Next.js — already checked above)
+      if (allDeps["react"]) return "react";
+    } catch {}
+  }
+
+  return null;
+}
+
+// ─── GENERATE ──────────────────────────────────────────────────
+
+async function generate() {
+  const cwd = process.cwd();
+  const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+
+  console.log("\n🔧 MCP Generator\n");
+  console.log(`📂 Project: ${cwd}`);
+
+  // 1. Detect stack
+  const detected = detectStack(cwd);
+  if (!detected) {
+    console.log("❌ Stack tidak terdeteksi. Pastikan ada:");
+    console.log("   - Laravel: composer.json + artisan");
+    console.log("   - Next.js: next.config.js/mjs/ts");
+    console.log("   - Express: package.json dengan dependency 'express'");
+    console.log("   - React: package.json dengan dependency 'react'");
+    rl.close();
+    return;
+  }
+  console.log(`🔍 Stack detected: ${detected}`);
+
+  // 2. Ask project slug
+  const defaultSlug = projectName;
+  const slug = (await ask(`Project slug [${defaultSlug}]: `)).trim() || defaultSlug;
+
+  // 3. Setup output directory
+  const outputDir = join(CLAUDE_HOME, "mcp", slug);
+  if (existsSync(outputDir)) {
+    const overwrite = await ask(`⚠️  ${outputDir} sudah ada. Overwrite? (y/n): `);
+    if (overwrite.toLowerCase() !== "y") {
+      console.log("❌ Dibatalkan.");
+      rl.close();
+      return;
+    }
+  }
+
+  console.log(`\n📦 Generating MCP server for '${slug}' (${detected})...\n`);
+
+  // 4. Create directory structure
+  mkdirSync(join(outputDir, "src", "tools"), { recursive: true });
+  mkdirSync(join(outputDir, "src", "indexer"), { recursive: true });
+
+  // 5. Copy shared tools
+  const sharedDir = join(TEMPLATES_DIR, "shared");
+  const sharedFiles = ["get-claude-md.ts", "get-current-state.ts", "get-mistakes.ts", "log-task.ts", "record-mistake.ts", "update-state.ts", "predict-impact.ts"];
+  for (const f of sharedFiles) {
+    const src = join(sharedDir, f);
+    if (existsSync(src)) {
+      copyFileSync(src, join(outputDir, "src", "tools", f));
+      console.log(`  ✅ shared/${f}`);
+    }
+  }
+
+  // 6. Copy stack-specific files
+  const stackDir = join(TEMPLATES_DIR, "stacks", detected);
+  const stackConfig = JSON.parse(readFileSync(join(stackDir, "config.json"), "utf-8"));
+
+  if (existsSync(join(stackDir, "symbol-index.ts"))) {
+    copyFileSync(join(stackDir, "symbol-index.ts"), join(outputDir, "src", "indexer", "symbol-index.ts"));
+    console.log(`  ✅ ${detected}/symbol-index.ts`);
+  }
+  if (existsSync(join(stackDir, "list-routes.ts"))) {
+    copyFileSync(join(stackDir, "list-routes.ts"), join(outputDir, "src", "tools", "list-routes.ts"));
+    console.log(`  ✅ ${detected}/list-routes.ts`);
+  }
+
+  // 7. Generate index.ts
+  const indexContent = generateIndex(slug, cwd, detected, stackConfig);
+  writeFileSync(join(outputDir, "src", "index.ts"), indexContent);
+  console.log(`  ✅ index.ts (generated)`);
+
+  // 8. Generate tsconfig.json
+  writeFileSync(join(outputDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022", module: "Node16", moduleResolution: "Node16",
+      outDir: "./dist", rootDir: "./src", strict: true,
+      esModuleInterop: true, skipLibCheck: true, resolveJsonModule: true,
+      forceConsistentCasingInFileNames: true, declaration: false,
+    },
+    include: ["src/**/*"],
+  }, null, 2));
+  console.log(`  ✅ tsconfig.json`);
+
+  // 9. Generate package.json
+  writeFileSync(join(outputDir, "package.json"), JSON.stringify({
+    name: `mcp-${slug}`,
+    version: "0.1.0",
+    description: `MCP server for ${slug} (${stackConfig.label})`,
+    type: "module",
+    main: "./dist/index.js",
+    scripts: { build: "tsc", start: "node dist/index.js" },
+    dependencies: { "@modelcontextprotocol/sdk": "^1.0.4" },
+    devDependencies: { "@types/node": "^20.11.0", typescript: "^5.4.0" },
+  }, null, 2));
+  console.log(`  ✅ package.json`);
+
+  // 10. Create project-docs folder
+  const docsDir = join(CLAUDE_HOME, "project-docs", slug);
+  if (!existsSync(docsDir)) {
+    mkdirSync(docsDir, { recursive: true });
+    console.log(`  ✅ Created ${docsDir}`);
+  }
+
+  // 11. Install deps & build
+  console.log(`\n📥 Installing dependencies...`);
+  try {
+    execSync("npm install", { cwd: outputDir, stdio: "pipe" });
+    console.log(`  ✅ npm install`);
+  } catch (e) {
+    console.log(`  ⚠️  npm install failed — run manually: cd ${outputDir} && npm install`);
+  }
+
+  console.log(`🔨 Building...`);
+  try {
+    execSync("npm run build", { cwd: outputDir, stdio: "pipe" });
+    console.log(`  ✅ Build successful`);
+  } catch (e) {
+    console.log(`  ⚠️  Build failed — run manually: cd ${outputDir} && npm run build`);
+  }
+
+  console.log(`\n✅ MCP server '${slug}' generated at ${outputDir}`);
+  console.log(`\nJalankan 'asap-mcp link' di project untuk register ke .mcp.json\n`);
+
+  rl.close();
+}
+
+function generateIndex(slug, projectPath, stack, config) {
+  const scanRoots = JSON.stringify(config.scan_roots);
+  const fileExts = JSON.stringify(config.file_extensions);
+  const hasSymbolIndex = config.symbol_index !== false;
+  const pathEscaped = projectPath.replace(/\\/g, "\\\\");
+
+  let imports = `
+import { getClaudeMd } from "./tools/get-claude-md.js";
+import { getCurrentState } from "./tools/get-current-state.js";
+import { getMistakes } from "./tools/get-mistakes.js";
+import { logTask } from "./tools/log-task.js";
+import { updateState } from "./tools/update-state.js";
+import { recordMistake } from "./tools/record-mistake.js";
+import { predictImpact } from "./tools/predict-impact.js";
+import { listRoutes } from "./tools/list-routes.js";`;
+
+  let symbolInit = "";
+  let findSymbolImport = "";
+  let symbolTools = "";
+  let symbolHandlers = "";
+
+  if (hasSymbolIndex) {
+    findSymbolImport = `
+import { SymbolIndex } from "./indexer/symbol-index.js";`;
+    symbolInit = `const symbolIndex = new SymbolIndex(PROJECT_PATH);`;
+
+    const kindEnum = stack === "laravel"
+      ? '"function", "method", "class", "any"'
+      : '"function", "component", "class", "hook", "type", "context", "any"';
+
+    symbolTools = `,
+  {
+    name: "find_symbol",
+    description: "Cari function/method/class/component di codebase. Return: name, file, line, kind.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        name: { type: "string", description: "Exact name (case-sensitive)" },
+        kind: { type: "string", enum: [${kindEnum}], description: "Filter by kind, default any" },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "get_symbol_body",
+    description: "Ambil body fungsi/method/component (default 80 baris). Pakai SETELAH find_symbol.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        name: { type: "string" },
+        max_lines: { type: "number", description: "Max baris, default 80" },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "rebuild_index",
+    description: "Re-scan semua file di project untuk update symbol index.",
+    inputSchema: { type: "object" as const, properties: {} },
+  }`;
+
+    symbolHandlers = `
+      case "find_symbol": {
+        const name = String(args?.name ?? "");
+        await symbolIndex.ensureBuilt();
+        let results = symbolIndex.find(name, args?.kind ? String(args.kind) : undefined);
+        if (results.length === 0) {
+          const rb = await symbolIndex.rebuild();
+          results = symbolIndex.find(name, args?.kind ? String(args.kind) : undefined);
+          result = { query: { name, kind: args?.kind ?? "any" }, count: results.length, results, auto_rebuilt: true, rebuild_ms: rb.ms };
+        } else {
+          result = { query: { name, kind: args?.kind ?? "any" }, count: results.length, results };
+        }
+        break;
+      }
+      case "get_symbol_body": {
+        const name = String(args?.name ?? "");
+        const maxLines = typeof args?.max_lines === "number" ? args.max_lines : 80;
+        await symbolIndex.ensureBuilt();
+        let results = symbolIndex.find(name);
+        if (results.length === 0) { await symbolIndex.rebuild(); results = symbolIndex.find(name); }
+        if (results.length === 0) { result = { name, found: false }; break; }
+        const first = results[0];
+        const content = await readFile(first.file, "utf-8");
+        const lines = content.split("\\n");
+        const startLine = first.line - 1;
+        const endLine = Math.min(lines.length, startLine + maxLines);
+        result = { name, file: first.file, line: first.line, kind: first.kind, body: lines.slice(startLine, endLine).join("\\n"), truncated: endLine - startLine === maxLines };
+        break;
+      }
+      case "rebuild_index":
+        result = await symbolIndex.rebuild();
+        break;`;
+  }
+
+  return `#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { join } from "path";
+import { readFile } from "fs/promises";
+${imports}
+${findSymbolImport}
+
+const PROJECT_SLUG = process.env.PROJECT_SLUG ?? "${slug}";
+const PROJECT_PATH = process.env.PROJECT_PATH ?? "${pathEscaped}";
+const CLAUDE_HOME = process.env.CLAUDE_HOME ?? \`\${process.env.USERPROFILE ?? process.env.HOME}/.claude\`;
+const DOCS_PATH = join(CLAUDE_HOME, "project-docs", PROJECT_SLUG);
+
+${symbolInit}
+
+const server = new Server(
+  { name: "${slug}", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+
+const tools = [
+  { name: "get_claude_md", description: "Ambil CLAUDE.md project.", inputSchema: { type: "object" as const, properties: {} } },
+  { name: "get_current_state", description: "Ambil CURRENT_STATE.md — task aktif + selesai.", inputSchema: { type: "object" as const, properties: {} } },
+  { name: "get_mistakes", description: "Ambil MISTAKES.md, bisa filter by topic.", inputSchema: { type: "object" as const, properties: { topic: { type: "string", description: "Optional keyword filter" } } } },
+  { name: "list_routes", description: "List semua routes/pages di project.", inputSchema: { type: "object" as const, properties: {} } },
+  {
+    name: "predict_impact",
+    description: "Impact analysis — cari siapa yang pakai symbol ini. Panggil sebelum refactor.",
+    inputSchema: { type: "object" as const, properties: { symbol: { type: "string", description: "Nama symbol (case-sensitive)" } }, required: ["symbol"] },
+  },
+  {
+    name: "log_task",
+    description: "Catat task selesai ke AUDIT_LOG.md.",
+    inputSchema: { type: "object" as const, properties: { task_id: { type: "string" }, action: { type: "string" }, files: { type: "array", items: { type: "string" } }, result: { type: "string" } }, required: ["task_id", "action", "files", "result"] },
+  },
+  {
+    name: "update_state",
+    description: "Update CURRENT_STATE.md — tambah/complete/update task.",
+    inputSchema: { type: "object" as const, properties: { action: { type: "string", enum: ["add_task", "complete_task", "update_task"] }, task_id: { type: "string" }, title: { type: "string" }, status: { type: "string" }, scope: { type: "string" }, files_changed: { type: "array", items: { type: "string" } }, notes: { type: "string" } }, required: ["action", "task_id"] },
+  },
+  {
+    name: "record_mistake",
+    description: "Catat bug/gotcha ke MISTAKES.md.",
+    inputSchema: { type: "object" as const, properties: { title: { type: "string" }, found_during: { type: "string" }, file: { type: "string" }, root_cause: { type: "string" }, fix: { type: "string" }, impact: { type: "string", enum: ["low", "medium", "high"] }, related: { type: "string" } }, required: ["title", "found_during", "file", "root_cause", "fix", "impact"] },
+  }${symbolTools}
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    let result: unknown;
+    switch (name) {
+      case "get_claude_md": result = await getClaudeMd(DOCS_PATH); break;
+      case "get_current_state": result = await getCurrentState(DOCS_PATH); break;
+      case "get_mistakes": result = await getMistakes(DOCS_PATH, args?.topic ? String(args.topic) : undefined); break;
+      case "list_routes": result = await listRoutes(PROJECT_PATH); break;
+      case "predict_impact": result = await predictImpact(PROJECT_PATH, ${scanRoots}, ${fileExts}, String(args?.symbol ?? "")); break;
+      case "log_task": result = await logTask(DOCS_PATH, { task_id: String(args?.task_id ?? ""), action: String(args?.action ?? ""), files: Array.isArray(args?.files) ? args.files.map(String) : [], result: String(args?.result ?? "done") }); break;
+      case "update_state": result = await updateState(DOCS_PATH, { action: String(args?.action ?? "add_task") as any, task_id: String(args?.task_id ?? ""), title: args?.title ? String(args.title) : undefined, status: args?.status ? String(args.status) : undefined, scope: args?.scope ? String(args.scope) : undefined, files_changed: Array.isArray(args?.files_changed) ? args.files_changed.map(String) : undefined, notes: args?.notes ? String(args.notes) : undefined }); break;
+      case "record_mistake": result = await recordMistake(DOCS_PATH, { title: String(args?.title ?? ""), found_during: String(args?.found_during ?? ""), file: String(args?.file ?? ""), root_cause: String(args?.root_cause ?? ""), fix: String(args?.fix ?? ""), impact: (args?.impact as any) ?? "medium", related: args?.related ? String(args.related) : undefined }); break;
+${symbolHandlers}
+      default: throw new Error(\`Unknown tool: \${name}\`);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: \`Error: \${err instanceof Error ? err.message : String(err)}\` }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(\`[\${PROJECT_SLUG}-mcp] connected. path=\${PROJECT_PATH}\`);
+`;
+}
+
+// ─── INIT ──────────────────────────────────────────────────────
+
+async function init() {
+  console.log("\n🔧 MCP Orchestrator — Setup\n");
+
+  if (!existsSync(CLAUDE_HOME)) {
+    mkdirSync(CLAUDE_HOME, { recursive: true });
+    console.log(`✅ Created ${CLAUDE_HOME}`);
+  }
+
+  const name = await ask("Nama developer: ");
+  const email = await ask("Email: ");
+
+  const identityPath = join(CLAUDE_HOME, "agent-identity.json");
+  if (!existsSync(identityPath)) {
+    writeFileSync(identityPath, JSON.stringify({
+      name: "Agent Fullstack",
+      specialization: "Multi-stack: Laravel, React, Next.js, Express",
+      developer: { name, email },
+    }, null, 2));
+    console.log(`✅ Created ${identityPath}`);
+  } else {
+    console.log(`⏭️  ${identityPath} already exists, skipping`);
+  }
+
+  const focusPath = join(CLAUDE_HOME, "current-focus.json");
+  if (!existsSync(focusPath)) {
+    writeFileSync(focusPath, JSON.stringify({ mode: "general", active_profile: null, profiles: {} }, null, 2));
+    console.log(`✅ Created ${focusPath}`);
+  } else {
+    console.log(`⏭️  ${focusPath} already exists, skipping`);
+  }
+
+  const docsPath = join(CLAUDE_HOME, "project-docs");
+  if (!existsSync(docsPath)) {
+    mkdirSync(docsPath, { recursive: true });
+    console.log(`✅ Created ${docsPath}`);
+  }
+
+  console.log("\n✅ Setup selesai!\n");
+  console.log("Selanjutnya:");
+  console.log("  asap-mcp generate  — Generate MCP server untuk project");
+  console.log("  asap-mcp link      — Link semua MCP ke .mcp.json\n");
+
+  rl.close();
+}
+
+// ─── LINK ──────────────────────────────────────────────────────
+
+function link() {
+  const cwd = process.cwd();
+  const mcpConfigPath = join(cwd, ".mcp.json");
+
+  let config = { mcpServers: {} };
+  if (existsSync(mcpConfigPath)) {
+    try {
+      config = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch { config = { mcpServers: {} }; }
+  }
+
+  // 1. Orchestrator from npm
+  const orchestratorPath = resolve(__dirname, "..", "dist", "index.js");
+  if (existsSync(orchestratorPath)) {
+    const action = config.mcpServers.orchestrator ? "🔄 Updated" : "✅ Added";
+    config.mcpServers.orchestrator = {
+      command: "node",
+      args: [orchestratorPath.replace(/\\/g, "/")],
+      env: { CLAUDE_HOME: CLAUDE_HOME.replace(/\\/g, "/") },
+    };
+    console.log(`${action} 'orchestrator' (from npm package)`);
+  }
+
+  // 2. Scan ~/.claude/mcp/ for all MCP servers
+  const mcpRoot = join(CLAUDE_HOME, "mcp");
+  if (existsSync(mcpRoot)) {
+    try {
+      const entries = readdirSync(mcpRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === "orchestrator") continue;
+        const serverIndex = join(mcpRoot, entry.name, "dist", "index.js");
+        if (!existsSync(serverIndex)) continue;
+
+        const serverName = entry.name;
+        const action = config.mcpServers[serverName] ? "🔄 Updated" : "✅ Added";
+        config.mcpServers[serverName] = {
+          command: "node",
+          args: [serverIndex.replace(/\\/g, "/")],
+          env: { CLAUDE_HOME: CLAUDE_HOME.replace(/\\/g, "/") },
+        };
+        console.log(`${action} '${serverName}' (from ~/.claude/mcp/${entry.name}/)`);
+      }
+    } catch {}
+  }
+
+  const serverCount = Object.keys(config.mcpServers).length;
+  writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(`\n📄 ${mcpConfigPath}`);
+  console.log(`🔗 ${serverCount} MCP server(s) linked — mereka satu tim sekarang.`);
+  console.log("Restart Claude Code jika sudah running.\n");
+}
+
+// ─── INFO ──────────────────────────────────────────────────────
+
+function info() {
+  console.log("\n📦 @agilsee/mcp-orchestrator");
+  console.log(`   CLAUDE_HOME: ${CLAUDE_HOME}`);
+  console.log("\nCommands:");
+  console.log("  asap-mcp init       — Setup ~/.claude (identity, focus, project-docs)");
+  console.log("  asap-mcp generate   — Auto-detect stack & generate MCP server untuk project");
+  console.log("  asap-mcp link       — Link semua MCP servers ke .mcp.json");
+  console.log("  asap-mcp dashboard  — Open Memory Dashboard (localhost:37800)");
+  console.log("  asap-mcp info       — Show this info");
+  console.log("\nSupported stacks: Laravel, Next.js, Express, React (Vite/CRA)");
+  console.log("Memory Dashboard: http://localhost:37800\n");
+}
+
+// ─── MAIN ──────────────────────────────────────────────────────
+
+switch (command) {
+  case "init": await init(); break;
+  case "generate": await generate(); break;
+  case "link": link(); break;
+  case "info": info(); break;
+  case "dashboard": case "dash": case "ui": {
+    const { execSync, spawn } = await import("child_process");
+    const serverPath = path.join(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1")), "..", "dist", "server", "web-server.js");
+    console.log("Starting MCP Memory Dashboard...");
+    const child = spawn("node", [serverPath], { stdio: "inherit", env: { ...process.env, CLAUDE_HOME: CLAUDE_HOME } });
+    child.on("error", (err) => { console.error("Failed to start dashboard:", err.message); });
+    break;
+  }
+  default: info(); break;
+}