@agilsee/mcp-orchestrator 0.5.0

package/dist/tools/smart-bootstrap.js

@@ -0,0 +1,255 @@
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+export async function smartBootstrap(claudeHome) {
+    const docsRoot = join(claudeHome, "project-docs");
+    // 1. Identity
+    let identity = null;
+    try {
+        const raw = await readFile(join(claudeHome, "agent-identity.json"), "utf-8");
+        const id = JSON.parse(raw);
+        identity = { name: id.name ?? "Agent", author: id.author ?? "—", spec: id.specialization ?? "—" };
+    }
+    catch { /* skip */ }
+    // 2. Focus
+    let focus = null;
+    let activeProjects = [];
+    try {
+        const raw = await readFile(join(claudeHome, "current-focus.json"), "utf-8");
+        const f = JSON.parse(raw);
+        const mode = f.mode ?? "general";
+        const profile = f.profiles?.[f.active_profile ?? ""] ?? {};
+        const label = profile.label ?? f.active_profile ?? "general";
+        activeProjects = profile.active_projects?.map((p) => p.slug ?? p) ?? [];
+        focus = { mode, label, projects: activeProjects };
+    }
+    catch { /* skip */ }
+    // 3. Energy check
+    const now = new Date();
+    const hour = now.getHours();
+    const day = now.getDay(); // 0=Sun, 6=Sat
+    const isWorkHour = day >= 1 && day <= 5 && hour >= 8 && hour < 17;
+    const energy = isWorkHour
+        ? { ok: true }
+        : { ok: false, warning: `Di luar jam kerja (${now.toLocaleTimeString("id-ID")}). Pertimbangkan istirahat.` };
+    // 4. Determine which projects to scan
+    let slugsToScan = activeProjects;
+    if (slugsToScan.length === 0) {
+        try {
+            const entries = await readdir(docsRoot, { withFileTypes: true });
+            slugsToScan = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            slugsToScan = [];
+        }
+    }
+    // 5. Scan each project (parallel-ish)
+    const projectSummaries = [];
+    const qccActive = [];
+    const recentMistakes = [];
+    for (const slug of slugsToScan) {
+        const slugPath = join(docsRoot, slug);
+        // CURRENT_STATE.md
+        let activeTasks = 0;
+        let recentCompleted = 0;
+        const blockers = [];
+        try {
+            const state = await readFile(join(slugPath, "CURRENT_STATE.md"), "utf-8");
+            // Count active tasks
+            const activeSection = extractSection(state, "## Task Aktif", "## Terakhir Selesai");
+            const taskMatches = activeSection.match(/^### /gm);
+            activeTasks = taskMatches?.length ?? 0;
+            // Count recent completed
+            const completedSection = extractSection(state, "## Terakhir Selesai", "## Blockers");
+            const compMatches = completedSection.match(/^### /gm);
+            recentCompleted = compMatches?.length ?? 0;
+            // Blockers
+            const blockerSection = extractSection(state, "## Blockers", null);
+            if (blockerSection && !blockerSection.includes("(tidak ada)")) {
+                const lines = blockerSection.split("\n").filter((l) => l.startsWith("- "));
+                blockers.push(...lines.map((l) => l.replace(/^- /, "").trim()).slice(0, 3));
+            }
+        }
+        catch { /* no state file */ }
+        // AUDIT_LOG.md — last entry
+        let lastAudit = null;
+        try {
+            const audit = await readFile(join(slugPath, "AUDIT_LOG.md"), "utf-8");
+            const lines = audit.split("\n").filter((l) => l.startsWith("|") && !l.includes("---") && !/\|\s*(Date|Action)\s*\|/.test(l));
+            if (lines.length > 0) {
+                lastAudit = lines[lines.length - 1].replace(/^\||\|$/g, "").trim();
+            }
+        }
+        catch { /* skip */ }
+        // MISTAKES.md — recent (top 3)
+        try {
+            const mistakes = await readFile(join(slugPath, "MISTAKES.md"), "utf-8");
+            const sections = mistakes.split(/(?=^## \[)/m).filter((s) => s.startsWith("## ["));
+            const recent = sections.slice(-3).reverse();
+            for (const sec of recent) {
+                const titleMatch = sec.match(/^## \[[\d-]+\]\s*—\s*(.+)$/m);
+                if (titleMatch) {
+                    recentMistakes.push(`[${slug}] ${titleMatch[1].trim()}`);
+                }
+            }
+        }
+        catch { /* skip */ }
+        // QCC_CYCLES.md — active cycles
+        try {
+            const qcc = await readFile(join(slugPath, "QCC_CYCLES.md"), "utf-8");
+            const cycles = qcc.split(/(?=\n## \[QCC-)/).filter((b) => b.includes("[QCC-"));
+            for (const block of cycles) {
+                if (!block.includes("**Status**: active"))
+                    continue;
+                const hMatch = block.match(/\[(QCC-\d+)\] Tema: (.+)/);
+                if (!hMatch)
+                    continue;
+                const createdMatch = block.match(/\*\*Created\*\*: ([\d-]+)/);
+                const created = createdMatch ? new Date(createdMatch[1]) : now;
+                const daysOld = Math.floor((now.getTime() - created.getTime()) / 86400000);
+                // Determine current step
+                let currentStep = 2;
+                for (let s = 8; s >= 2; s--) {
+                    const header = `### Step ${s}:`;
+                    const idx = block.indexOf(header);
+                    if (idx === -1)
+                        continue;
+                    const section = block.slice(idx, block.indexOf("### Step", idx + header.length)).concat(block.slice(idx));
+                    const isEmpty = section.includes("(belum diisi)") ||
+                        section.includes(": —") ||
+                        (s >= 5 && s <= 6 && !section.match(/\|\s*\d+\s*\|/));
+                    if (!isEmpty) {
+                        currentStep = Math.min(s + 1, 8);
+                        break;
+                    }
+                }
+                qccActive.push({
+                    slug,
+                    qcc_id: hMatch[1],
+                    theme: hMatch[2].trim(),
+                    current_step: currentStep,
+                    days_stuck: daysOld,
+                });
+            }
+        }
+        catch { /* skip */ }
+        projectSummaries.push({
+            slug,
+            active_tasks: activeTasks,
+            recent_completed: recentCompleted,
+            blockers,
+            last_audit_entry: lastAudit,
+        });
+    }
+    // 6. Determine suggested action
+    const suggested = determineSuggestion(projectSummaries, qccActive, recentMistakes);
+    // 7. Determine response mode (Caveman compression)
+    const responseMode = determineResponseMode(energy, qccActive, suggested);
+    // 8. Build greeting
+    const name = identity?.name ?? "Agent Fullstack PHP";
+    const focusLabel = focus?.label ?? "General";
+    const projectList = focus?.projects.join(" + ") ?? "—";
+    const greeting = `${name} | Fokus: **${focusLabel}** (${projectList}) | ${projectSummaries.reduce((a, p) => a + p.active_tasks, 0)} task aktif`;
+    return {
+        greeting,
+        identity,
+        focus,
+        energy,
+        response_mode: responseMode,
+        project_summaries: projectSummaries,
+        qcc_active: qccActive,
+        recent_mistakes: recentMistakes.slice(0, 5),
+        suggested_action: suggested,
+        suggested_skill: suggested.skill ?? null,
+    };
+}
+// --- Response Mode (Caveman-style compression) ---
+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: [],
+};
+function determineResponseMode(energy, qccActive, suggested) {
+    // QCC report aktif dan suggested action = qcc → off (butuh kalimat formal)
+    if (qccActive.length > 0 && suggested.tool === "qcc_update") {
+        return { intensity: "off", rules: RESPONSE_RULES.off };
+    }
+    // Di luar jam kerja → lite (santai, lebih jelas)
+    if (!energy.ok) {
+        return { intensity: "lite", rules: RESPONSE_RULES.lite };
+    }
+    // Default jam kerja → full
+    return { intensity: "full", rules: RESPONSE_RULES.full };
+}
+function determineSuggestion(projects, qcc, mistakes) {
+    // Priority 1: Blockers
+    const allBlockers = projects.flatMap((p) => p.blockers);
+    if (allBlockers.length > 0) {
+        return {
+            priority: "high",
+            message: `Ada ${allBlockers.length} blocker: "${allBlockers[0]}". Selesaikan ini dulu.`,
+            skill: "/debug",
+        };
+    }
+    // Priority 2: QCC stuck >3 days
+    const stuckQcc = qcc.filter((q) => q.days_stuck >= 3);
+    if (stuckQcc.length > 0) {
+        const q = stuckQcc[0];
+        const stepNames = {
+            2: "Kondisi", 3: "Target SMART", 4: "Fishbone",
+            5: "Rencana", 6: "Pelaksanaan", 7: "Evaluasi", 8: "Validasi",
+        };
+        return {
+            priority: "high",
+            message: `${q.qcc_id} "${q.theme}" stuck di Step ${q.current_step} (${stepNames[q.current_step] ?? "?"}) sudah ${q.days_stuck} hari. Lanjutkan.`,
+            tool: "qcc_update",
+        };
+    }
+    // Priority 3: Active tasks exist
+    const totalActive = projects.reduce((a, p) => a + p.active_tasks, 0);
+    if (totalActive > 0) {
+        const proj = projects.find((p) => p.active_tasks > 0);
+        return {
+            priority: "medium",
+            message: `${totalActive} task aktif di ${proj?.slug ?? "project"}. Lanjutkan task yang in-progress.`,
+            skill: "/execute-plan",
+        };
+    }
+    // Priority 4: Recent mistakes suggest debugging opportunity
+    if (mistakes.length >= 3) {
+        return {
+            priority: "medium",
+            message: `${mistakes.length} bugs tercatat. Pertimbangkan buat QCC cycle untuk address secara sistematis.`,
+            tool: "qcc_create",
+        };
+    }
+    // Priority 5: Nothing urgent
+    return {
+        priority: "low",
+        message: "Tidak ada yang urgent. Siap terima task baru.",
+    };
+}
+function extractSection(content, startHeader, endHeader) {
+    const startIdx = content.indexOf(startHeader);
+    if (startIdx === -1)
+        return "";
+    const afterHeader = startIdx + startHeader.length;
+    if (!endHeader)
+        return content.slice(afterHeader);
+    const endIdx = content.indexOf(endHeader, afterHeader);
+    return endIdx === -1 ? content.slice(afterHeader) : content.slice(afterHeader, endIdx);
+}

package/dist/tools/summarize-session.js

@@ -0,0 +1,161 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+export async function summarizeLastSession(claudeHome, limit = 5) {
+    const focus = await readJson(join(claudeHome, "current-focus.json"));
+    const mode = focus?.mode ?? "general";
+    const label = focus?.label ?? focus?.active_profile ?? null;
+    const activeProjects = focus?.active_projects ?? [];
+    const perProject = [];
+    for (const slug of activeProjects) {
+        perProject.push(await summarizeProject(claudeHome, slug, limit));
+    }
+    const tldr = buildTldr(label, mode, perProject);
+    return {
+        focus_label: label,
+        focus_mode: mode,
+        active_projects: activeProjects,
+        per_project: perProject,
+        tldr,
+        generated_at: new Date().toISOString(),
+    };
+}
+async function summarizeProject(claudeHome, slug, limit) {
+    const docsDir = join(claudeHome, "project-docs", slug);
+    const recentTasks = await parseAuditLog(join(docsDir, "AUDIT_LOG.md"), limit);
+    const openMistakes = await parseMistakes(join(docsDir, "MISTAKES.md"), limit);
+    const activeTasks = await parseCurrentStateActive(join(docsDir, "CURRENT_STATE.md"));
+    const lastActivity = recentTasks[0]?.date ?? null;
+    return {
+        slug,
+        recent_tasks: recentTasks,
+        open_mistakes: openMistakes,
+        active_tasks: activeTasks,
+        last_activity: lastActivity,
+    };
+}
+async function parseAuditLog(path, limit) {
+    const content = await safeRead(path);
+    if (!content)
+        return [];
+    const rows = [];
+    for (const line of content.split("\n")) {
+        if (!line.startsWith("|") || line.includes("---"))
+            continue;
+        if (/\|\s*Date\s*\|/i.test(line))
+            continue;
+        const cols = line
+            .split("|")
+            .map((c) => c.trim())
+            .filter(Boolean);
+        if (cols.length < 2 || !/^\d{4}-\d{2}-\d{2}/.test(cols[0]))
+            continue;
+        rows.push({
+            date: cols[0],
+            action: cols[1] ?? "",
+            result: cols[cols.length - 1] ?? "",
+        });
+    }
+    return rows.sort((a, b) => b.date.localeCompare(a.date)).slice(0, limit);
+}
+async function parseMistakes(path, limit) {
+    const content = await safeRead(path);
+    if (!content)
+        return [];
+    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 fixMatch = section.match(/\*\*Fix\*\*:\s*(.+)/);
+        const fixStatus = fixMatch?.[1]?.trim() ?? "";
+        const fixed = /sudah fix|fixed|done|resolved|selesai/i.test(fixStatus) &&
+            !/belum|not yet|pending|workaround/i.test(fixStatus);
+        if (fixed)
+            continue;
+        results.push({
+            date: titleMatch[1],
+            title: titleMatch[2].trim(),
+            file: fileMatch?.[1]?.trim() ?? "",
+            fix_status: fixStatus || "unknown",
+        });
+    }
+    return results.sort((a, b) => b.date.localeCompare(a.date)).slice(0, limit);
+}
+async function parseCurrentStateActive(path) {
+    const content = await safeRead(path);
+    if (!content)
+        return [];
+    const active = [];
+    let inActive = false;
+    for (const line of content.split("\n")) {
+        if (/^##\s+.*(active|sedang|in[- ]progress)/i.test(line)) {
+            inActive = true;
+            continue;
+        }
+        if (/^##\s/.test(line)) {
+            inActive = false;
+            continue;
+        }
+        if (!inActive)
+            continue;
+        const item = line.match(/^\s*[-*]\s+(.+)/);
+        if (item)
+            active.push(item[1].trim());
+    }
+    return active.slice(0, 10);
+}
+function buildTldr(label, mode, perProject) {
+    const tldr = [];
+    if (label)
+        tldr.push(`Focus: ${label} (mode: ${mode})`);
+    else
+        tldr.push(`Mode: ${mode} (no active focus label)`);
+    if (perProject.length === 0) {
+        tldr.push("Tidak ada active project di focus.");
+        return tldr;
+    }
+    for (const p of perProject) {
+        const parts = [`[${p.slug}]`];
+        if (p.last_activity) {
+            parts.push(`last activity ${p.last_activity}`);
+            const latest = p.recent_tasks[0];
+            if (latest)
+                parts.push(`— "${truncate(latest.action, 60)}"`);
+        }
+        else {
+            parts.push("belum ada audit log");
+        }
+        tldr.push(parts.join(" "));
+        if (p.open_mistakes.length > 0) {
+            tldr.push(`  ⚠ ${p.open_mistakes.length} bug belum fix — terbaru: "${truncate(p.open_mistakes[0].title, 55)}"`);
+        }
+        if (p.active_tasks.length > 0) {
+            tldr.push(`  → active task: "${truncate(p.active_tasks[0], 60)}"`);
+        }
+    }
+    return tldr;
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+async function readJson(path) {
+    const content = await safeRead(path);
+    if (!content)
+        return null;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function safeRead(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/switch-focus.js

@@ -0,0 +1,40 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+export async function switchFocus(claudeHome, profileKey) {
+    const path = join(claudeHome, "current-focus.json");
+    const raw = await readFile(path, "utf-8");
+    const focus = JSON.parse(raw);
+    const profiles = focus.available_focus_profiles ?? {};
+    if (profileKey === "general") {
+        focus.mode = "general";
+        focus.focus_label = "General (semua project terbuka)";
+        focus.active_projects = [];
+        focus.last_updated = new Date().toISOString().slice(0, 10);
+        await writeFile(path, JSON.stringify(focus, null, 2), "utf-8");
+        return {
+            file: path,
+            switched_to: "general",
+            message: "Focus switched to General mode",
+        };
+    }
+    if (!profiles[profileKey]) {
+        return {
+            error: true,
+            message: `Profile '${profileKey}' tidak ditemukan.`,
+            available: Object.keys(profiles),
+        };
+    }
+    const profile = profiles[profileKey];
+    focus.mode = "focused";
+    focus.focus_label = profile.label;
+    focus.active_projects = profile.active_projects;
+    focus.last_updated = new Date().toISOString().slice(0, 10);
+    await writeFile(path, JSON.stringify(focus, null, 2), "utf-8");
+    return {
+        file: path,
+        switched_to: profileKey,
+        label: profile.label,
+        active_projects: profile.active_projects,
+        message: `Focus switched to: ${profile.label}`,
+    };
+}