@agilsee/mcp-orchestrator 0.5.0

package/dist/tools/analyze-history.js

@@ -0,0 +1,213 @@
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+export async function analyzeHistory(claudeHome) {
+    const docsRoot = join(claudeHome, "project-docs");
+    let slugs;
+    try {
+        const entries = await readdir(docsRoot, { withFileTypes: true });
+        slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return emptyResult("Cannot read project-docs");
+    }
+    // Collect all audit entries and mistakes
+    const allFiles = new Map();
+    const allMistakes = [];
+    const allDates = [];
+    let totalTasks = 0;
+    for (const slug of slugs) {
+        // Parse AUDIT_LOG
+        try {
+            const auditPath = join(docsRoot, slug, "AUDIT_LOG.md");
+            const auditContent = await readFile(auditPath, "utf-8");
+            const auditEntries = parseAuditFiles(auditContent, slug);
+            totalTasks += auditEntries.length;
+            for (const entry of auditEntries) {
+                if (entry.date)
+                    allDates.push(entry.date);
+                for (const file of entry.files) {
+                    const normalized = normalizeFile(file);
+                    if (!normalized)
+                        continue;
+                    if (!allFiles.has(normalized)) {
+                        allFiles.set(normalized, { count: 0, projects: new Set(), tasks: [] });
+                    }
+                    const record = allFiles.get(normalized);
+                    record.count++;
+                    record.projects.add(slug);
+                    record.tasks.push(entry.action);
+                }
+            }
+        }
+        catch { /* skip */ }
+        // Parse MISTAKES
+        try {
+            const mistakePath = join(docsRoot, slug, "MISTAKES.md");
+            const mistakeContent = await readFile(mistakePath, "utf-8");
+            const mistakes = parseMistakes(mistakeContent, slug);
+            allMistakes.push(...mistakes);
+        }
+        catch { /* skip */ }
+    }
+    // === ANALYSIS ===
+    // 1. Hotspots: files touched 3+ times
+    const hotspots = Array.from(allFiles.entries())
+        .filter(([, v]) => v.count >= 3)
+        .sort((a, b) => b[1].count - a[1].count)
+        .slice(0, 10)
+        .map(([file, v]) => ({
+        file,
+        touch_count: v.count,
+        projects: Array.from(v.projects),
+    }));
+    // 2. Repeat bugs: similar root causes
+    const causeGroups = groupBySimilarity(allMistakes.map((m) => ({
+        key: m.root_cause.toLowerCase(),
+        label: m.title,
+        project: m.project,
+        date: m.date,
+    })));
+    const repeatBugs = causeGroups
+        .filter((g) => g.count >= 2)
+        .map((g) => ({
+        pattern: g.representative,
+        count: g.count,
+        entries: g.items.map((i) => `[${i.project}] ${i.label} (${i.date})`),
+    }));
+    // 3. Warnings based on analysis
+    const warnings = [];
+    const suggestions = [];
+    // Hotspot warnings
+    for (const hs of hotspots) {
+        if (hs.touch_count >= 5) {
+            warnings.push(`🔥 ${hs.file} disentuh ${hs.touch_count}x — kemungkinan file terlalu besar atau tanggung jawab terlalu banyak. Pertimbangkan refactor/split.`);
+        }
+    }
+    // Repeat bug warnings
+    for (const rb of repeatBugs) {
+        warnings.push(`🔁 Bug pattern "${rb.pattern}" muncul ${rb.count}x — ada masalah sistemik yang perlu di-address, bukan cuma fix per-case.`);
+    }
+    // Common mistake patterns
+    const readFirstBugs = allMistakes.filter((m) => m.root_cause.toLowerCase().includes("read-first") ||
+        m.root_cause.toLowerCase().includes("myisam") ||
+        m.root_cause.toLowerCase().includes("transaction"));
+    if (readFirstBugs.length >= 2) {
+        warnings.push(`⚠️ ${readFirstBugs.length} bugs terkait read-first/MyISAM/transaction — pertimbangkan auto-check sebelum save.`);
+    }
+    // Suggestions based on data
+    if (totalTasks > 0 && allMistakes.length === 0) {
+        suggestions.push("Belum ada MISTAKES.md tercatat — mulai catat bug yang ditemukan supaya pattern bisa terdeteksi.");
+    }
+    if (hotspots.length > 0) {
+        suggestions.push(`Top hotspot: ${hotspots[0].file} (${hotspots[0].touch_count}x). Setiap kali mau sentuh file ini, cek MISTAKES.md dulu — kemungkinan ada known gotcha.`);
+    }
+    if (totalTasks >= 10 && repeatBugs.length === 0) {
+        suggestions.push("Tidak ada repeat bug terdeteksi dari history — good sign, pattern sudah cukup bersih.");
+    }
+    // Cross-project file overlap
+    const crossProjectFiles = Array.from(allFiles.entries())
+        .filter(([, v]) => v.projects.size > 1);
+    if (crossProjectFiles.length > 0) {
+        suggestions.push(`${crossProjectFiles.length} file disentuh di multiple projects — perubahan di sini bisa impact project lain.`);
+    }
+    // Date range
+    allDates.sort();
+    const dateRange = allDates.length > 0
+        ? { earliest: allDates[0], latest: allDates[allDates.length - 1] }
+        : null;
+    return {
+        hotspots,
+        repeat_bugs: repeatBugs,
+        warnings,
+        suggestions,
+        stats: {
+            total_tasks: totalTasks,
+            total_mistakes: allMistakes.length,
+            projects_analyzed: slugs.length,
+            date_range: dateRange,
+        },
+    };
+}
+function parseAuditFiles(content, _slug) {
+    const entries = [];
+    for (const line of content.split("\n")) {
+        if (!line.startsWith("|"))
+            continue;
+        if (line.includes("---") || /\|\s*Date\s*\|/i.test(line))
+            continue;
+        const cols = line.split("|").map((c) => c.trim()).filter(Boolean);
+        if (cols.length < 3 || !/^\d{4}-\d{2}-\d{2}/.test(cols[0]))
+            continue;
+        entries.push({
+            date: cols[0],
+            action: cols[1],
+            files: cols[2].split(",").map((f) => f.trim()).filter(Boolean),
+        });
+    }
+    return entries;
+}
+function parseMistakes(content, project) {
+    const sections = content.split(/(?=^##\s)/m).filter((s) => s.trim());
+    const results = [];
+    for (const section of sections) {
+        const titleMatch = section.match(/^##\s+\[(\d{4}-\d{2}-\d{2})\]\s*—\s*(.+)$/m);
+        if (!titleMatch)
+            continue;
+        const fileMatch = section.match(/\*\*File\*\*:\s*(.+)/);
+        const causeMatch = section.match(/\*\*Root cause\*\*:\s*(.+)/);
+        results.push({
+            project,
+            date: titleMatch[1],
+            title: titleMatch[2].trim(),
+            file: fileMatch ? fileMatch[1].trim() : "",
+            root_cause: causeMatch ? causeMatch[1].trim() : "",
+        });
+    }
+    return results;
+}
+function normalizeFile(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === "—" || trimmed.length < 3)
+        return null;
+    // Remove line numbers, clean up
+    return trimmed.replace(/:\d+$/, "").replace(/\s*\(.*\)$/, "").trim();
+}
+function groupBySimilarity(items) {
+    const groups = [];
+    for (const item of items) {
+        let matched = false;
+        for (const group of groups) {
+            if (fuzzyMatch(item.key, group.items[0].key)) {
+                group.items.push(item);
+                group.count++;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            groups.push({ representative: item.label, count: 1, items: [item] });
+        }
+    }
+    return groups.sort((a, b) => b.count - a.count);
+}
+function fuzzyMatch(a, b) {
+    const wordsA = new Set(a.split(/\s+/).filter((w) => w.length > 3));
+    const wordsB = new Set(b.split(/\s+/).filter((w) => w.length > 3));
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return false;
+    let overlap = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            overlap++;
+    }
+    return overlap / Math.min(wordsA.size, wordsB.size) >= 0.5;
+}
+function emptyResult(note) {
+    return {
+        hotspots: [],
+        repeat_bugs: [],
+        warnings: [note],
+        suggestions: [],
+        stats: { total_tasks: 0, total_mistakes: 0, projects_analyzed: 0, date_range: null },
+    };
+}

package/dist/tools/auto-dispatch.js

@@ -0,0 +1,199 @@
+/**
+ * Auto-Dispatch — Orchestrator menganalisis query user,
+ * menentukan project mana yang terlibat, dan return dispatch plan
+ * berisi exact MCP tool calls yang harus Claude eksekusi.
+ *
+ * Flow: user query → detect module → search memory → build plan → Claude execute
+ */
+import { readFile } from "fs/promises";
+import { join } from "path";
+/**
+ * Module → project mapping.
+ *
+ * Default kosong. User bisa override dengan menulis file:
+ *   $CLAUDE_HOME/orchestrator-dispatch-map.json
+ *
+ * Format:
+ *   {
+ *     "order":    ["app-fe", "app-be"],
+ *     "invoice":  ["app-fe", "app-be"],
+ *     "vendor":   ["procurement-fe", "procurement-be"]
+ *   }
+ *
+ * Tanpa file ini, auto-dispatch fallback ke active_projects di current-focus.json.
+ */
+const DEFAULT_MODULE_PROJECT_MAP = {};
+// Intent detection patterns
+const INTENT_PATTERNS = {
+    debug: [/bug/i, /error/i, /gagal/i, /tidak (bisa|jalan|tampil|muncul)/i, /rusak/i, /broken/i, /fix/i, /issue/i, /masalah/i],
+    trace: [/trace/i, /lacak/i, /cari (di|ke) mana/i, /flow/i, /alur/i],
+    feature: [/tambah/i, /bikin/i, /buat/i, /new feature/i, /fitur baru/i, /implementasi/i],
+    review: [/review/i, /cek/i, /periksa/i, /audit/i],
+    refactor: [/refactor/i, /pindah/i, /restructure/i, /cleanup/i],
+};
+function detectModule(query, map) {
+    const q = query.toLowerCase();
+    for (const mod of Object.keys(map)) {
+        if (q.includes(mod.toLowerCase()))
+            return mod;
+    }
+    return "unknown";
+}
+function detectIntent(query) {
+    for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (pattern.test(query))
+                return intent;
+        }
+    }
+    return "explore";
+}
+function buildDispatchPlan(query, module, intent, projects, memoryHits) {
+    const targets = [];
+    for (const proj of projects) {
+        const agentName = proj; // MCP server name = project slug
+        const tools = [];
+        let order = 1;
+        // Step 1: Cek known bugs dulu (semua intent)
+        tools.push({
+            order: order++,
+            tool: `mcp__${agentName}__get_mistakes`,
+            args: { keyword: module !== "unknown" ? module : "" },
+            purpose: `Cek apakah bug terkait '${module}' sudah pernah ditemukan di ${proj}`,
+        });
+        // Step 2: Intent-specific tools
+        if (intent === "debug" || intent === "trace") {
+            // Find related symbols
+            const symbolQuery = module !== "unknown" ? module.replace(/-/g, "") : query.split(" ").slice(0, 2).join("");
+            tools.push({
+                order: order++,
+                tool: `mcp__${agentName}__find_symbol`,
+                args: { query: symbolQuery },
+                purpose: `Cari function/class terkait '${module}' di ${proj}`,
+            });
+            tools.push({
+                order: order++,
+                tool: `mcp__${agentName}__list_routes`,
+                args: {},
+                purpose: `List routes untuk trace endpoint terkait di ${proj}`,
+            });
+        }
+        if (intent === "feature" || intent === "refactor") {
+            tools.push({
+                order: order++,
+                tool: `mcp__${agentName}__find_symbol`,
+                args: { query: module !== "unknown" ? module : "" },
+                purpose: `Cari existing code terkait untuk extend/refactor di ${proj}`,
+            });
+            tools.push({
+                order: order++,
+                tool: `mcp__${agentName}__predict_impact`,
+                args: { symbol: module },
+                purpose: `Analisis impact perubahan di ${proj}`,
+            });
+        }
+        if (intent === "review") {
+            tools.push({
+                order: order++,
+                tool: `mcp__${agentName}__get_current_state`,
+                args: {},
+                purpose: `Cek state terkini ${proj}`,
+            });
+        }
+        // Determine role
+        const isFE = proj.includes("-fe") || proj.endsWith("-frontend") || proj.endsWith("-web");
+        const role = isFE ? "Trace di view/controller/JS" : "Trace di API/service/model/DB";
+        targets.push({
+            agent: agentName,
+            project_slug: proj,
+            tools,
+            reason: `${role} — ${proj} ${intent === "debug" ? "mungkin ada bug" : "perlu dicek"}`,
+        });
+    }
+    return targets;
+}
+async function loadDispatchMap(claudeHome) {
+    try {
+        const raw = await readFile(join(claudeHome, "orchestrator-dispatch-map.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object")
+            return parsed;
+    }
+    catch { }
+    return DEFAULT_MODULE_PROJECT_MAP;
+}
+export async function autoDispatch(claudeHome, args) {
+    const { query, force_projects } = args;
+    // 1. Load module map (user-overridable) + detect module & intent
+    const moduleMap = await loadDispatchMap(claudeHome);
+    const module = detectModule(query, moduleMap);
+    const intent = detectIntent(query);
+    // 2. Determine target projects
+    let projects;
+    if (force_projects && force_projects.length > 0) {
+        projects = force_projects;
+    }
+    else if (module !== "unknown" && moduleMap[module]) {
+        projects = moduleMap[module];
+    }
+    else {
+        // Default: cek focus aktif
+        try {
+            const focusRaw = await readFile(join(claudeHome, "current-focus.json"), "utf8");
+            const focus = JSON.parse(focusRaw);
+            projects = focus.active_projects?.map((p) => p.slug || p) || [];
+        }
+        catch {
+            projects = [];
+        }
+    }
+    // 3. Search memory for related issues
+    let memoryHits = 0;
+    try {
+        const { readFileSync, existsSync } = await import("fs");
+        const memDb = join(claudeHome, "data", "memory.json");
+        if (existsSync(memDb)) {
+            const db = JSON.parse(readFileSync(memDb, "utf8"));
+            const col = db.collections?.find((c) => c.name === "memories");
+            if (col?.data) {
+                const q = query.toLowerCase();
+                memoryHits = col.data.filter((e) => {
+                    const text = `${e.title} ${e.content} ${(e.tags || []).join(" ")}`.toLowerCase();
+                    return q.split(/\s+/).some((word) => word.length > 2 && text.includes(word));
+                }).length;
+            }
+        }
+    }
+    catch { }
+    // 4. Build dispatch plan
+    const targets = buildDispatchPlan(query, module, intent, projects, memoryHits);
+    const totalCalls = targets.reduce((sum, t) => sum + t.tools.length, 0);
+    // 5. Aggregation hint
+    let aggregationHint = "";
+    if (targets.length > 1) {
+        if (intent === "debug") {
+            aggregationHint = "Setelah eksekusi semua, bandingkan: apakah bug di FE (view/JS) atau BE (API/logic)? Cross-reference error message.";
+        }
+        else if (intent === "feature") {
+            aggregationHint = "Setelah eksekusi, pastikan FE dan BE konsisten. Cek apakah perlu endpoint baru di BE.";
+        }
+        else if (intent === "trace") {
+            aggregationHint = "Trace full flow: Blade → JS → Controller FE → Utility::HttpRequest → BE Controller → Service → Model.";
+        }
+        else {
+            aggregationHint = "Gabungkan hasil dari semua agent, highlight perbedaan atau konflik.";
+        }
+    }
+    else {
+        aggregationHint = "Single agent — langsung eksekusi.";
+    }
+    return {
+        query,
+        detected_module: module,
+        detected_intent: intent,
+        memory_hits: memoryHits,
+        targets,
+        aggregation_hint: aggregationHint,
+        total_calls: totalCalls,
+    };
+}

package/dist/tools/check-energy.js

@@ -0,0 +1,49 @@
+/**
+ * Check apakah saat ini di luar jam kerja developer.
+ * Jika ya, return warning supaya agent tanya kondisi dulu.
+ *
+ * Jam kerja: Senin-Jumat 08:00-17:00 WIB (UTC+7)
+ * Sabtu-Minggu: opsional (tidak trigger warning)
+ */
+export function checkEnergy() {
+    // Use UTC+7 for WIB
+    const now = new Date();
+    const wibOffset = 7 * 60; // minutes
+    const utcMinutes = now.getUTCHours() * 60 + now.getUTCMinutes();
+    const wibMinutes = utcMinutes + wibOffset;
+    const wibHour = Math.floor((wibMinutes % 1440) / 60);
+    const wibDay = now.getUTCDay(); // 0=Sun, 6=Sat
+    // Adjust day if WIB offset pushes past midnight
+    const adjustedDay = wibMinutes >= 1440 ? (wibDay + 1) % 7 : wibDay;
+    const isWeekday = adjustedDay >= 1 && adjustedDay <= 5;
+    const isWorkHours = wibHour >= 8 && wibHour < 17;
+    const dayNames = [
+        "Minggu", "Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu",
+    ];
+    const result = {
+        current_time_wib: `${String(wibHour).padStart(2, "0")}:${String(wibMinutes % 60).padStart(2, "0")} WIB`,
+        day: dayNames[adjustedDay],
+        is_work_hours: isWorkHours,
+        is_weekday: isWeekday,
+        warning: null,
+        suggestion: null,
+    };
+    if (isWeekday && !isWorkHours) {
+        if (wibHour >= 17) {
+            result.warning = `Sekarang ${result.current_time_wib} — sudah lewat jam kerja (17:00).`;
+            result.suggestion =
+                "WAJIB tanyakan kondisi developer sebelum mulai task: 'Sudah lewat jam kerja, mau lanjut atau istirahat dulu?'";
+        }
+        else if (wibHour < 8) {
+            result.warning = `Sekarang ${result.current_time_wib} — belum jam kerja (08:00).`;
+            result.suggestion =
+                "Tanyakan apakah developer sengaja kerja pagi atau lupa waktu.";
+        }
+    }
+    else if (!isWeekday) {
+        result.warning = `Hari ${result.day} — weekend/opsional.`;
+        result.suggestion =
+            "Weekend opsional. Jangan push task berat kecuali developer yang minta.";
+    }
+    return result;
+}

package/dist/tools/cross-search.js

@@ -0,0 +1,171 @@
+/**
+ * Cross-Search — Cari informasi di SEMUA project sekaligus.
+ *
+ * Orchestrator langsung baca file dari semua project (tahu path dari registry).
+ * Tidak perlu dispatch ke agent lain — akses langsung.
+ *
+ * Search targets: MISTAKES.md, CURRENT_STATE.md, AUDIT_LOG.md, routes, symbols
+ */
+import { readFile, readdir } from "fs/promises";
+import { join, extname } from "path";
+import { existsSync } from "fs";
+async function loadRegistry(claudeHome) {
+    try {
+        const raw = await readFile(join(claudeHome, "project-registry.json"), "utf8");
+        const reg = JSON.parse(raw);
+        return reg.projects || {};
+    }
+    catch {
+        return {};
+    }
+}
+function scoreMatch(line, keywords) {
+    const lower = line.toLowerCase();
+    let score = 0;
+    for (const kw of keywords) {
+        if (kw.length < 3)
+            continue;
+        if (lower.includes(kw))
+            score += 1;
+    }
+    return score;
+}
+async function searchInFile(filePath, keywords, source, maxResults = 5) {
+    if (!existsSync(filePath))
+        return [];
+    try {
+        const content = await readFile(filePath, "utf8");
+        const lines = content.split("\n");
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line || line.startsWith("---") || line === "#")
+                continue;
+            const score = scoreMatch(line, keywords);
+            if (score > 0) {
+                matches.push({
+                    match: {
+                        source,
+                        file: filePath,
+                        line_preview: line.substring(0, 200),
+                        relevance: score >= 2 ? "high" : score === 1 ? "medium" : "low",
+                    },
+                    score,
+                });
+            }
+        }
+        // Sort by score desc, take top N
+        matches.sort((a, b) => b.score - a.score);
+        return matches.slice(0, maxResults).map((m) => m.match);
+    }
+    catch {
+        return [];
+    }
+}
+async function searchCodeFiles(projectPath, keywords, extensions = [".php", ".blade.php", ".js"], maxResults = 5) {
+    const matches = [];
+    const searchDirs = ["app", "routes", "resources"];
+    for (const dir of searchDirs) {
+        const dirPath = join(projectPath, dir);
+        if (!existsSync(dirPath))
+            continue;
+        try {
+            await scanDir(dirPath, keywords, extensions, matches, 3); // max depth 3
+        }
+        catch { }
+    }
+    matches.sort((a, b) => b.score - a.score);
+    return matches.slice(0, maxResults).map((m) => m.match);
+}
+async function scanDir(dirPath, keywords, extensions, results, maxDepth, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return;
+    if (results.length >= 20)
+        return; // cap total scanned
+    const ignore = ["vendor", "node_modules", ".git", "storage", "bootstrap", "public", "dist"];
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (ignore.includes(entry.name))
+                continue;
+            const fullPath = join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                await scanDir(fullPath, keywords, extensions, results, maxDepth, currentDepth + 1);
+            }
+            else if (entry.isFile()) {
+                const ext = extname(entry.name);
+                const isBladePhp = entry.name.endsWith(".blade.php");
+                if (!extensions.includes(ext) && !isBladePhp)
+                    continue;
+                // Only check filename match for speed
+                const nameLower = entry.name.toLowerCase();
+                const nameScore = scoreMatch(nameLower, keywords);
+                if (nameScore > 0) {
+                    results.push({
+                        match: {
+                            source: "code",
+                            file: fullPath,
+                            line_preview: `File: ${entry.name} (name matches keyword)`,
+                            relevance: nameScore >= 2 ? "high" : "medium",
+                        },
+                        score: nameScore + 1, // bonus for filename match
+                    });
+                }
+            }
+        }
+    }
+    catch { }
+}
+export async function crossSearch(claudeHome, args) {
+    const { query, scope, include_code } = args;
+    const keywords = query
+        .toLowerCase()
+        .split(/[\s,;.]+/)
+        .filter((w) => w.length > 2);
+    // Load projects from registry
+    const projects = await loadRegistry(claudeHome);
+    const projectEntries = Object.entries(projects).filter(([slug, proj]) => {
+        if (scope)
+            return slug === scope || proj.group?.toLowerCase() === scope.toLowerCase();
+        return proj.status === "active";
+    });
+    const results = [];
+    let totalMatches = 0;
+    for (const [slug, proj] of projectEntries) {
+        const projectPath = proj.path?.replace(/\\/g, "/") || "";
+        const docsPath = join(claudeHome, "project-docs", slug);
+        const projectMatches = [];
+        // Search MISTAKES.md
+        const mistakesPath = join(docsPath, "MISTAKES.md");
+        const mistakeMatches = await searchInFile(mistakesPath, keywords, "mistakes");
+        projectMatches.push(...mistakeMatches);
+        // Search CURRENT_STATE.md
+        const statePath = join(docsPath, "CURRENT_STATE.md");
+        const stateMatches = await searchInFile(statePath, keywords, "current_state");
+        projectMatches.push(...stateMatches);
+        // Search AUDIT_LOG.md
+        const auditPath = join(docsPath, "AUDIT_LOG.md");
+        const auditMatches = await searchInFile(auditPath, keywords, "audit_log");
+        projectMatches.push(...auditMatches);
+        // Search code files (optional, slower)
+        if (include_code && projectPath && existsSync(projectPath)) {
+            const codeMatches = await searchCodeFiles(projectPath, keywords);
+            projectMatches.push(...codeMatches);
+        }
+        if (projectMatches.length > 0) {
+            results.push({
+                project: slug,
+                matches: projectMatches,
+            });
+            totalMatches += projectMatches.length;
+        }
+    }
+    // Sort projects by match count desc
+    results.sort((a, b) => b.matches.length - a.matches.length);
+    return {
+        query,
+        results,
+        total_matches: totalMatches,
+        projects_searched: projectEntries.length,
+    };
+}

package/dist/tools/get-focus.js

@@ -0,0 +1,7 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+export async function getCurrentFocus(claudeHome) {
+    const path = join(claudeHome, "current-focus.json");
+    const raw = await readFile(path, "utf-8");
+    return JSON.parse(raw);
+}

package/dist/tools/get-identity.js

@@ -0,0 +1,7 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+export async function getIdentity(claudeHome) {
+    const path = join(claudeHome, "agent-identity.json");
+    const raw = await readFile(path, "utf-8");
+    return JSON.parse(raw);
+}

package/dist/tools/get-project-status.js

@@ -0,0 +1,35 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+export async function getProjectStatus(claudeHome, slug) {
+    if (!slug)
+        throw new Error("slug is required");
+    const path = join(claudeHome, "project-docs", slug, "CURRENT_STATE.md");
+    const content = await readFile(path, "utf-8");
+    const activeSection = extractSection(content, "Task Aktif");
+    const completedSection = extractSection(content, "Terakhir Selesai");
+    const blockersSection = extractSection(content, "Blockers");
+    return {
+        slug,
+        file: path,
+        active_task: activeSection ? parseFirstTask(activeSection) : null,
+        recent_completed_preview: completedSection ? completedSection.slice(0, 1500) : null,
+        blockers: blockersSection ? blockersSection.slice(0, 500) : null,
+    };
+}
+function extractSection(content, heading) {
+    const regex = new RegExp(`##\\s+${heading}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`);
+    const match = content.match(regex);
+    return match ? match[1].trim() : null;
+}
+function parseFirstTask(section) {
+    const taskMatch = section.match(/###\s+(\S+)\s+(.*?)$/m);
+    if (!taskMatch) {
+        const trimmed = section.slice(0, 600);
+        return { raw_preview: trimmed, empty: /\(kosong\)/i.test(trimmed) };
+    }
+    return {
+        id: taskMatch[1],
+        title: taskMatch[2],
+        preview: section.slice(0, 800),
+    };
+}