@agilsee/mcp-orchestrator 0.5.0

package/dist/tools/workflow-router.js

@@ -0,0 +1,438 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+// Intent patterns and their workflows
+const WORKFLOW_TEMPLATES = {
+    debug: (args) => [
+        {
+            order: 1,
+            action: "Cek known bugs terkait",
+            type: "mcp_tool",
+            tool: "get_mistakes",
+            args_hint: { topic: args.module ?? "" },
+            reason: "Jangan debug masalah yang sudah pernah ditemukan",
+        },
+        {
+            order: 2,
+            action: "Cek QCC cycle aktif yang related",
+            type: "mcp_tool",
+            tool: "qcc_status",
+            args_hint: args.module ? { slug: args.module } : {},
+            reason: "Bug ini mungkin sudah di-track dalam QCC",
+        },
+        {
+            order: 3,
+            action: "Systematic debugging",
+            type: "skill",
+            skill: "/debug",
+            reason: "Trace root cause secara terstruktur",
+        },
+        {
+            order: 4,
+            action: "Cari function terkait",
+            type: "mcp_tool",
+            tool: "find_symbol",
+            args_hint: { name: args.detail ?? "" },
+            reason: "Trace function yang bermasalah",
+            gate: "Jika perlu trace code",
+        },
+        {
+            order: 5,
+            action: "Cek blast radius sebelum fix",
+            type: "mcp_tool",
+            tool: "predict_impact",
+            args_hint: { symbol: args.detail ?? "" },
+            reason: "Pastikan fix tidak break hal lain",
+            gate: "Jika akan modify function",
+        },
+        {
+            order: 6,
+            action: "Catat bug yang ditemukan",
+            type: "mcp_tool",
+            tool: "record_mistake",
+            reason: "Supaya tidak terulang — auto cross-project check",
+        },
+        {
+            order: 7,
+            action: "Update QCC jika ada cycle aktif",
+            type: "mcp_tool",
+            tool: "qcc_update",
+            reason: "Track di QCC Step 6 (Pelaksanaan)",
+            gate: "Jika ada QCC cycle terkait",
+        },
+        {
+            order: 8,
+            action: "Log task selesai",
+            type: "mcp_tool",
+            tool: "log_task",
+            reason: "Audit trail",
+        },
+    ],
+    "new-feature": (args) => [
+        {
+            order: 1,
+            action: "Brainstorm requirements",
+            type: "skill",
+            skill: "/brainstorm",
+            reason: "Pahami requirements sebelum coding",
+        },
+        {
+            order: 2,
+            action: "Buat implementation plan",
+            type: "skill",
+            skill: "/write-plan",
+            reason: "Breakdown task, identify files",
+            gate: "Setelah brainstorm di-approve",
+        },
+        {
+            order: 3,
+            action: "Cek impact ke existing code",
+            type: "mcp_tool",
+            tool: "predict_impact",
+            reason: "Pastikan fitur baru tidak break existing",
+        },
+        {
+            order: 4,
+            action: "Eksekusi plan",
+            type: "skill",
+            skill: "/execute-plan",
+            reason: "Coding terstruktur sesuai plan",
+            gate: "Setelah plan di-approve",
+        },
+        {
+            order: 5,
+            action: "Code review",
+            type: "skill",
+            skill: "/code-review",
+            reason: "Review + security audit",
+            gate: "Setelah coding selesai",
+        },
+        {
+            order: 6,
+            action: "Log task selesai",
+            type: "mcp_tool",
+            tool: "log_task",
+            reason: "Audit trail",
+        },
+    ],
+    "fix-bug": (args) => [
+        {
+            order: 1,
+            action: "Cek known bugs",
+            type: "mcp_tool",
+            tool: "get_mistakes",
+            args_hint: { topic: args.module ?? "" },
+            reason: "Mungkin sudah pernah ditemukan",
+        },
+        {
+            order: 2,
+            action: "Trace bug",
+            type: "skill",
+            skill: "/trace-bug",
+            reason: "Trace dari Blade → Controller → API",
+        },
+        {
+            order: 3,
+            action: "Cek blast radius",
+            type: "mcp_tool",
+            tool: "predict_impact",
+            args_hint: { symbol: args.detail ?? "" },
+            reason: "Fix tidak boleh break hal lain",
+            gate: "Sebelum modify code",
+        },
+        {
+            order: 4,
+            action: "Fix & test",
+            type: "manual",
+            reason: "Apply fix, test di browser",
+        },
+        {
+            order: 5,
+            action: "Catat bug",
+            type: "mcp_tool",
+            tool: "record_mistake",
+            reason: "Knowledge base untuk future reference",
+        },
+        {
+            order: 6,
+            action: "Log task",
+            type: "mcp_tool",
+            tool: "log_task",
+            reason: "Audit trail",
+        },
+    ],
+    qcc: (args) => [
+        {
+            order: 1,
+            action: "Buat QCC cycle baru",
+            type: "mcp_tool",
+            tool: "qcc_create",
+            reason: "Step 1: Tema & Focus Target",
+        },
+        {
+            order: 2,
+            action: "Auto-analyze kondisi",
+            type: "mcp_tool",
+            tool: "qcc_analyze",
+            args_hint: { scope: "conditions", keyword: args.module ?? "" },
+            reason: "Step 2: Data dari MISTAKES.md + AUDIT_LOG.md",
+        },
+        {
+            order: 3,
+            action: "Define target SMART",
+            type: "mcp_tool",
+            tool: "qcc_update",
+            args_hint: { step: "3" },
+            reason: "Step 3: S/M/A/R/T",
+            gate: "Developer input needed",
+        },
+        {
+            order: 4,
+            action: "Auto-analyze fishbone",
+            type: "mcp_tool",
+            tool: "qcc_analyze",
+            args_hint: { scope: "fishbone", keyword: args.module ?? "" },
+            reason: "Step 4: Auto-categorize causes",
+        },
+        {
+            order: 5,
+            action: "Rencana penanggulangan",
+            type: "mcp_tool",
+            tool: "qcc_update",
+            args_hint: { step: "5" },
+            reason: "Step 5: Countermeasures",
+            gate: "Developer input needed",
+        },
+        {
+            order: 6,
+            action: "Track pelaksanaan",
+            type: "mcp_tool",
+            tool: "qcc_update",
+            args_hint: { step: "6" },
+            reason: "Step 6: Update per-action",
+            gate: "Ongoing — update as work progresses",
+        },
+        {
+            order: 7,
+            action: "Auto-evaluate before/after",
+            type: "mcp_tool",
+            tool: "qcc_evaluate",
+            reason: "Step 7: Compare MISTAKES.md data",
+            gate: "Setelah semua countermeasures done",
+        },
+        {
+            order: 8,
+            action: "Validasi & standardisasi",
+            type: "mcp_tool",
+            tool: "qcc_update",
+            args_hint: { step: "8" },
+            reason: "Step 8: Sign-off + horizontal deploy",
+            gate: "Setelah evaluasi confirm target tercapai",
+        },
+    ],
+    refactor: (args) => [
+        {
+            order: 1,
+            action: "Cek impact sebelum refactor",
+            type: "mcp_tool",
+            tool: "predict_impact",
+            args_hint: { symbol: args.detail ?? "" },
+            reason: "Tahu blast radius sebelum mulai",
+        },
+        {
+            order: 2,
+            action: "Buat plan",
+            type: "skill",
+            skill: "/write-plan",
+            reason: "Refactor harus terstruktur",
+        },
+        {
+            order: 3,
+            action: "Eksekusi",
+            type: "skill",
+            skill: "/execute-plan",
+            reason: "Step-by-step sesuai plan",
+            gate: "Setelah plan di-approve",
+        },
+        {
+            order: 4,
+            action: "Code review",
+            type: "skill",
+            skill: "/code-review",
+            reason: "Pastikan refactor tidak introduce bugs",
+        },
+        {
+            order: 5,
+            action: "Log task",
+            type: "mcp_tool",
+            tool: "log_task",
+            reason: "Audit trail",
+        },
+    ],
+    explore: (args) => [
+        {
+            order: 1,
+            action: "Generate system map",
+            type: "mcp_tool",
+            tool: "generate_system_map",
+            reason: "Overview arsitektur project",
+        },
+        {
+            order: 2,
+            action: "List routes",
+            type: "mcp_tool",
+            tool: "list_routes",
+            reason: "Semua endpoint FE",
+        },
+        {
+            order: 3,
+            action: "Cek current state",
+            type: "mcp_tool",
+            tool: "get_current_state",
+            reason: "Task aktif & yang baru selesai",
+        },
+        {
+            order: 4,
+            action: "Cek known bugs",
+            type: "mcp_tool",
+            tool: "get_mistakes",
+            args_hint: args.module ? { topic: args.module } : {},
+            reason: "Known issues di area ini",
+        },
+    ],
+    review: (_args) => [
+        {
+            order: 1,
+            action: "Code review + security audit",
+            type: "skill",
+            skill: "/code-review",
+            reason: "Review perubahan yang sudah dibuat",
+        },
+        {
+            order: 2,
+            action: "Cek blast radius",
+            type: "mcp_tool",
+            tool: "predict_impact",
+            reason: "Pastikan perubahan tidak impact modul lain",
+            gate: "Jika ada function yang diubah",
+        },
+        {
+            order: 3,
+            action: "Log review",
+            type: "mcp_tool",
+            tool: "log_task",
+            reason: "Audit trail",
+        },
+    ],
+};
+// --- Response Mode (Caveman-style compression per intent) ---
+const INTENSITY_MAP = {
+    debug: "ultra",
+    "fix-bug": "ultra",
+    review: "ultra",
+    refactor: "full",
+    "new-feature": "full",
+    explore: "lite",
+    qcc: "off",
+};
+const RESPONSE_RULES = {
+    ultra: [
+        "Maks 2 kalimat per poin. No intro, no recap, no filler.",
+        "Code snippet > penjelasan panjang. Simbol OK: → ✅ ❌ ⚠️",
+        "Jangan ulangi yang sudah user tahu. Fragment > kalimat lengkap.",
+        "Bilingual OK: Indo + English technical terms.",
+    ],
+    full: [
+        "Fragment > kalimat lengkap. No filler (Great question, Let me explain...).",
+        "Jawab langsung, skip pengantar dan penutup.",
+        "Code snippet > penjelasan panjang kalau bisa.",
+        "Bilingual OK: Indo + English technical terms.",
+    ],
+    lite: [
+        "Kalimat lengkap tapi ringkas. Skip filler dan basa-basi.",
+        "Boleh jelaskan jika konteks baru bagi user.",
+        "Bilingual OK: Indo + English technical terms.",
+    ],
+    off: [],
+};
+// Intent detection keywords
+const INTENT_KEYWORDS = {
+    debug: ["debug", "error", "bug", "gagal", "tidak jalan", "broken", "issue", "trace", "investigate"],
+    "new-feature": ["fitur baru", "new feature", "tambah fitur", "implement", "bikin", "buat baru", "create"],
+    "fix-bug": ["fix", "perbaiki", "hotfix", "patch", "benerin"],
+    qcc: ["qcc", "quality control", "improvement", "8 langkah", "fishbone", "root cause"],
+    refactor: ["refactor", "cleanup", "restructure", "reorganize", "split", "extract"],
+    explore: ["explore", "overview", "arsitektur", "architecture", "map", "understanding", "pahami"],
+    review: ["review", "audit", "cek code", "check code"],
+};
+export async function workflowRouter(claudeHome, args) {
+    const intentLower = args.intent.toLowerCase();
+    // Detect intent
+    let detectedIntent = "explore"; // default
+    let bestScore = 0;
+    for (const [intent, keywords] of Object.entries(INTENT_KEYWORDS)) {
+        let score = 0;
+        for (const kw of keywords) {
+            if (intentLower.includes(kw))
+                score += kw.split(" ").length; // multi-word = higher score
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            detectedIntent = intent;
+        }
+    }
+    // Get workflow template
+    const templateFn = WORKFLOW_TEMPLATES[detectedIntent];
+    if (!templateFn) {
+        return {
+            intent: args.intent,
+            workflow_name: "unknown",
+            response_mode: { intensity: "full", rules: RESPONSE_RULES.full },
+            steps: [],
+            estimated_calls: 0,
+            token_budget: "—",
+            notes: [`Intent "${detectedIntent}" tidak dikenali. Coba: debug, new-feature, fix-bug, qcc, refactor, explore, review.`],
+        };
+    }
+    const steps = templateFn(args);
+    // Check if there's active QCC that might be related
+    const notes = [];
+    try {
+        const focusRaw = await readFile(join(claudeHome, "current-focus.json"), "utf-8");
+        const focus = JSON.parse(focusRaw);
+        const profile = focus.profiles?.[focus.active_profile ?? ""] ?? {};
+        const activeProjects = profile.active_projects?.map((p) => p.slug ?? p) ?? [];
+        for (const slug of activeProjects) {
+            try {
+                const qccPath = join(claudeHome, "project-docs", slug, "QCC_CYCLES.md");
+                const qcc = await readFile(qccPath, "utf-8");
+                if (qcc.includes("**Status**: active")) {
+                    const match = qcc.match(/\[(QCC-\d+)\] Tema: (.+)/);
+                    if (match) {
+                        notes.push(`Ada QCC aktif: ${match[1]} "${match[2].trim()}". Hasil kerja ini mungkin bisa update QCC.`);
+                    }
+                }
+            }
+            catch { /* no qcc file */ }
+        }
+    }
+    catch { /* no focus */ }
+    // Estimate tokens
+    const toolCalls = steps.filter((s) => s.type === "mcp_tool").length;
+    const skillCalls = steps.filter((s) => s.type === "skill").length;
+    const estimatedTokens = toolCalls * 200 + skillCalls * 800;
+    // Determine response mode based on intent
+    const intensity = INTENSITY_MAP[detectedIntent] ?? "full";
+    const responseMode = {
+        intensity,
+        rules: RESPONSE_RULES[intensity] ?? [],
+    };
+    return {
+        intent: args.intent,
+        workflow_name: detectedIntent,
+        response_mode: responseMode,
+        steps,
+        estimated_calls: toolCalls + skillCalls,
+        token_budget: `~${estimatedTokens} tokens (${toolCalls} MCP tools × 200 + ${skillCalls} skills × 800)`,
+        notes,
+    };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@agilsee/mcp-orchestrator",
+  "version": "0.5.0",
+  "description": "MCP Orchestrator — identity, focus, workflow routing, QCC tracking, response compression. Multi-project memory layer for Claude Code with Loki.js + MiniSearch.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "mcp-orchestrator": "dist/index.js",
+    "asap-mcp": "bin/cli.js"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "templates/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "orchestrator",
+    "model-context-protocol",
+    "ai-agent",
+    "memory",
+    "loki"
+  ],
+  "author": "agilsee",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "lokijs": "^1.5.12",
+    "minisearch": "^7.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.0"
+  }
+}

package/templates/index.ts.template

@@ -0,0 +1,42 @@
+#!/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";
+// __STACK_IMPORTS__
+
+const PROJECT_SLUG = process.env.PROJECT_SLUG ?? "__PROJECT_SLUG__";
+const PROJECT_PATH = process.env.PROJECT_PATH ?? "__PROJECT_PATH__";
+const CLAUDE_HOME = process.env.CLAUDE_HOME ?? `${process.env.USERPROFILE ?? process.env.HOME}/.claude`;
+const DOCS_PATH = join(CLAUDE_HOME, "project-docs", PROJECT_SLUG);
+
+// __SYMBOL_INDEX_INIT__
+
+const server = new Server(
+  { name: "__PROJECT_SLUG__", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+
+const tools = __TOOLS_ARRAY__;
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    let result: unknown;
+    switch (name) {
+// __TOOL_HANDLERS__
+      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}`);

package/templates/shared/get-claude-md.ts

@@ -0,0 +1,12 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+export async function getClaudeMd(docsPath: string) {
+  const path = join(docsPath, "CLAUDE.md");
+  try {
+    const content = await readFile(path, "utf-8");
+    return { file: path, length: content.length, content };
+  } catch {
+    return { file: path, content: null, note: "CLAUDE.md belum ada" };
+  }
+}

package/templates/shared/get-current-state.ts

@@ -0,0 +1,21 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+export async function getCurrentState(docsPath: string) {
+  const path = join(docsPath, "CURRENT_STATE.md");
+  try {
+    const content = await readFile(path, "utf-8");
+    const active = extractSection(content, "Task Aktif");
+    const completed = extractSection(content, "Terakhir Selesai");
+    const blockers = extractSection(content, "Blockers");
+    return { file: path, active_task: active, recent_completed: completed?.slice(0, 2000) ?? null, blockers };
+  } catch {
+    return { file: path, active_task: null, recent_completed: null, blockers: null, note: "CURRENT_STATE.md belum ada" };
+  }
+}
+
+function extractSection(content: string, heading: string): string | null {
+  const regex = new RegExp(`##\\s+${heading}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`);
+  const match = content.match(regex);
+  return match ? match[1].trim() : null;
+}

package/templates/shared/get-mistakes.ts

@@ -0,0 +1,18 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+export async function getMistakes(docsPath: string, topic?: string) {
+  const path = join(docsPath, "MISTAKES.md");
+  try {
+    const content = await readFile(path, "utf-8");
+    if (!topic) {
+      return { file: path, length: content.length, preview: content.slice(0, 3000), truncated: content.length > 3000 };
+    }
+    const sections = content.split(/(?=^##\s)/m);
+    const lower = topic.toLowerCase();
+    const matches = sections.filter((s) => s.toLowerCase().includes(lower));
+    return { file: path, topic, match_count: matches.length, matches: matches.map((s) => s.slice(0, 1200)) };
+  } catch {
+    return { file: path, content: null, note: "MISTAKES.md belum ada" };
+  }
+}

package/templates/shared/log-task.ts

@@ -0,0 +1,27 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+
+interface LogTaskArgs {
+  task_id: string;
+  action: string;
+  files: string[];
+  result: string;
+}
+
+export async function logTask(docsPath: string, args: LogTaskArgs) {
+  const path = join(docsPath, "AUDIT_LOG.md");
+  await mkdir(dirname(path), { recursive: true });
+
+  let content: string;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch {
+    content = "# Audit Log\n\n> Auto-updated oleh agent setelah task selesai.\n\n| Date | Action | Files Touched | Result |\n|---|---|---|---|\n";
+  }
+
+  const date = new Date().toISOString().slice(0, 10);
+  const entry = `| ${date} | ${args.task_id} ${args.action} | ${args.files.join(", ")} | ${args.result} |`;
+  content = content.trimEnd() + "\n" + entry + "\n";
+  await writeFile(path, content, "utf-8");
+  return { file: path, entry, message: `Logged: ${args.task_id} — ${args.action}` };
+}

package/templates/shared/predict-impact.ts

@@ -0,0 +1,67 @@
+import { readdir, readFile, stat } from "fs/promises";
+import { join, relative } from "path";
+
+interface Caller { file: string; line: number; snippet: string; pattern: string; }
+interface ImpactResult {
+  symbol: string;
+  callers: Caller[];
+  summary: { total_callers: number; files_affected: number; severity: "low" | "medium" | "high" };
+  truncated: boolean;
+}
+
+const IGNORED_DIRS = new Set(["vendor", "node_modules", ".git", "storage", "bootstrap", "public", "tests", "dist", "build", ".next", "__pycache__", "venv"]);
+const MAX_CALLERS = 200;
+
+export async function predictImpact(
+  projectPath: string,
+  scanRoots: string[],
+  allowedExts: string[],
+  symbol: string
+): Promise<ImpactResult> {
+  if (!symbol) throw new Error("symbol is required");
+  const callers: Caller[] = [];
+  let truncated = false;
+  const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`\\b${escaped}\\b`);
+
+  for (const root of scanRoots) {
+    const full = join(projectPath, root);
+    try { await stat(full); } catch { continue; }
+    await scanDir(full, projectPath, regex, symbol, allowedExts, callers);
+    if (callers.length >= MAX_CALLERS) { truncated = true; break; }
+  }
+
+  const fileSet = new Set(callers.map((c) => c.file));
+  return {
+    symbol,
+    callers: callers.slice(0, MAX_CALLERS),
+    summary: {
+      total_callers: callers.length,
+      files_affected: fileSet.size,
+      severity: callers.length >= 20 || fileSet.size >= 10 ? "high" : callers.length >= 5 || fileSet.size >= 3 ? "medium" : "low",
+    },
+    truncated,
+  };
+}
+
+async function scanDir(dir: string, root: string, regex: RegExp, symbol: string, exts: string[], out: Caller[]): Promise<void> {
+  if (out.length >= MAX_CALLERS) return;
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || IGNORED_DIRS.has(entry.name)) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) { await scanDir(full, root, regex, symbol, exts, out); }
+    else if (entry.isFile() && exts.some((e) => entry.name.endsWith(e))) {
+      let content: string;
+      try { content = await readFile(full, "utf-8"); } catch { continue; }
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          out.push({ file: relative(root, full).replace(/\\/g, "/"), line: i + 1, snippet: lines[i].trim().slice(0, 200), pattern: "reference" });
+          if (out.length >= MAX_CALLERS) return;
+        }
+      }
+    }
+  }
+}