@deksden-com/dd-flow-cli 0.2.0 → 0.3.0

package/dist/schemas/status-report.schema.json

@@ -18,6 +18,8 @@
       "properties": {
         "version": { "type": "string", "minLength": 1 },
         "package_name": { "type": "string", "minLength": 1 },
+        "compatibility": { "$ref": "#/definitions/cliCompatibility" },
+        "registry": { "$ref": "#/definitions/registryStatus" },
         "build": {
           "type": "object",
           "additionalProperties": true,
@@ -85,6 +87,38 @@
     }
   },
   "definitions": {
+    "cliCompatibility": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["verdict", "reason", "package_name", "installed_version"],
+      "properties": {
+        "verdict": { "type": "string", "enum": ["ok", "outdated", "incompatible", "missing", "unknown"] },
+        "reason": { "type": "string", "minLength": 1 },
+        "package_name": { "type": "string", "minLength": 1 },
+        "expected_package_name": { "type": "string" },
+        "installed_version": { "type": "string", "minLength": 1 },
+        "memory_bank_version": { "type": ["string", "null"] },
+        "min_version": { "type": ["string", "null"] },
+        "recommended_version": { "type": ["string", "null"] },
+        "status_contract": { "type": ["string", "null"] },
+        "version_contract": { "type": ["string", "null"] },
+        "flow_contract": { "type": ["string", "null"] },
+        "update_command": { "type": ["string", "null"] }
+      }
+    },
+    "registryStatus": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["package_name", "latest", "checked_at", "source", "status"],
+      "properties": {
+        "package_name": { "type": "string", "minLength": 1 },
+        "latest": { "type": ["string", "null"] },
+        "checked_at": { "type": "string", "minLength": 1 },
+        "source": { "type": "string", "enum": ["npm", "npm_cache"] },
+        "status": { "type": "string", "enum": ["ok", "degraded"] },
+        "reason": { "type": "string" }
+      }
+    },
     "memoryBank": {
       "type": ["object", "null"],
       "additionalProperties": true,

package/dist/schemas/version-report.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/version-report@1",
+  "title": "dd-flow version report",
+  "description": "Small read-only JSON contract for dd-flow version --json.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["ok", "schema_id", "cli"],
+  "properties": {
+    "ok": { "const": true },
+    "schema_id": { "const": "dd-flow/version-report@1" },
+    "cli": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["package_name", "version"],
+      "properties": {
+        "package_name": { "type": "string", "minLength": 1 },
+        "version": { "type": "string", "minLength": 1 }
+      }
+    }
+  }
+}

package/dist/services/build-info.js

@@ -21,6 +21,10 @@ export function getCliBuildInfo() {
                     version: null,
                     commit: null,
                     flow_contract: null,
+                    repo_root: null,
+                    memorybank_root: null,
+                    flow_root: null,
+                    layout: null,
                     status: "unknown",
                     reason: "build_info_missing"
                 }
@@ -31,10 +35,14 @@ export function getCliBuildInfo() {
     const canonVersion = stringOrNull(builtWithCanon?.version);
     const canonCommit = stringOrNull(builtWithCanon?.commit);
     const flowContract = stringOrNull(builtWithCanon?.flow_contract);
-    const canonStatus = canonVersion && canonCommit ? "present" : "degraded";
+    const repoRoot = stringOrNull(builtWithCanon?.repo_root);
+    const memorybankRoot = stringOrNull(builtWithCanon?.memorybank_root);
+    const flowRoot = stringOrNull(builtWithCanon?.flow_root);
+    const layout = stringOrNull(builtWithCanon?.layout);
+    const canonStatus = canonVersion && canonCommit && flowContract ? "present" : "degraded";
     return {
-        version: stringOr(buildInfo.cli_version, version),
-        package_name: stringOr(buildInfo.cli_package, packageName),
+        version,
+        package_name: packageName,
         build: {
             status: "present",
             built_at: stringOrNull(buildInfo.built_at),
@@ -43,12 +51,27 @@ export function getCliBuildInfo() {
                 version: canonVersion,
                 commit: canonCommit,
                 flow_contract: flowContract,
+                repo_root: repoRoot,
+                memorybank_root: memorybankRoot,
+                flow_root: flowRoot,
+                layout,
                 status: canonStatus,
                 ...(canonStatus === "degraded" ? { reason: "build_canon_metadata_incomplete" } : {})
             }
         }
     };
 }
+export function getCliVersionReport() {
+    const cli = getCliBuildInfo();
+    return {
+        ok: true,
+        schema_id: "dd-flow/version-report@1",
+        cli: {
+            package_name: cli.package_name,
+            version: cli.version
+        }
+    };
+}
 function findPackageRoot(start) {
     let current = path.resolve(start);
     while (true) {

package/dist/services/canon.js

@@ -46,14 +46,21 @@ export function resolveCanonRoot(context, input = {}) {
             throw new Error("Expected one canonical candidate.");
         }
         const root = candidate.realpath ?? candidate.root;
-        const metadata = readCanonMetadata(root);
+        const flowRoot = candidate.flow_root ?? path.join(root, "dd-flow");
+        const memorybankRoot = candidate.memorybank_root ?? root;
+        const mbbRoot = candidate.mbb_root ?? path.join(memorybankRoot, "mbb");
+        const layout = candidate.layout ?? "legacy_root";
+        const metadata = readCanonMetadata(root, flowRoot);
         return {
             ok: true,
             canon: {
                 root,
+                repo_root: root,
                 source: candidate.source,
-                flow_root: path.join(root, "dd-flow"),
-                memorybank_root: root,
+                layout,
+                flow_root: flowRoot,
+                mbb_root: mbbRoot,
+                memorybank_root: memorybankRoot,
                 version: metadata.version,
                 commit: metadata.commit,
                 flow_contract: metadata.flow_contract,
@@ -121,24 +128,28 @@ function validateCanonCandidate(source, root) {
     if (!fs.statSync(realpath).isDirectory()) {
         blockers.push(`${source} canonical root is not a directory: ${realpath}`);
     }
-    const requiredFiles = [
-        "dd-flow/README.md",
-        "mbb/index.md",
-        "protocol/index.md",
-        "dd-flow/mb-init.md",
-        "dd-flow/mb-upgrade.md",
-        "dd-flow/mb-upgrade-review.md",
-        "dd-flow/mb-distill.md"
-    ];
-    for (const relativePath of requiredFiles) {
-        const file = path.join(realpath, relativePath);
-        if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
-            blockers.push(`${source} canonical root is missing ${relativePath}: ${realpath}`);
-        }
+    if (path.basename(realpath) === ".memory-bank" && fs.existsSync(path.join(path.dirname(realpath), "VERSION"))) {
+        blockers.push(`${source} canonical root points to .memory-bank; use the dd-memorybank repository root instead: ${path.dirname(realpath)}`);
     }
-    return { source, root: absolute, realpath, valid: blockers.length === 0, blockers };
+    const layout = assessCanonLayout(realpath);
+    blockers.push(...layout.blockers.map((blocker) => `${source} ${blocker}`));
+    return {
+        source,
+        root: absolute,
+        realpath,
+        valid: blockers.length === 0 && layout.valid,
+        blockers,
+        ...(layout.valid
+            ? {
+                layout: layout.layout,
+                memorybank_root: layout.memorybankRoot,
+                flow_root: layout.flowRoot,
+                mbb_root: layout.mbbRoot
+            }
+            : {})
+    };
 }
-export function readCanonMetadata(root) {
+export function readCanonMetadata(root, flowRoot = path.join(root, "dd-flow")) {
     const diagnostics = [];
     const version = readTrimmed(path.join(root, "VERSION"));
     if (!version)
@@ -146,7 +157,7 @@ export function readCanonMetadata(root) {
     const commit = gitCommit(root);
     if (!commit)
         diagnostics.push("canon_commit_unknown");
-    const flowContract = readFlowContractId(root);
+    const flowContract = readFlowContractId(flowRoot);
     if (!flowContract)
         diagnostics.push("flow_contract_unknown");
     return {
@@ -166,9 +177,69 @@ function readTrimmed(file) {
         return null;
     }
 }
-function readFlowContractId(root) {
+export function resolveCanonLayout(root) {
+    return assessCanonLayout(path.resolve(root));
+}
+function assessCanonLayout(root) {
+    const legacy = assessLayout(root, "legacy_root", root);
+    const dot = assessLayout(root, "dot_memory_bank", path.join(root, ".memory-bank"));
+    if (dot.valid && !legacy.valid)
+        return dot;
+    if (legacy.valid && !dot.valid)
+        return legacy;
+    if (dot.valid && legacy.valid) {
+        if (dot.flowContract && legacy.flowContract && dot.flowContract !== legacy.flowContract) {
+            return {
+                ...dot,
+                valid: false,
+                blockers: [
+                    `canonical root has conflicting legacy_root and dot_memory_bank flow contracts: ${legacy.flowContract} vs ${dot.flowContract}`
+                ]
+            };
+        }
+        return dot;
+    }
+    return {
+        ...dot,
+        valid: false,
+        blockers: [
+            "canonical root does not match legacy_root or dot_memory_bank layout",
+            ...legacy.blockers.map((blocker) => `legacy_root: ${blocker}`),
+            ...dot.blockers.map((blocker) => `dot_memory_bank: ${blocker}`)
+        ]
+    };
+}
+function assessLayout(root, layout, memorybankRoot) {
+    const blockers = [];
+    const requiredFiles = [
+        "dd-flow/README.md",
+        "mbb/index.md",
+        "protocol/index.md",
+        "dd-flow/mb-init.md",
+        "dd-flow/mb-upgrade.md",
+        "dd-flow/mb-upgrade-review.md",
+        "dd-flow/mb-distill.md"
+    ];
+    for (const relativePath of requiredFiles) {
+        const file = path.join(memorybankRoot, relativePath);
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+            blockers.push(`canonical root is missing ${layout} ${relativePath}: ${root}`);
+        }
+    }
+    const flowRoot = path.join(memorybankRoot, "dd-flow");
+    return {
+        layout,
+        memorybankRoot,
+        flowRoot,
+        mbbRoot: path.join(memorybankRoot, "mbb"),
+        valid: blockers.length === 0,
+        blockers,
+        flowContract: readFlowContractId(flowRoot)
+    };
+}
+function readFlowContractId(flowRoot) {
     try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(root, "dd-flow", "flow-contract.json"), "utf8"));
+        const parsed = JSON.parse(fs.readFileSync(path.join(flowRoot, "flow-contract.json"), "utf8"));
         if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
             const id = parsed.id;
             return typeof id === "string" && id.length > 0 ? id : null;

package/dist/services/cleanup.js

@@ -7,7 +7,7 @@ import { ensureReadableFile } from "../storage/database.js";
 import { projectCheckoutRoot, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { requireProjectByRoot } from "./projects.js";
-import { readProtocolRuntimeState, requireProtocol } from "./protocols.js";
+import { protocolRunDiagnostics, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 const actionKinds = new Set([
     "repair_protocol_state",
     "cancel_queue_job",
@@ -39,6 +39,19 @@ export function cleanupScan(context, input) {
                 });
             }
         }
+        const fullProtocol = requireProtocol(context, protocol.id);
+        const state = readProtocolRuntimeState(context, fullProtocol).state;
+        const diagnostics = protocolRunDiagnostics(context, fullProtocol, state).diagnostics;
+        for (const diagnostic of diagnostics.filter((entry) => entry.code === "protocol_run_stage_mismatch")) {
+            findings.push({
+                code: "protocol_run_stage_mismatch",
+                severity: diagnostic.severity === "error" ? "warning" : "info",
+                protocol_id: protocol.id,
+                protocol_stage: state.stage,
+                latest_run: diagnostic.latest_run,
+                recommended_commands: diagnostic.recommended_commands
+            });
+        }
     }
     const orphanQueueJobs = context.db.all(`SELECT mq.protocol_id, mq.status FROM merge_queue mq
      LEFT JOIN protocols p ON p.id = mq.protocol_id

package/dist/services/config.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { cmuxModes } from "../domain/contracts.js";
 import { AppError } from "../shared/errors.js";
+import { projectHome } from "../storage/paths.js";
 export const defaultProjectConfig = {
     dashboard: {
         auto_refresh: true,
@@ -52,6 +53,30 @@ export function globalDashboardMarkdownPath(context, config) {
     const configured = config?.dashboard.global_markdown_path ?? defaultProjectConfig.dashboard.global_markdown_path;
     return path.isAbsolute(configured) ? configured : path.join(context.ddFlowHome, configured);
 }
+export function projectDashboardDir(ddFlowHome, projectId) {
+    return path.join(projectHome(ddFlowHome, projectId), "dashboard");
+}
+export function projectDashboardJsonPath(context, projectId) {
+    return path.join(projectDashboardDir(context.ddFlowHome, projectId), "project-dashboard.json");
+}
+export function projectDashboardHtmlPath(context, projectId) {
+    return path.join(projectDashboardDir(context.ddFlowHome, projectId), "project-dashboard.html");
+}
+export function protocolDashboardJsonPath(context, projectId, protocolId) {
+    return path.join(projectDashboardDir(context.ddFlowHome, projectId), "protocols", `${protocolId}.json`);
+}
+export function protocolDashboardHtmlPath(context, projectId, protocolId) {
+    return path.join(projectDashboardDir(context.ddFlowHome, projectId), "protocols", `${protocolId}.html`);
+}
+export function globalDashboardDir(context) {
+    return path.join(context.ddFlowHome, "dashboard");
+}
+export function globalDashboardJsonPath(context) {
+    return path.join(globalDashboardDir(context), "global-dashboard.json");
+}
+export function globalDashboardHtmlPath(context) {
+    return path.join(globalDashboardDir(context), "global-dashboard.html");
+}
 function configOverrides(context, projectId) {
     return context.db.all("SELECT key, value_json, updated_at FROM project_config WHERE project_id = ? ORDER BY key ASC", [projectId]);
 }