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

package/dist/services/compatibility-preflight.js

@@ -0,0 +1,124 @@
+import { AppError } from "../shared/errors.js";
+import { getCliBuildInfo } from "./build-info.js";
+import { classifyCliOperation } from "./cli-operation-classifier.js";
+import { selectEngine } from "./engines.js";
+import { requireProtocol } from "./protocols.js";
+export function preflightCliCompatibility(context, args, env = process.env) {
+    const classification = classifyCliOperation(args, env);
+    if (classification.mode === "router_native") {
+        return { ok: true, classification, compatibility: null };
+    }
+    const projectRoot = resolveOperationProjectRoot(context, args);
+    if (!projectRoot) {
+        return { ok: true, classification, compatibility: null };
+    }
+    const selection = selectEngine(context, { projectRoot });
+    const compatibility = compatibilityReport(selection, classification);
+    if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
+        return { ok: true, classification, compatibility };
+    }
+    if (selection.status !== "selected" || !selection.selected) {
+        throw new AppError("compatibility_preflight_failed", "dd-flow compatibility preflight blocked a state-changing command", 1, {
+            compatibility,
+            remediation: remediationForSelection(selection)
+        });
+    }
+    return { ok: true, classification, compatibility };
+}
+export function compatibilityReport(selection, classification) {
+    const build = getCliBuildInfo();
+    return {
+        verdict: selection.status === "selected" ? "ok" : "incompatible",
+        memorybank_version: selection.memory_bank_version,
+        router_version: build.version,
+        cli_version: build.version,
+        engine_version: selection.selected?.engine_version ?? selection.selected?.package_version ?? null,
+        engine_resolution: selection.status,
+        required_engine_range: selection.required_range,
+        recommended_engine_version: selection.recommended_version,
+        allowed_modes: ["read_only_diagnostics", "mb_upgrade"],
+        operation_mode: classification.mode,
+        blocked_operation: classification.mode === "normal_write" ? classification.operation : null,
+        install_hint: selection.install_hint,
+        project_root: selection.project_root,
+        diagnostics: selection.diagnostics
+    };
+}
+function remediationForSelection(selection) {
+    return {
+        install_hint: selection.install_hint,
+        mb_upgrade_mode: "Run through mb-upgrade with --compatibility-mode mb-upgrade only when intentionally migrating the project.",
+        diagnostics: selection.diagnostics
+    };
+}
+function resolveOperationProjectRoot(context, args) {
+    const [family, command, ...rest] = args;
+    const parsed = parseLightArgs(rest);
+    const explicitRoot = option(parsed, "project-root") ?? option(parsed, "root");
+    if (explicitRoot)
+        return explicitRoot;
+    if (family === "protocol") {
+        const protocolId = positional(parsed, 0);
+        if (protocolId && command && ["ready-for-merge", "cancel", "status"].includes(command)) {
+            return requireProtocol(context, protocolId).project_root;
+        }
+    }
+    if (family === "transition") {
+        const transitionParsed = parseLightArgs([command ?? "", ...rest]);
+        const protocolId = positional(transitionParsed, 0);
+        return protocolId ? requireProtocol(context, protocolId).project_root : null;
+    }
+    if (family === "plan" && (command === "set" || command === "status")) {
+        const protocolId = positional(parsed, 0);
+        return protocolId ? requireProtocol(context, protocolId).project_root : null;
+    }
+    if (family === "plan" && command === "item") {
+        const protocolId = positional(parsed, 1);
+        return protocolId ? requireProtocol(context, protocolId).project_root : null;
+    }
+    if (family === "merge-queue" && ["complete", "fail", "cancel", "note"].includes(command ?? "")) {
+        const protocolId = positional(parsed, 0);
+        return protocolId ? requireProtocol(context, protocolId).project_root : null;
+    }
+    if (family === "worktree") {
+        const protocolId = option(parsed, "protocol-id");
+        return protocolId ? requireProtocol(context, protocolId).project_root : null;
+    }
+    return null;
+}
+function parseLightArgs(args) {
+    const positional = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value?.startsWith("--")) {
+            const equal = value.indexOf("=");
+            if (equal > 2) {
+                const key = value.slice(2, equal);
+                options.set(key, [...(options.get(key) ?? []), value.slice(equal + 1)]);
+                continue;
+            }
+            const key = value.slice(2);
+            const next = args[index + 1];
+            if (!next || next.startsWith("--")) {
+                options.set(key, [...(options.get(key) ?? []), ""]);
+            }
+            else {
+                options.set(key, [...(options.get(key) ?? []), next]);
+                index += 1;
+            }
+        }
+        else if (value) {
+            positional.push(value);
+        }
+    }
+    return { positional, options };
+}
+function option(parsed, key) {
+    const values = parsed.options.get(key);
+    const value = values?.[values.length - 1];
+    return value ? value : null;
+}
+function positional(parsed, index) {
+    return parsed.positional[index] ?? null;
+}

package/dist/services/config.js

@@ -62,6 +62,12 @@ export function projectDashboardJsonPath(context, projectId) {
 export function projectDashboardHtmlPath(context, projectId) {
     return path.join(projectDashboardDir(context.ddFlowHome, projectId), "project-dashboard.html");
 }
+export function projectSummaryDir(context, projectId) {
+    return path.join(projectHome(context.ddFlowHome, projectId), "summary");
+}
+export function projectSummaryJsonPath(context, projectId) {
+    return path.join(projectSummaryDir(context, projectId), "project-summary.json");
+}
 export function protocolDashboardJsonPath(context, projectId, protocolId) {
     return path.join(projectDashboardDir(context.ddFlowHome, projectId), "protocols", `${protocolId}.json`);
 }

package/dist/services/dashboard-targets.js

@@ -0,0 +1,95 @@
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByReference, requireProjectByRoot } from "./projects.js";
+export function resolveDashboardTarget(context, input) {
+    if (input.all) {
+        if (input.action !== "refresh") {
+            throw new AppError("validation", "--all is supported only for dashboard refresh", 2, {
+                preferred_command: "dd-flow dashboard refresh --all",
+                related_commands: relatedDashboardCommands("refresh")
+            });
+        }
+        if (input.project || input.projectRoot || input.protocol || input.global) {
+            throw new AppError("validation", "--all cannot be combined with --project, --project-root, --protocol, or --global", 2, {
+                related_commands: relatedDashboardCommands("refresh")
+            });
+        }
+        return { kind: "all_projects" };
+    }
+    if (input.global && (input.project || input.projectRoot || input.protocol)) {
+        throw new AppError("validation", "--global cannot be combined with project or protocol targets", 2, {
+            related_commands: relatedDashboardCommands(input.action)
+        });
+    }
+    const project = resolveDashboardProject(context, input.project, input.projectRoot);
+    if (input.protocol) {
+        if (!project) {
+            throw new AppError("validation", "--protocol requires --project or --project-root", 2, {
+                related_commands: relatedDashboardCommands(input.action, "project")
+            });
+        }
+        return { kind: "protocol", project, protocolId: input.protocol };
+    }
+    if (project) {
+        return { kind: "project", project };
+    }
+    return { kind: "global" };
+}
+export function dashboardTargetSummary(target) {
+    if (target.kind === "project") {
+        return { kind: "project", project_id: target.project.id, project_root: target.project.root };
+    }
+    if (target.kind === "protocol") {
+        return { kind: "protocol", project_id: target.project.id, project_root: target.project.root, protocol_id: target.protocolId };
+    }
+    return { kind: target.kind };
+}
+export function preferredDashboardCommand(action, target) {
+    if (target.kind === "project") {
+        return `dd-flow dashboard ${action} --project <project>`;
+    }
+    if (target.kind === "protocol") {
+        return `dd-flow dashboard ${action} --project <project> --protocol <protocol>`;
+    }
+    if (target.kind === "all_projects") {
+        return "dd-flow dashboard refresh --all";
+    }
+    return `dd-flow dashboard ${action}`;
+}
+export function relatedDashboardCommands(action, targetKind = "global") {
+    if (targetKind === "all_projects") {
+        return ["dd-flow dashboard refresh --all", "dd-flow dashboard open", "dd-flow dashboard open --project <project>"];
+    }
+    if (targetKind === "project" || targetKind === "protocol") {
+        return uniqueCommands([
+            `dd-flow dashboard ${action} --project <project>`,
+            "dd-flow dashboard refresh --project <project>",
+            "dd-flow dashboard open --project <project>",
+            "dd-flow dashboard data --project <project> --json"
+        ]);
+    }
+    return uniqueCommands([
+        `dd-flow dashboard ${action}`,
+        "dd-flow dashboard open",
+        "dd-flow dashboard refresh",
+        "dd-flow dashboard refresh --all",
+        "dd-flow dashboard open --project <project>"
+    ]);
+}
+function resolveDashboardProject(context, project, projectRoot) {
+    if (!project && !projectRoot) {
+        return null;
+    }
+    const byProject = project ? requireProjectByReference(context, project) : null;
+    const byRoot = projectRoot ? requireProjectByRoot(context, resolveProjectRoot(projectRoot)) : null;
+    if (byProject && byRoot && byProject.id !== byRoot.id) {
+        throw new AppError("validation", "--project and --project-root resolve to different projects", 2, {
+            project: { id: byProject.id, root: byProject.root },
+            project_root: { id: byRoot.id, root: byRoot.root }
+        });
+    }
+    return byProject ?? byRoot;
+}
+function uniqueCommands(commands) {
+    return Array.from(new Set(commands));
+}