@dev-loops/core 0.1.0

package/src/loop/phase-files.mjs

@@ -0,0 +1,187 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export function createDefaultPhaseManifest(phase) {
+  return {
+    phase,
+    status: "not-started",
+    startedAt: "",
+    completedAt: "",
+    nextPhase: "",
+    validation: {
+      check: "not-run",
+      test: "not-run",
+      coverage: "not-run",
+    },
+    artifacts: [],
+    subagents: [],
+    decisions: [],
+    notes: [],
+  };
+}
+
+export function createDefaultPhaseIndex() {
+  return {
+    phases: [],
+  };
+}
+
+export function normalizePhaseName(phase) {
+  if (typeof phase !== "string" || !/^phase-\d+$/.test(phase)) {
+    throw new Error(`phase must match phase-<number>, received ${phase}`);
+  }
+
+  return phase;
+}
+
+export function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))].sort();
+}
+
+export async function readJsonIfExists(filePath) {
+  try {
+    const content = await readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return undefined;
+    }
+
+    throw error;
+  }
+}
+
+export async function writeJson(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function buildPhasePaths(projectRoot, phase) {
+  const normalizedPhase = normalizePhaseName(phase);
+  const phasesRoot = path.join(projectRoot, "tmp", "phases");
+  const phaseDir = path.join(phasesRoot, normalizedPhase);
+  const docsPhasesRoot = path.join(projectRoot, "docs", "phases");
+
+  return {
+    projectRoot,
+    phasesRoot,
+    phase: normalizedPhase,
+    phaseDir,
+    docsPhasesRoot,
+    phasePlanPath: path.join(docsPhasesRoot, `${normalizedPhase}.md`),
+    manifestPath: path.join(phaseDir, "manifest.json"),
+    indexPath: path.join(phasesRoot, "index.json"),
+    bashExitOnePath: path.join(phaseDir, "bash-exit-1.jsonl"),
+  };
+}
+
+export function applyManifestPatch(manifest, patch = {}) {
+  const next = {
+    ...manifest,
+    ...patch,
+    validation: {
+      ...manifest.validation,
+      ...(patch.validation ?? {}),
+    },
+  };
+
+  next.artifacts = uniqueSortedStrings([...(manifest.artifacts ?? []), ...(patch.artifacts ?? [])]);
+  next.subagents = uniqueSortedStrings([...(manifest.subagents ?? []), ...(patch.subagents ?? [])]);
+  next.decisions = uniqueSortedStrings([...(manifest.decisions ?? []), ...(patch.decisions ?? [])]);
+  next.notes = uniqueSortedStrings([...(manifest.notes ?? []), ...(patch.notes ?? [])]);
+
+  return next;
+}
+
+export function upsertPhaseIndex(index, phaseEntry) {
+  const phases = Array.isArray(index?.phases) ? [...index.phases] : [];
+  const existingIndex = phases.findIndex((entry) => entry.phase === phaseEntry.phase);
+
+  if (existingIndex >= 0) {
+    phases[existingIndex] = {
+      ...phases[existingIndex],
+      ...phaseEntry,
+    };
+  } else {
+    phases.push(phaseEntry);
+  }
+
+  phases.sort((left, right) => left.phase.localeCompare(right.phase, undefined, { numeric: true }));
+  return { phases };
+}
+
+export async function ensurePhaseFiles(projectRoot, phase, patch = {}) {
+  const paths = buildPhasePaths(projectRoot, phase);
+  await mkdir(paths.phaseDir, { recursive: true });
+
+  const currentManifest = (await readJsonIfExists(paths.manifestPath)) ?? createDefaultPhaseManifest(paths.phase);
+  const nextManifest = applyManifestPatch(currentManifest, patch);
+  await writeJson(paths.manifestPath, nextManifest);
+
+  const currentIndex = (await readJsonIfExists(paths.indexPath)) ?? createDefaultPhaseIndex();
+  const nextIndex = upsertPhaseIndex(currentIndex, {
+    phase: paths.phase,
+    status: nextManifest.status,
+    manifestPath: path.relative(projectRoot, paths.manifestPath),
+    updatedAt: new Date().toISOString(),
+  });
+  await writeJson(paths.indexPath, nextIndex);
+
+  return {
+    paths,
+    manifest: nextManifest,
+    index: nextIndex,
+  };
+}
+
+function requireOptionValue(args, flag) {
+  const value = args.shift();
+
+  if (typeof value !== "string" || value.length === 0 || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+
+  return value;
+}
+
+export function parseCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    projectRoot: process.cwd(),
+    phase: undefined,
+    patch: {},
+  };
+
+  while (args.length > 0) {
+    const token = args.shift();
+
+    if (token === "--project-root") {
+      options.projectRoot = requireOptionValue(args, "--project-root");
+      continue;
+    }
+
+    if (token === "--phase") {
+      options.phase = requireOptionValue(args, "--phase");
+      continue;
+    }
+
+    if (token === "--patch") {
+      options.patch = JSON.parse(requireOptionValue(args, "--patch"));
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  if (!options.phase) {
+    throw new Error("Missing required --phase <phase-name> argument");
+  }
+
+  return options;
+}
+
+export async function runCli(argv = process.argv.slice(2), stdout = process.stdout) {
+  const options = parseCliArgs(argv);
+  const result = await ensurePhaseFiles(options.projectRoot, options.phase, options.patch);
+  stdout.write(`${JSON.stringify({ ok: true, ...result.paths })}\n`);
+}

package/src/loop/policy-constants.mjs

@@ -0,0 +1,17 @@
+/**
+ * Centralized policy constants — single source of truth for
+ * timeout budgets, poll intervals, and related policy values.
+ *
+ * These replace the now-removed CLI policy flags (--timeout-ms,
+ * --poll-interval-ms, --probe-only, --force, --force-rerequest-review).
+ */
+export const DEFAULT_POLL_INTERVAL_MS = 60_000;
+
+/** Copilot-first durable-wait seam: bootstrap-only PR watch budget */
+export const COPILOT_FIRST_DURABLE_WAIT_TIMEOUT_MS = 3_600_000;
+
+/** Copilot review wait: external healthy-wait budget */
+export const COPILOT_REVIEW_WAIT_TIMEOUT_MS = 1_800_000;
+
+/** Explicit single-check timeout value (used only for status probes) */
+export const PROBE_ONLY_TIMEOUT_MS = 0;