dev-loops 0.1.0

package/skills/dev-loop/scripts/dev-mode-context.mjs

@@ -0,0 +1,152 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { buildPhasePaths } from "./phase-files.mjs";
+
+async function readTextIfExists(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return undefined;
+    }
+
+    throw error;
+  }
+}
+
+function countLines(text) {
+  if (!text || text.trim().length === 0) {
+    return 0;
+  }
+
+  return text.trimEnd().split("\n").length;
+}
+
+export function parseJsonLines(text) {
+  if (!text || text.trim().length === 0) {
+    return [];
+  }
+
+  return text
+    .trim()
+    .split("\n")
+    .filter((line) => line.trim().length > 0)
+    .map((line) => JSON.parse(line));
+}
+
+export async function collectDevModeContext(projectRoot, phase) {
+  const paths = buildPhasePaths(projectRoot, phase);
+  const summaryPath = path.join(paths.phaseDir, "summary.md");
+  const retrospectivePath = path.join(paths.phaseDir, "retrospective.md");
+  const reviewPath = path.join(paths.phaseDir, "review.md");
+  const mergedPlanPath = path.join(paths.phaseDir, "merged-plan.md");
+
+  const [manifestText, summaryText, retrospectiveText, reviewText, mergedPlanText, bashExitOneText] = await Promise.all([
+    readTextIfExists(paths.manifestPath),
+    readTextIfExists(summaryPath),
+    readTextIfExists(retrospectivePath),
+    readTextIfExists(reviewPath),
+    readTextIfExists(mergedPlanPath),
+    readTextIfExists(paths.bashExitOnePath),
+  ]);
+
+  const manifest = manifestText ? JSON.parse(manifestText) : undefined;
+  const bashExitOneRecords = parseJsonLines(bashExitOneText);
+
+  return {
+    phase: paths.phase,
+    projectRoot,
+    paths: {
+      manifestPath: path.relative(projectRoot, paths.manifestPath),
+      bashExitOnePath: path.relative(projectRoot, paths.bashExitOnePath),
+      summaryPath: path.relative(projectRoot, summaryPath),
+      retrospectivePath: path.relative(projectRoot, retrospectivePath),
+      reviewPath: path.relative(projectRoot, reviewPath),
+      mergedPlanPath: path.relative(projectRoot, mergedPlanPath),
+      devModeContextPath: path.relative(projectRoot, path.join(paths.phaseDir, "dev-mode-context.json")),
+    },
+    manifest,
+    artifactPresence: {
+      summary: Boolean(summaryText),
+      retrospective: Boolean(retrospectiveText),
+      review: Boolean(reviewText),
+      mergedPlan: Boolean(mergedPlanText),
+      bashExitOneLog: Boolean(bashExitOneText),
+    },
+    lineCounts: {
+      summary: countLines(summaryText),
+      retrospective: countLines(retrospectiveText),
+      review: countLines(reviewText),
+      mergedPlan: countLines(mergedPlanText),
+      bashExitOneLog: countLines(bashExitOneText),
+    },
+    bashExitOne: {
+      count: bashExitOneRecords.length,
+      commands: [...new Set(bashExitOneRecords.map((record) => record.command))].sort(),
+      records: bashExitOneRecords,
+    },
+  };
+}
+
+export async function writeDevModeContext(outputPath, context) {
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, `${JSON.stringify(context, null, 2)}\n`, "utf8");
+  return outputPath;
+}
+
+export function parseCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    projectRoot: process.cwd(),
+    phase: undefined,
+    output: undefined,
+  };
+
+  while (args.length > 0) {
+    const token = args.shift();
+
+    if (token === "--project-root") {
+      options.projectRoot = args.shift();
+      continue;
+    }
+
+    if (token === "--phase") {
+      options.phase = args.shift();
+      continue;
+    }
+
+    if (token === "--output") {
+      options.output = args.shift();
+      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)) {
+  const options = parseCliArgs(argv);
+  const context = await collectDevModeContext(options.projectRoot, options.phase);
+  const outputPath = options.output ?? path.join(options.projectRoot, "tmp", "phases", options.phase, "dev-mode-context.json");
+  await writeDevModeContext(outputPath, context);
+  process.stdout.write(`${JSON.stringify({ ok: true, outputPath, phase: context.phase })}\n`);
+}
+
+const invokedAsScript = process.argv[1]
+  ? import.meta.url === pathToFileURL(process.argv[1]).href
+  : false;
+
+if (invokedAsScript) {
+  runCli().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/skills/dev-loop/scripts/dev-mode-context.test.mjs

@@ -0,0 +1,80 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  collectDevModeContext,
+  parseCliArgs,
+  parseJsonLines,
+  writeDevModeContext,
+} from "./dev-mode-context.mjs";
+
+test("dev-mode-context parses json lines deterministically", () => {
+  assert.deepEqual(parseJsonLines('{"command":"npm test"}\n{"command":"npm run check"}\n'), [
+    { command: "npm test" },
+    { command: "npm run check" },
+  ]);
+  assert.deepEqual(parseJsonLines(""), []);
+});
+
+test("dev-mode-context collects context for an existing phase directory", async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dev-loop-dev-mode-"));
+  const phaseDir = path.join(tempDir, "tmp", "phases", "phase-3");
+
+  try {
+    await mkdir(phaseDir, { recursive: true });
+    await writeFile(path.join(phaseDir, "manifest.json"), JSON.stringify({ phase: "phase-3", status: "completed" }), { encoding: "utf8", flag: "w" });
+    await writeFile(path.join(phaseDir, "summary.md"), "# Summary\nline\n", { encoding: "utf8", flag: "w" });
+    await writeFile(path.join(phaseDir, "retrospective.md"), "# Retro\n", { encoding: "utf8", flag: "w" });
+    await writeFile(path.join(phaseDir, "review.md"), "# Review\n", { encoding: "utf8", flag: "w" });
+    await writeFile(path.join(phaseDir, "merged-plan.md"), "# Plan\n", { encoding: "utf8", flag: "w" });
+    await writeFile(
+      path.join(phaseDir, "bash-exit-1.jsonl"),
+      '{"command":"npm test","exitCode":1}\n{"command":"npm run test:coverage","exitCode":1}\n',
+      { encoding: "utf8", flag: "w" },
+    );
+
+    const context = await collectDevModeContext(tempDir, "phase-3");
+
+    assert.equal(context.phase, "phase-3");
+    assert.deepEqual(context.manifest, { phase: "phase-3", status: "completed" });
+    assert.deepEqual(context.artifactPresence, {
+      summary: true,
+      retrospective: true,
+      review: true,
+      mergedPlan: true,
+      bashExitOneLog: true,
+    });
+    assert.equal(context.bashExitOne.count, 2);
+    assert.deepEqual(context.bashExitOne.commands, ["npm run test:coverage", "npm test"]);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("dev-mode-context writes collected context to disk", async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dev-loop-dev-mode-write-"));
+  const outputPath = path.join(tempDir, "dev-mode-context.json");
+
+  try {
+    await writeDevModeContext(outputPath, { phase: "phase-1", ok: true });
+    const written = JSON.parse(await readFile(outputPath, "utf8"));
+    assert.deepEqual(written, { phase: "phase-1", ok: true });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("dev-mode-context parses cli args", () => {
+  assert.deepEqual(parseCliArgs(["--project-root", "/repo", "--phase", "phase-4", "--output", "tmp/x.json"]), {
+    projectRoot: "/repo",
+    phase: "phase-4",
+    output: "tmp/x.json",
+  });
+});
+
+test("dev-mode-context requires phase arg", () => {
+  assert.throws(() => parseCliArgs(["--output", "tmp/x.json"]), /missing required --phase/i);
+});

package/skills/dev-loop/scripts/init-phase.mjs

@@ -0,0 +1,71 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { ensurePhaseFiles, parseCliArgs as parsePhaseFileArgs } from "./phase-files.mjs";
+import { materializeTemplate } from "./render-template.mjs";
+
+export const DEFAULT_PHASE_ARTIFACTS = [
+  "manifest.json",
+  "variant-a.md",
+  "variant-b.md",
+  "merged-plan.md",
+  "review.md",
+];
+
+export function parseCliArgs(argv) {
+  return parsePhaseFileArgs(argv);
+}
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const skillRoot = path.resolve(scriptDir, "..");
+const templateRoot = path.join(skillRoot, "templates");
+
+export async function initializePhase(projectRoot, phase, patch = {}) {
+  const phasePlanArtifact = path.relative(
+    path.join(projectRoot, "tmp", "phases", phase),
+    path.join(projectRoot, "docs", "phases", `${phase}.md`),
+  );
+
+  const nextPatch = {
+    ...patch,
+    artifacts: [...(patch.artifacts ?? []), ...DEFAULT_PHASE_ARTIFACTS, phasePlanArtifact],
+  };
+
+  const result = await ensurePhaseFiles(projectRoot, phase, nextPatch);
+
+  const outputs = [
+    ["phase-doc.md", result.paths.phasePlanPath, { phase }],
+    ["phase-variant.md", path.join(result.paths.phaseDir, "variant-a.md"), { phase, variant: "a" }],
+    ["phase-variant.md", path.join(result.paths.phaseDir, "variant-b.md"), { phase, variant: "b" }],
+    ["merged-phase-plan.md", path.join(result.paths.phaseDir, "merged-plan.md"), { phase }],
+    ["review.md", path.join(result.paths.phaseDir, "review.md"), { phase }],
+  ];
+
+  for (const [templateName, outputPath, variables] of outputs) {
+    await materializeTemplate(path.join(templateRoot, templateName), outputPath, variables);
+  }
+
+  return {
+    ...result,
+    generated: outputs.map(([, outputPath]) => path.relative(projectRoot, outputPath)),
+  };
+}
+
+export async function runCli(argv = process.argv.slice(2)) {
+  const options = parseCliArgs(argv);
+  const result = await initializePhase(options.projectRoot, options.phase, options.patch);
+  process.stdout.write(
+    `${JSON.stringify({ ok: true, phase: result.paths.phase, generated: result.generated })}\n`,
+  );
+}
+
+const invokedAsScript = process.argv[1]
+  ? import.meta.url === pathToFileURL(process.argv[1]).href
+  : false;
+
+if (invokedAsScript) {
+  runCli().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/skills/dev-loop/scripts/log-bash-exit-1.mjs

@@ -0,0 +1,25 @@
+import { pathToFileURL } from "node:url";
+
+export {
+  DEFAULT_OUTPUT_LIMIT,
+  appendBashExitOneRecord,
+  formatBashExitOneRecord,
+  normalizeBashExitOneRecord,
+  parseCliArgs,
+  readRecordFromStdin,
+  runCli,
+  truncateText,
+} from "../../../packages/core/src/bash-exit-one.mjs";
+
+import { runCli } from "../../../packages/core/src/bash-exit-one.mjs";
+
+const invokedAsScript = process.argv[1]
+  ? import.meta.url === pathToFileURL(process.argv[1]).href
+  : false;
+
+if (invokedAsScript) {
+  runCli().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/skills/dev-loop/scripts/phase-files.mjs

@@ -0,0 +1,29 @@
+import { pathToFileURL } from "node:url";
+
+export {
+  applyManifestPatch,
+  buildPhasePaths,
+  createDefaultPhaseIndex,
+  createDefaultPhaseManifest,
+  ensurePhaseFiles,
+  normalizePhaseName,
+  parseCliArgs,
+  readJsonIfExists,
+  runCli,
+  uniqueSortedStrings,
+  upsertPhaseIndex,
+  writeJson,
+} from "../../../packages/core/src/loop/phase-files.mjs";
+
+import { runCli } from "../../../packages/core/src/loop/phase-files.mjs";
+
+const invokedAsScript = process.argv[1]
+  ? import.meta.url === pathToFileURL(process.argv[1]).href
+  : false;
+
+if (invokedAsScript) {
+  runCli().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}