coding-agent-harness 1.0.7 → 1.1.0

package/dist/lib/dashboard-data.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Dashboard bundle aggregation stays behavior-first until dashboard domain types are modeled.
 import fs from "node:fs";
 import path from "node:path";
@@ -9,7 +8,7 @@ import { readCapabilityRegistry, validateCapabilities } from "./capability-regis
 import { resolveHarnessPaths } from "./harness-paths.mjs";
 import { legacyCompatMode, safeAdoptionCapability, } from "./harness-paths.mjs";
 import { buildStatusData } from "./status-builder.mjs";
-import { listTaskPlanPaths, parseTaskState, isActiveTaskState, } from "./task-scanner.mjs";
+import { parseTaskState, isActiveTaskState, createScannerTaskRepository, } from "./task-repository.mjs";
 import { writeDashboardDirectory, writeDashboardFile } from "./dashboard-writer.mjs";
 import { listPresetPackageLayers } from "./preset-registry.mjs";
 import { validateGovernanceTableBoundaries } from "./governance-table-boundary.mjs";
@@ -17,7 +16,7 @@ import { summarizeGitState } from "./git-status-summary.mjs";
 export function collectMarkdownDocuments(target, options = {}) {
     const docs = collectDashboardDocumentPaths(target, options);
     return docs.map((entry, index) => {
-        const file = typeof entry === "string" ? entry : entry.file;
+        const file = entry.file;
         const content = sanitizeText(readFileSafe(file));
         const source = prefixedPath(target, file);
         return {
@@ -76,17 +75,21 @@ function collectDashboardDocumentPaths(target, options = {}) {
             selected.add(file);
         }
     }
-    const tasksByPlanPath = new Map((options.tasks || []).map((task) => [
-        path.join(target.projectRoot, String(task.taskPlanPath || "").replace(/^TARGET:/, "")),
+    const tasks = options.tasks || createScannerTaskRepository(target).list();
+    const tasksByPlanPath = new Map(tasks.map((task) => [
+        targetAbsolutePath(target, String(task.taskPlanPath || "")),
         task,
     ]));
-    for (const taskPlanPath of options.taskPlanPaths || listTaskPlanPaths(target)) {
+    for (const listedTask of tasks) {
+        const taskPlanPath = targetAbsolutePath(target, String(listedTask.taskPlanPath || ""));
+        if (!taskPlanPath || !fs.existsSync(taskPlanPath))
+            continue;
         const taskDir = path.dirname(taskPlanPath);
         const progress = readFileSafe(path.join(taskDir, "progress.md"));
         const state = parseTaskState(progress);
         const active = isActiveTaskState(state);
-        const task = tasksByPlanPath.get(taskPlanPath);
-        const historicalClosed = !active && task?.closeoutStatus === "closed";
+        const taskRef = tasksByPlanPath.get(taskPlanPath);
+        const historicalClosed = !active && taskRef?.closeoutStatus === "closed";
         const documentNames = historicalClosed
             ? ["brief.md", "walkthrough.md"]
             : ["brief.md", "task_plan.md", "execution_strategy.md", visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, "progress.md", "review.md", "findings.md", "walkthrough.md"];
@@ -98,7 +101,7 @@ function collectDashboardDocumentPaths(target, options = {}) {
                     partial.set(file, {
                         partial: true,
                         partialReason: "historical-closed",
-                        taskId: task?.id || path.basename(taskDir),
+                        taskId: taskRef?.id || path.basename(taskDir),
                     });
                 }
             }
@@ -198,7 +201,7 @@ export function collectGraph(status, tables = { tables: [] }, target = null) {
     };
     for (const task of status.tasks) {
         addNode({ id: `task:${task.id}`, type: "task", label: task.title, state: task.state, completion: task.completion });
-        for (const phase of task.phases || []) {
+        for (const phase of dashboardTaskPhases(task)) {
             const phaseId = `phase:${task.id}:${phase.id}`;
             addNode({
                 id: phaseId,
@@ -216,12 +219,34 @@ export function collectGraph(status, tables = { tables: [] }, target = null) {
                 addEdge({ from: `phase:${task.id}:${dependency}`, to: phaseId, type: "depends_on" });
             }
         }
-        for (const handoff of task.handoffs || []) {
+        for (const handoff of dashboardTaskHandoffs(task)) {
             const handoffId = `handoff:${handoff.id}`;
             addNode({ id: handoffId, type: "handoff", label: handoff.summary, state: handoff.state });
             addEdge({ from: `task:${task.id}`, to: handoffId, type: "handoff" });
         }
     }
+    for (const module of Array.isArray(status.modules) ? status.modules : []) {
+        const key = String(module.key || "");
+        if (!key)
+            continue;
+        const moduleId = `module:${key}`;
+        const currentStep = String(module.currentStep || "");
+        const state = module.status || "planned";
+        addNode({
+            id: moduleId,
+            type: "module",
+            label: String(module.title || key),
+            state,
+            currentStep,
+            ...moduleDocumentPaths(target, key),
+        });
+        if (currentStep) {
+            const stepId = `step:${currentStep}`;
+            if (!seenNodes.has(stepId))
+                addNode({ id: stepId, type: "step", label: currentStep, state, module: key });
+            addEdge({ from: moduleId, to: stepId, type: "current_step" });
+        }
+    }
     for (const table of tables.tables || []) {
         if (table.kind === "module-registry") {
             for (const row of table.rows) {
@@ -234,7 +259,7 @@ export function collectGraph(status, tables = { tables: [] }, target = null) {
                 addNode({
                     id: moduleId,
                     type: "module",
-                    label: getCell(row.cells, ["Name", "Module", "模块名称", "模块"], key),
+                    label: getCell(row.cells, ["Title", "Name", "Module", "模块名称", "模块"], key),
                     state: status,
                     currentStep,
                     ...moduleDocumentPaths(target, key),
@@ -271,6 +296,12 @@ export function collectGraph(status, tables = { tables: [] }, target = null) {
     }
     return { nodes, edges: edges.filter((edge) => seenNodes.has(edge.from) && seenNodes.has(edge.to)) };
 }
+function dashboardTaskPhases(task) {
+    return Array.isArray(task.phases) ? task.phases : [];
+}
+function dashboardTaskHandoffs(task) {
+    return Array.isArray(task.handoffs) ? task.handoffs : [];
+}
 function moduleKeyFromPlanSource(source, target) {
     if (!target?.projectRoot || !target?.harness?.modulesRoot) {
         const moduleMatch = source.match(/(?:MODULES|modules)\/([^/]+)\/module_plan\.md$/);
@@ -285,6 +316,14 @@ function moduleKeyFromPlanSource(source, target) {
     const legacyMatch = source.match(/(?:MODULES|modules)\/([^/]+)\/module_plan\.md$/);
     return legacyMatch ? legacyMatch[1] : "";
 }
+function targetAbsolutePath(target, targetPath) {
+    const withoutPrefix = String(targetPath || "").replace(/^TARGET:/, "");
+    if (!withoutPrefix)
+        return "";
+    if (path.isAbsolute(withoutPrefix))
+        return withoutPrefix;
+    return path.join(target.projectRoot, withoutPrefix.replace(/^\/+/, ""));
+}
 function moduleDocumentPaths(target, moduleKey) {
     if (!target?.harness?.modulesRoot || !moduleKey)
         return {};
@@ -295,6 +334,136 @@ function moduleDocumentPaths(target, moduleKey) {
         ...(fs.existsSync(modulePlan) ? { modulePlanPath: prefixedPath(target, modulePlan) } : {}),
     };
 }
+function collectDashboardModules(status, target) {
+    const tasks = Array.isArray(status.tasks) ? status.tasks : [];
+    const registered = Array.isArray(status.modules)
+        ? status.modules
+        : [];
+    const modules = new Map();
+    for (const module of registered) {
+        const key = String(module.key || "").trim();
+        if (!key)
+            continue;
+        modules.set(key, {
+            ...module,
+            key,
+            title: String(module.title || key),
+            source: "registry",
+            ...moduleDocumentPaths(target, key),
+            counts: emptyModuleCounts(),
+            tasks: [],
+        });
+    }
+    for (const task of tasks) {
+        if (isArchivedDashboardTask(task))
+            continue;
+        const key = dashboardTaskModuleKey(task);
+        if (key === "legacy-unclassified")
+            continue;
+        if (!modules.has(key)) {
+            modules.set(key, {
+                key,
+                title: key,
+                source: "inferred",
+                status: String(task.classificationSource || "inferred"),
+                ...moduleDocumentPaths(target, key),
+                counts: emptyModuleCounts(),
+                tasks: [],
+            });
+        }
+        const module = modules.get(key);
+        if (!module)
+            continue;
+        accumulateModuleTask(module, task);
+    }
+    const unclassifiedTasks = tasks.filter((task) => !isArchivedDashboardTask(task) && dashboardTaskModuleKey(task) === "legacy-unclassified");
+    const moduleList = [...modules.values()].sort((left, right) => {
+        const leftStatus = String(left.status || "");
+        const rightStatus = String(right.status || "");
+        if (leftStatus === "in-progress" && rightStatus !== "in-progress")
+            return -1;
+        if (rightStatus === "in-progress" && leftStatus !== "in-progress")
+            return 1;
+        return left.key.localeCompare(right.key);
+    });
+    return {
+        modules: moduleList,
+        summary: {
+            total: moduleList.length,
+            registered: registered.length,
+            inferred: moduleList.filter((module) => module.source === "inferred").length,
+            active: moduleList.filter((module) => Number(module.counts.active || 0) > 0).length,
+            risk: moduleList.reduce((sum, module) => sum + Number(module.counts.risk || 0), 0),
+            unclassifiedTasks: unclassifiedTasks.length,
+        },
+    };
+}
+function emptyModuleCounts() {
+    return {
+        total: 0,
+        active: 0,
+        in_progress: 0,
+        review: 0,
+        blocked: 0,
+        done: 0,
+        planned: 0,
+        not_started: 0,
+        unknown: 0,
+        risk: 0,
+        missingDocs: 0,
+    };
+}
+function accumulateModuleTask(module, task) {
+    const state = String(task.state || "unknown");
+    module.counts.total += 1;
+    module.counts[state] = (module.counts[state] || 0) + 1;
+    if (["in_progress", "review", "blocked", "planned", "not_started"].includes(state))
+        module.counts.active += 1;
+    if (dashboardTaskHasRisk(task))
+        module.counts.risk += 1;
+    if (dashboardTaskMissingDocs(task))
+        module.counts.missingDocs += 1;
+    if (module.tasks.length < 16) {
+        module.tasks.push({
+            id: task.id,
+            shortId: task.shortId,
+            title: task.title,
+            state,
+            completion: task.completion,
+            reviewStatus: task.reviewStatus,
+            closeoutStatus: task.closeoutStatus,
+            lifecycleState: task.lifecycleState,
+            taskQueues: task.taskQueues,
+            queueReasons: task.queueReasons,
+            visualMapStatus: task.visualMapStatus,
+            briefSource: task.briefSource,
+            path: task.path,
+        });
+    }
+}
+function dashboardTaskModuleKey(task) {
+    return String(task.module || task.inferredModule || "legacy-unclassified");
+}
+function isArchivedDashboardTask(task) {
+    const archiveState = String(task.archiveMetadata?.state || "").toLowerCase();
+    return task.deletionState === "archived" || archiveState === "archived";
+}
+function dashboardTaskHasRisk(task) {
+    if (task.state === "blocked")
+        return true;
+    if (String(task.reviewStatus || "").includes("blocked"))
+        return true;
+    if (Array.isArray(task.materialIssues) && task.materialIssues.length > 0)
+        return true;
+    if (Array.isArray(task.queueReasons) && task.queueReasons.length > 0)
+        return true;
+    if (String(task.visualMapStatus || "") === "missing")
+        return true;
+    return false;
+}
+function dashboardTaskMissingDocs(task) {
+    return task.briefSource !== "standalone" || String(task.visualMapStatus || "") === "missing";
+}
 export function categorizeWarning(message) {
     if (/governance-table-entropy/i.test(message))
         return "Governance Table Boundary";
@@ -395,11 +564,14 @@ function warningAffectedPaths(message) {
     return [...new Set(matches.map((item) => item.replace(/[),.;]+$/, "")))];
 }
 function summarizeWarnings(warnings) {
-    const countBy = (field) => warnings.reduce((acc, warning) => {
-        const key = warning[field] || "unknown";
-        acc[key] = (acc[key] || 0) + 1;
-        return acc;
-    }, {});
+    const countBy = (field) => {
+        const counts = {};
+        for (const warning of warnings) {
+            const key = String(warning[field] || "unknown");
+            counts[key] = (counts[key] ?? 0) + 1;
+        }
+        return counts;
+    };
     return {
         total: warnings.length,
         byCategory: countBy("category"),
@@ -518,7 +690,7 @@ function warningAction(message) {
 }
 export function buildDashboardBundle(targetInput, options = {}) {
     const target = normalizeTarget(targetInput);
-    const taskPlanPaths = listTaskPlanPaths(target);
+    const tasks = options.tasks || createScannerTaskRepository(target).list();
     const capabilityState = validateCapabilities(target);
     const gitState = summarizeGitState(target);
     const declaredCapabilities = new Set(capabilityState.registry.capabilities.map((capability) => capability.name));
@@ -530,17 +702,18 @@ export function buildDashboardBundle(targetInput, options = {}) {
         ...options,
         capabilityState,
         gitState,
-        taskPlanPaths,
+        tasks,
         legacy,
         failures: [...capabilityState.failures, ...governanceBoundaries.failures],
         warnings: [...capabilityState.warnings, ...legacyWarnings, ...governanceBoundaries.warnings, ...gitState.warnings],
     });
-    const documents = { documents: collectMarkdownDocuments(target, { taskPlanPaths, tasks: status.tasks }) };
+    const documents = { documents: collectMarkdownDocuments(target, { tasks: status.tasks }) };
     const tables = collectTables(documents.documents);
     const graph = collectGraph(status, tables, target);
+    const modules = collectDashboardModules(status, target);
     const adoption = collectAdoption(status);
     const presetCatalog = collectPresetCatalog(targetInput, target, options);
-    return sanitizeDeep({ status, tables, documents, graph, adoption, presetCatalog });
+    return sanitizeDeep({ status, tables, documents, graph, modules: modules.modules, moduleSummary: modules.summary, adoption, presetCatalog });
 }
 function runDashboardCompatibilityCheck(target) {
     const checkTarget = target.docsOnly ? target.projectRoot : target.input;
@@ -597,7 +770,15 @@ export function writeDashboardFolder(outDir, targetInput, options = {}) {
     const registry = readCapabilityRegistry(target);
     const locale = options.localeOverride || registry.locale;
     const bundle = buildDashboardBundle(targetInput, options);
-    return writeDashboardDirectory(outDir, bundle, { repoRoot, projectRoot: target.projectRoot, docsRoot: target.docsRoot, locale, workbenchRuntime: options.workbenchRuntime === true, recoverGeneratedDashboard: options.recoverGeneratedDashboard === true });
+    return writeDashboardDirectory(outDir, bundle, {
+        repoRoot,
+        projectRoot: target.projectRoot,
+        docsRoot: target.docsRoot,
+        locale,
+        workbenchRuntime: options.workbenchRuntime === true,
+        recoverGeneratedDashboard: options.recoverGeneratedDashboard === true,
+        replaceExistingDashboardOutput: options.replaceExistingDashboardOutput === true,
+    });
 }
 export function writeDashboardSingleFile(outFile, targetInput, options = {}) {
     const target = normalizeTarget(targetInput);