@agilsee/mcp-orchestrator 0.5.0

package/dist/tools/list-projects.js

@@ -0,0 +1,21 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+export async function listProjects(claudeHome) {
+    const path = join(claudeHome, "project-registry.json");
+    const raw = await readFile(path, "utf-8");
+    const registry = JSON.parse(raw);
+    const projects = Object.entries(registry.projects ?? {}).map(([slug, info]) => ({
+        slug,
+        name: info.name,
+        stack_profile: info.stack_profile,
+        stack: info.stack,
+        status: info.status,
+        group: info.group,
+        path: info.path,
+    }));
+    return {
+        count: projects.length,
+        projects,
+        groups: registry.groups,
+    };
+}

package/dist/tools/list-recent-tasks.js

@@ -0,0 +1,59 @@
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+export async function listRecentTasks(claudeHome, slug, limit) {
+    const docsRoot = join(claudeHome, "project-docs");
+    let slugs;
+    if (slug) {
+        slugs = [slug];
+    }
+    else {
+        const entries = await readdir(docsRoot, { withFileTypes: true });
+        slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    const allEntries = [];
+    for (const s of slugs) {
+        try {
+            const path = join(docsRoot, s, "AUDIT_LOG.md");
+            const content = await readFile(path, "utf-8");
+            allEntries.push(...parseAuditLog(content, s));
+        }
+        catch {
+            // skip missing files
+        }
+    }
+    allEntries.sort((a, b) => b.date.localeCompare(a.date));
+    return {
+        query: { slug: slug ?? "all", limit },
+        total_found: allEntries.length,
+        entries: allEntries.slice(0, limit),
+    };
+}
+function parseAuditLog(content, slug) {
+    const entries = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+        if (!line.startsWith("|"))
+            continue;
+        if (line.includes("---"))
+            continue;
+        if (/\|\s*Date\s*\|/i.test(line))
+            continue;
+        const cols = line
+            .split("|")
+            .map((c) => c.trim())
+            .filter((c, i, arr) => !(i === 0 && c === "") && !(i === arr.length - 1 && c === ""));
+        if (cols.length < 2)
+            continue;
+        if (!/^\d{4}-\d{2}-\d{2}/.test(cols[0]))
+            continue;
+        entries.push({
+            project: slug,
+            date: cols[0] ?? "",
+            action: cols[1] ?? "",
+            files: cols[2] ?? "",
+            tokens: cols[3] ?? "",
+            result: cols[4] ?? "",
+        });
+    }
+    return entries;
+}

package/dist/tools/log-insight.js

@@ -0,0 +1,43 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+export async function logInsight(claudeHome, args) {
+    const path = join(claudeHome, "project-docs", "INSIGHTS.md");
+    let content;
+    try {
+        content = await readFile(path, "utf-8");
+    }
+    catch {
+        content = [
+            "# Cross-Project Insights",
+            "",
+            "> Pattern, feedback, dan gotcha yang berlaku lintas project.",
+            "> Auto-updated oleh orchestrator.",
+            "",
+        ].join("\n");
+    }
+    const today = new Date().toISOString().slice(0, 10);
+    const projectList = args.projects.join(", ");
+    const typeLabel = {
+        cross_project_pattern: "Pattern",
+        feedback: "Feedback",
+        workflow: "Workflow",
+        gotcha: "Gotcha",
+    }[args.type];
+    const entry = [
+        `## [${today}] [${typeLabel}] ${args.title}`,
+        `- **Projects**: ${projectList}`,
+        `- **Detail**: ${args.detail}`,
+        args.source ? `- **Source**: ${args.source}` : null,
+        "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    content = content.trimEnd() + "\n\n" + entry + "\n";
+    await writeFile(path, content, "utf-8");
+    return {
+        file: path,
+        type: args.type,
+        title: args.title,
+        message: `Insight logged: [${typeLabel}] ${args.title}`,
+    };
+}

package/dist/tools/qcc-create.js

@@ -0,0 +1,82 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+export async function qccCreate(claudeHome, args) {
+    const docsPath = join(claudeHome, "project-docs", args.slug);
+    const qccPath = join(docsPath, "QCC_CYCLES.md");
+    // Ensure directory exists
+    await mkdir(docsPath, { recursive: true });
+    let content;
+    try {
+        content = await readFile(qccPath, "utf-8");
+    }
+    catch {
+        content = "# QCC Cycles\n\n> Quality Control Circle — 8 Langkah Problem Solving\n";
+    }
+    // Auto-increment QCC ID
+    const idMatches = content.match(/\[QCC-(\d+)\]/g) ?? [];
+    const maxId = idMatches.reduce((max, m) => {
+        const num = parseInt(m.match(/\d+/)[0], 10);
+        return num > max ? num : max;
+    }, 0);
+    const newId = `QCC-${String(maxId + 1).padStart(3, "0")}`;
+    const today = new Date().toISOString().slice(0, 10);
+    const cycleBlock = [
+        "",
+        "---",
+        "",
+        `## [${newId}] Tema: ${args.theme}`,
+        `- **Status**: active`,
+        `- **Created**: ${today}`,
+        `- **Focus Target**: ${args.focus_target}`,
+        "",
+        `### Step 2: Kondisi Saat Ini`,
+        "(belum diisi)",
+        "",
+        `### Step 3: Target SMART`,
+        "- **S (Specific/Masalah)**: —",
+        "- **M (Measurable/Target)**: —",
+        "- **A (Achievable/Percepat)**: —",
+        "- **R (Relevant/Alasan)**: —",
+        "- **T (Time-bound/Waktu)**: —",
+        "",
+        `### Step 4: Fishbone (Sebab-Akibat)`,
+        "```mermaid",
+        "graph LR",
+        `  ROOT["${args.theme}"]`,
+        `  ROOT --- MAN["Man"]`,
+        `  ROOT --- MACHINE["Machine"]`,
+        `  ROOT --- METHOD["Method"]`,
+        `  ROOT --- MATERIAL["Material"]`,
+        `  ROOT --- ENV["Environment"]`,
+        "```",
+        "",
+        `### Step 5: Rencana Penanggulangan`,
+        "| No | Sebab | Tindakan | PIC | Target |",
+        "|----|-------|----------|-----|--------|",
+        "",
+        `### Step 6: Pelaksanaan`,
+        "| No | Tindakan | Status | Tanggal | Catatan |",
+        "|----|----------|--------|---------|---------|",
+        "",
+        `### Step 7: Evaluasi`,
+        "- **Before**: —",
+        "- **After**: —",
+        "- **Target tercapai?**: —",
+        "",
+        `### Step 8: Validasi`,
+        "- **Validated by**: —",
+        "- **Date**: —",
+        "- **Standardisasi**: —",
+        "- **Horizontal deploy**: —",
+        "",
+    ].join("\n");
+    content = content.trimEnd() + "\n" + cycleBlock;
+    await writeFile(qccPath, content, "utf-8");
+    return {
+        qcc_id: newId,
+        file: qccPath,
+        theme: args.theme,
+        focus_target: args.focus_target,
+        message: `QCC cycle ${newId} created: "${args.theme}"`,
+    };
+}

package/dist/tools/qcc-status.js

@@ -0,0 +1,164 @@
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+export async function qccStatus(claudeHome, slug, qccId) {
+    const docsRoot = join(claudeHome, "project-docs");
+    // If slug specified, return for that project only
+    if (slug) {
+        return await getProjectQccStatus(docsRoot, slug, qccId);
+    }
+    // Otherwise scan all projects
+    let slugs;
+    try {
+        const entries = await readdir(docsRoot, { withFileTypes: true });
+        slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const s of slugs) {
+        try {
+            const result = await getProjectQccStatus(docsRoot, s);
+            if (result.total_cycles > 0) {
+                results.push(result);
+            }
+        }
+        catch { /* skip */ }
+    }
+    return results;
+}
+async function getProjectQccStatus(docsRoot, slug, filterQccId) {
+    const qccPath = join(docsRoot, slug, "QCC_CYCLES.md");
+    let content;
+    try {
+        content = await readFile(qccPath, "utf-8");
+    }
+    catch {
+        return { slug, total_cycles: 0, active: 0, completed: 0, cycles: [] };
+    }
+    // Parse cycles
+    const cycleBlocks = content.split(/(?=\n## \[QCC-)/);
+    const cycles = [];
+    for (const block of cycleBlocks) {
+        const headerMatch = block.match(/## \[(QCC-\d+)\] Tema: (.+)/);
+        if (!headerMatch)
+            continue;
+        const qccId = headerMatch[1];
+        const theme = headerMatch[2].trim();
+        if (filterQccId && qccId !== filterQccId)
+            continue;
+        const statusMatch = block.match(/\*\*Status\*\*: (\w+)/);
+        const createdMatch = block.match(/\*\*Created\*\*: ([\d-]+)/);
+        const focusMatch = block.match(/\*\*Focus Target\*\*: (.+)/);
+        const status = statusMatch ? statusMatch[1] : "unknown";
+        const created = createdMatch ? createdMatch[1] : "unknown";
+        const focusTarget = focusMatch ? focusMatch[1].trim() : "—";
+        // Check which steps are done
+        const stepsDone = [];
+        const stepsPending = [];
+        // Step 2: check if "(belum diisi)" is replaced
+        if (block.includes("### Step 2:")) {
+            const step2Section = extractSection(block, "### Step 2:", "### Step 3:");
+            if (!step2Section.includes("(belum diisi)") && step2Section.trim().length > 5) {
+                stepsDone.push(2);
+            }
+            else {
+                stepsPending.push(2);
+            }
+        }
+        // Step 3: check if SMART fields are filled
+        if (block.includes("### Step 3:")) {
+            const step3Section = extractSection(block, "### Step 3:", "### Step 4:");
+            const dashCount = (step3Section.match(/: —/g) ?? []).length;
+            if (dashCount === 0) {
+                stepsDone.push(3);
+            }
+            else {
+                stepsPending.push(3);
+            }
+        }
+        // Step 4: check if fishbone has items beyond template
+        if (block.includes("### Step 4:")) {
+            const step4Section = extractSection(block, "### Step 4:", "### Step 5:");
+            // Count node connections (more than 5 base connections = has items)
+            const connections = (step4Section.match(/---/g) ?? []).length;
+            if (connections > 5) {
+                stepsDone.push(4);
+            }
+            else {
+                stepsPending.push(4);
+            }
+        }
+        // Step 5: check if countermeasure table has data rows
+        if (block.includes("### Step 5:")) {
+            const step5Section = extractSection(block, "### Step 5:", "### Step 6:");
+            const dataRows = step5Section.split("\n").filter((l) => l.startsWith("|") && !l.includes("---") && !l.includes("No |"));
+            if (dataRows.length > 0) {
+                stepsDone.push(5);
+            }
+            else {
+                stepsPending.push(5);
+            }
+        }
+        // Step 6: check if execution table has data
+        if (block.includes("### Step 6:")) {
+            const step6Section = extractSection(block, "### Step 6:", "### Step 7:");
+            const dataRows = step6Section.split("\n").filter((l) => l.startsWith("|") && !l.includes("---") && !l.includes("No |"));
+            if (dataRows.length > 0) {
+                stepsDone.push(6);
+            }
+            else {
+                stepsPending.push(6);
+            }
+        }
+        // Step 7: check if evaluation is filled
+        if (block.includes("### Step 7:")) {
+            const step7Section = extractSection(block, "### Step 7:", "### Step 8:");
+            const dashCount = (step7Section.match(/: —/g) ?? []).length;
+            if (dashCount === 0) {
+                stepsDone.push(7);
+            }
+            else {
+                stepsPending.push(7);
+            }
+        }
+        // Step 8: check if validation is filled
+        if (block.includes("### Step 8:")) {
+            const step8Section = extractSection(block, "### Step 8:", null);
+            const dashCount = (step8Section.match(/: —/g) ?? []).length;
+            if (dashCount === 0) {
+                stepsDone.push(8);
+            }
+            else {
+                stepsPending.push(8);
+            }
+        }
+        // Current step = first pending
+        const currentStep = stepsPending.length > 0 ? stepsPending[0] : 8;
+        cycles.push({
+            qcc_id: qccId,
+            theme,
+            status,
+            created,
+            focus_target: focusTarget,
+            steps_done: stepsDone,
+            steps_pending: stepsPending,
+            current_step: currentStep,
+        });
+    }
+    return {
+        slug,
+        total_cycles: cycles.length,
+        active: cycles.filter((c) => c.status === "active").length,
+        completed: cycles.filter((c) => c.status === "completed").length,
+        cycles,
+    };
+}
+function extractSection(block, startHeader, endHeader) {
+    const startIdx = block.indexOf(startHeader);
+    if (startIdx === -1)
+        return "";
+    const afterHeader = startIdx + startHeader.length;
+    const endIdx = endHeader ? block.indexOf(endHeader, afterHeader) : block.length;
+    return endIdx === -1 ? block.slice(afterHeader) : block.slice(afterHeader, endIdx);
+}

package/dist/tools/qcc-update.js

@@ -0,0 +1,188 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+export async function qccUpdate(claudeHome, args) {
+    const qccPath = join(claudeHome, "project-docs", args.slug, "QCC_CYCLES.md");
+    let content;
+    try {
+        content = await readFile(qccPath, "utf-8");
+    }
+    catch {
+        throw new Error(`QCC_CYCLES.md not found for project ${args.slug}. Run qcc_create first.`);
+    }
+    // Find the cycle section
+    const cycleHeader = `## [${args.qcc_id}]`;
+    const cycleIdx = content.indexOf(cycleHeader);
+    if (cycleIdx === -1) {
+        throw new Error(`Cycle ${args.qcc_id} not found in QCC_CYCLES.md`);
+    }
+    // Find the end of this cycle (next ## [ or end of file)
+    const nextCycleMatch = content.slice(cycleIdx + cycleHeader.length).match(/\n## \[QCC-/);
+    const cycleEnd = nextCycleMatch
+        ? cycleIdx + cycleHeader.length + nextCycleMatch.index
+        : content.length;
+    let cycleContent = content.slice(cycleIdx, cycleEnd);
+    const { step } = args.data;
+    const stepHeaders = {
+        2: "### Step 2: Kondisi Saat Ini",
+        3: "### Step 3: Target SMART",
+        4: "### Step 4: Fishbone (Sebab-Akibat)",
+        5: "### Step 5: Rencana Penanggulangan",
+        6: "### Step 6: Pelaksanaan",
+        7: "### Step 7: Evaluasi",
+        8: "### Step 8: Validasi",
+    };
+    const currentHeader = stepHeaders[step];
+    const nextStep = step + 1;
+    const nextHeader = stepHeaders[nextStep] ?? null;
+    const headerIdx = cycleContent.indexOf(currentHeader);
+    if (headerIdx === -1) {
+        throw new Error(`Step ${step} header not found in cycle ${args.qcc_id}`);
+    }
+    const sectionStart = headerIdx + currentHeader.length;
+    const sectionEnd = nextHeader
+        ? cycleContent.indexOf(nextHeader)
+        : cycleContent.length;
+    if (sectionEnd === -1) {
+        throw new Error(`Cannot find boundary for step ${step}`);
+    }
+    let newSection;
+    switch (args.data.step) {
+        case 2: {
+            const lines = args.data.findings.map((f) => `- ${f}`);
+            newSection = "\n" + lines.join("\n") + "\n\n";
+            break;
+        }
+        case 3: {
+            const s = args.data.smart;
+            newSection = [
+                "",
+                `- **S (Specific/Masalah)**: ${s.specific}`,
+                `- **M (Measurable/Target)**: ${s.measurable}`,
+                `- **A (Achievable/Percepat)**: ${s.achievable}`,
+                `- **R (Relevant/Alasan)**: ${s.relevant}`,
+                `- **T (Time-bound/Waktu)**: ${s.timebound}`,
+                "",
+            ].join("\n");
+            break;
+        }
+        case 4: {
+            const { root_problem, causes } = args.data;
+            const mermaidLines = [
+                "```mermaid",
+                "graph LR",
+                `  ROOT["${root_problem}"]`,
+            ];
+            const catMap = {
+                man: "MAN",
+                machine: "MACHINE",
+                method: "METHOD",
+                material: "MATERIAL",
+                environment: "ENV",
+            };
+            const catLabel = {
+                man: "Man",
+                machine: "Machine",
+                method: "Method",
+                material: "Material",
+                environment: "Environment",
+            };
+            for (const cause of causes) {
+                const nodeId = catMap[cause.category] ?? cause.category.toUpperCase();
+                const label = catLabel[cause.category] ?? cause.category;
+                mermaidLines.push(`  ROOT --- ${nodeId}["${label}"]`);
+                cause.items.forEach((item, i) => {
+                    const itemId = `${nodeId}${i + 1}`;
+                    mermaidLines.push(`  ${nodeId} --- ${itemId}["${item}"]`);
+                });
+            }
+            mermaidLines.push("```");
+            newSection = "\n" + mermaidLines.join("\n") + "\n\n";
+            break;
+        }
+        case 5: {
+            const tableHeader = [
+                "| No | Sebab | Tindakan | PIC | Target |",
+                "|----|-------|----------|-----|--------|",
+            ];
+            const rows = args.data.countermeasures.map((cm, i) => `| ${i + 1} | ${cm.cause} | ${cm.action} | ${cm.pic} | ${cm.target_date} |`);
+            newSection = "\n" + [...tableHeader, ...rows].join("\n") + "\n\n";
+            break;
+        }
+        case 6: {
+            // For step 6, we UPDATE existing table rows or add new ones
+            const ex = args.data.execution;
+            const existingSection = cycleContent.slice(sectionStart, sectionEnd);
+            const tableLines = existingSection.split("\n").filter((l) => l.startsWith("|"));
+            if (tableLines.length < 2) {
+                // No table yet, create with header
+                newSection = [
+                    "",
+                    "| No | Tindakan | Status | Tanggal | Catatan |",
+                    "|----|----------|--------|---------|---------|",
+                    `| ${ex.no} | — | ${ex.status} | ${ex.date ?? "—"} | ${ex.notes ?? "—"} |`,
+                    "",
+                ].join("\n");
+            }
+            else {
+                // Find existing row or append
+                const headerRows = tableLines.slice(0, 2);
+                const dataRows = tableLines.slice(2);
+                let found = false;
+                const updatedRows = dataRows.map((row) => {
+                    const cols = row.split("|").map((c) => c.trim()).filter(Boolean);
+                    if (cols[0] === String(ex.no)) {
+                        found = true;
+                        return `| ${ex.no} | ${cols[1]} | ${ex.status} | ${ex.date ?? cols[3]} | ${ex.notes ?? cols[4]} |`;
+                    }
+                    return row;
+                });
+                if (!found) {
+                    updatedRows.push(`| ${ex.no} | — | ${ex.status} | ${ex.date ?? "—"} | ${ex.notes ?? "—"} |`);
+                }
+                newSection = "\n" + [...headerRows, ...updatedRows].join("\n") + "\n\n";
+            }
+            break;
+        }
+        case 7: {
+            const ev = args.data.evaluation;
+            newSection = [
+                "",
+                `- **Before**: ${ev.before}`,
+                `- **After**: ${ev.after}`,
+                `- **Target tercapai?**: ${ev.target_achieved ? "Ya" : "Belum"}`,
+                ev.notes ? `- **Notes**: ${ev.notes}` : null,
+                "",
+            ].filter(Boolean).join("\n");
+            break;
+        }
+        case 8: {
+            const v = args.data.validation;
+            const today = new Date().toISOString().slice(0, 10);
+            // Also update cycle status to completed
+            cycleContent = cycleContent.replace(/- \*\*Status\*\*: active/, "- **Status**: completed");
+            newSection = [
+                "",
+                `- **Validated by**: ${v.validated_by}`,
+                `- **Date**: ${v.date ?? today}`,
+                `- **Standardisasi**: ${v.standardization ?? "—"}`,
+                `- **Horizontal deploy**: ${v.horizontal_deploy ?? "—"}`,
+                "",
+            ].join("\n");
+            break;
+        }
+    }
+    // Replace section content
+    cycleContent =
+        cycleContent.slice(0, sectionStart) +
+            newSection +
+            cycleContent.slice(sectionEnd);
+    // Rebuild full content
+    content = content.slice(0, cycleIdx) + cycleContent + content.slice(cycleEnd);
+    await writeFile(qccPath, content, "utf-8");
+    return {
+        qcc_id: args.qcc_id,
+        step,
+        file: qccPath,
+        message: `Step ${step} updated for ${args.qcc_id}`,
+    };
+}