@deksden-com/dd-flow-cli 0.7.0 → 0.8.0

package/dist/services/vnext-workspace-policy.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { gitFacts } from "./runs.js";
+const configRelativePath = path.join(".memory-bank", "dd-flow", "project-workspace.json");
+/** The runtime reads explicit configuration; it never attempts to infer route from policy prose. */
+export function loadVnextWorkspacePolicy(projectRoot) {
+    const file = path.join(projectRoot, configRelativePath);
+    if (!fs.existsSync(file)) {
+        throw new AppError("workspace_policy_missing", "vNext flow requires .memory-bank/dd-flow/project-workspace.json", 1, { file });
+    }
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("workspace_policy_invalid", "Project workspace policy is not valid JSON", 1, { file, cause: String(error) });
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new AppError("workspace_policy_invalid", "Project workspace policy must be an object", 1, { file });
+    }
+    const raw = value;
+    const workspace = raw.workspace;
+    const route = workspace?.route;
+    const integrationBranch = workspace?.integration_branch;
+    const template = workspace?.feature_branch_template;
+    const provisionStage = workspace?.provision_stage;
+    if (raw.schema_id !== "dd-flow/project-workspace@1" || !workspace || (route !== "feature_worktree" && route !== "integration_branch_direct") || typeof integrationBranch !== "string" || !integrationBranch || provisionStage !== "protocolize_start") {
+        throw new AppError("workspace_policy_invalid", "Project workspace policy does not match dd-flow/project-workspace@1", 1, { file });
+    }
+    if (route === "feature_worktree" && (typeof template !== "string" || !template.includes("<RUN>"))) {
+        throw new AppError("workspace_policy_invalid", "feature_worktree policy needs a branch template containing <RUN>", 1, { file });
+    }
+    return {
+        schema_id: "dd-flow/project-workspace@1",
+        workspace: {
+            route,
+            integration_branch: integrationBranch,
+            feature_branch_template: typeof template === "string" ? template : null,
+            provision_stage: "protocolize_start"
+        }
+    };
+}
+export function vnextRunBranch(policy, run) {
+    if (policy.workspace.route !== "feature_worktree")
+        return null;
+    return policy.workspace.feature_branch_template
+        .replaceAll("<RUN>", run.short_id.toLowerCase())
+        .replaceAll("<slug>", safeSlug(run.slug));
+}
+/**
+ * The route receipt is the single source of truth after PROTOCOLIZE provisions
+ * the workspace. Every later mutating vNext stage calls this before it opens.
+ */
+export function requireVnextWorkspaceRoute(input) {
+    const file = path.join(input.runHome, "02-protocolize", "workspace-route.json");
+    let receipt;
+    try {
+        receipt = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("workspace_route_missing", `${input.stage} requires the PROTOCOLIZE workspace route receipt`, 1, { file, run_id: input.runId, cause: String(error) });
+    }
+    const policy = receipt.policy;
+    if (receipt.schema_id !== "dd-flow/vnext-workspace-route@1" || !policy?.provisioned || (policy.route !== "feature_worktree" && policy.route !== "integration_branch_direct")) {
+        throw new AppError("workspace_route_missing", `${input.stage} requires a valid provisioned workspace route`, 1, { file, run_id: input.runId });
+    }
+    const workspaceRoot = realPath(input.workspaceRoot);
+    if (policy.worktree_path && realPath(policy.worktree_path) !== workspaceRoot) {
+        throw new AppError("workspace_route_invalid", `${input.stage} RUN workspace differs from its frozen route`, 1, { run_id: input.runId, expected_workspace_root: policy.worktree_path, actual_workspace_root: workspaceRoot });
+    }
+    if (policy.route === "feature_worktree") {
+        if (!receipt.created || !receipt.bootstrap || !policy.worktree_path || !policy.feature_branch || !policy.base_ref || workspaceRoot === realPath(input.projectRoot)) {
+            throw new AppError("workspace_route_missing", `${input.stage} requires a provisioned feature worktree`, 1, { run_id: input.runId, workspace_root: workspaceRoot, policy });
+        }
+        const facts = gitFacts(workspaceRoot);
+        if (facts.status === "unavailable" || facts.branch !== policy.feature_branch || facts.head !== policy.base_ref) {
+            throw new AppError("workspace_route_invalid", `${input.stage} workspace no longer matches its frozen feature branch and base`, 1, { run_id: input.runId, workspace_root: workspaceRoot, expected: policy, actual: facts });
+        }
+    }
+    return policy;
+}
+function realPath(value) { return fs.existsSync(value) ? fs.realpathSync(value) : path.resolve(value); }
+function safeSlug(value) {
+    const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return slug || "work";
+}