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

package/dist/services/vnext-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/services/vnext-execution-profile.js

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+const relativePath = path.join(".memory-bank", "dd-flow", "project-execution.json");
+/** The project owns defaults; a RUN snapshots them once and never re-infers them. */
+export function loadVnextExecutionProfile(projectRoot) {
+    const file = path.join(projectRoot, relativePath);
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("execution_profile_missing", "vNext flow requires .memory-bank/dd-flow/project-execution.json", 1, { file, cause: String(error) });
+    }
+    const profile = value;
+    if (profile.schema_id !== "dd-flow/project-execution@1"
+        || (profile.stage_session_mode !== undefined && profile.stage_session_mode !== "same_session" && profile.stage_session_mode !== "new_session")
+        || !["auto", "off", "standard", "deep"].includes(String(profile.plan_review_mode))
+        || (profile.code_review_mode !== undefined && !["auto", "off", "standard", "deep"].includes(String(profile.code_review_mode)))
+        || !["code_completed", "code_review_completed"].includes(String(profile.stop_target))
+        || !profile.code_bootstrap || typeof profile.code_bootstrap.command !== "string" || !profile.code_bootstrap.command.trim()
+        || typeof profile.code_bootstrap.policy_ref !== "string" || !profile.code_bootstrap.policy_ref.trim()) {
+        throw new AppError("execution_profile_invalid", "Project execution profile does not match dd-flow/project-execution@1", 1, { file });
+    }
+    return { ...profile, stage_session_mode: profile.stage_session_mode ?? "same_session", code_review_mode: profile.code_review_mode ?? "off" };
+}
+export function executionProfilePath(projectRoot) { return path.join(projectRoot, relativePath); }

package/dist/services/vnext-fanout.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { getFlowRunVariables } from "./runs.js";
+import { listWorks } from "./work-registry.js";
+import { vnextStageDirectory } from "../domain/stage-catalog.js";
+export const subagentCapacityKey = "runtime.subagent.available_slots";
+export const capacityProbe = {
+    fanout_size: 15,
+    probe_hold_seconds: 60,
+    cleanup_deadline_seconds: 180,
+    completion_token: "AGENT-NN"
+};
+export function fanoutState(input) {
+    if (!input.hasWork)
+        return input.dispatch === "none" ? "coordinator_required" : "dispatch_required";
+    if (input.capacityRequired && !input.capacityKnown)
+        return "capacity_required";
+    if (input.created || input.running)
+        return "awaiting_children";
+    return "children_settled";
+}
+export function fanoutFile(stageRoot) { return path.join(stageRoot, "fanout.json"); }
+export function writeFanoutDescriptor(stageRoot, descriptor) {
+    const value = { schema_id: "dd-flow/work-fanout@1", kind: "work_fanout", ...descriptor };
+    fs.writeFileSync(fanoutFile(stageRoot), `${JSON.stringify(value, null, 2)}\n`);
+    return value;
+}
+export function readFanoutDescriptor(stageRoot) {
+    const file = fanoutFile(stageRoot);
+    if (!fs.existsSync(file))
+        return null;
+    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (value.schema_id !== "dd-flow/work-fanout@1" || value.kind !== "work_fanout" || typeof value.stage !== "string" || typeof value.parent_work_id !== "string" || !["none", "plan-review"].includes(String(value.dispatch)) || typeof value.capacity_required !== "boolean") {
+        throw new AppError("runtime_missing", "Stage fan-out descriptor is invalid", 1, { file });
+    }
+    return value;
+}
+/** Read-only projection for an external orchestrator.  dd-flow keeps the graph authority. */
+export function getVnextFanoutStatus(context, input) {
+    const projectRoot = resolveProjectRoot(input.projectRoot);
+    const project = requireProjectByRoot(context, projectRoot);
+    const run = context.db.get("SELECT run_home_path FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
+    if (!run?.run_home_path)
+        throw new AppError("not_found", "RUN workspace is unavailable", 1, { run_id: input.runId });
+    const stageRoot = path.join(run.run_home_path, vnextStageDirectory(input.stage));
+    const descriptor = readFanoutDescriptor(stageRoot);
+    if (!descriptor)
+        return { ok: true, run_id: input.runId, stage: input.stage, orchestration: null };
+    if (descriptor.stage !== input.stage)
+        throw new AppError("runtime_missing", "Stage fan-out descriptor belongs to another stage", 1, { requested_stage: input.stage, descriptor_stage: descriptor.stage });
+    const variables = getFlowRunVariables(context, { projectRoot, runId: input.runId });
+    const available = variables.variables[subagentCapacityKey];
+    const all = listWorks(context, { parentWorkId: descriptor.parent_work_id, includeResults: false });
+    const ready = listWorks(context, { parentWorkId: descriptor.parent_work_id, ready: true, includeResults: false });
+    const counts = Object.fromEntries(["created", "running", "completed", "failed", "cancelled"].map((status) => [status, all.works.filter((work) => work.status === status).length]));
+    const hasWork = all.works.length > 0;
+    const capacityKnown = typeof available === "number" && Number.isInteger(available) && available >= 0;
+    return {
+        ok: true,
+        run_id: input.runId,
+        stage: descriptor.stage,
+        orchestration: {
+            ...descriptor,
+            // PLAN-REVIEW has a deterministic dispatcher. CODE and CODE-REVIEW do
+            // not: their coordinator first materializes the Work graph from its
+            // authoritative prompt. An empty graph is therefore not a success.
+            state: fanoutState({ dispatch: descriptor.dispatch, hasWork, capacityRequired: descriptor.capacity_required, capacityKnown, created: counts.created ?? 0, running: counts.running ?? 0 }),
+            capacity: {
+                run_key: subagentCapacityKey,
+                available_slots: capacityKnown ? available : null,
+                ...(descriptor.capacity_required && !capacityKnown ? { probe: capacityProbe } : {})
+            },
+            works: { ...counts, ready: ready.works.map((work) => ({ work_id: work.work_id, task: work.task, start_command: work.start_command })) }
+        }
+    };
+}