takt-marp 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takt-marp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "takt-marp",
   "repository": {
     "type": "git",

package/scripts/lib/takt-marp-cli.mjs

@@ -6,11 +6,16 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 import { initializeProject } from "./takt-marp-project-init.mjs";
 import { packageScriptPath } from "./takt-marp-runtime-context.mjs";
-import { formatError, SlideWorkflowError } from "./takt-marp-slide-workflow.mjs";
+import {
+  APPROVAL_COMMANDS,
+  formatError,
+  SlideWorkflowError,
+} from "./takt-marp-slide-workflow.mjs";
 
 const WORKFLOW_COMMANDS = ["plan", "compose", "polish", "deliver"];
-const VALID_COMMANDS = ["init", ...WORKFLOW_COMMANDS, "smoke"];
+const VALID_COMMANDS = ["init", ...WORKFLOW_COMMANDS, "approve", "smoke"];
 const RUNNER_SCRIPT = "scripts/takt-marp-run-slide-workflow.mjs";
+const APPROVE_SCRIPT = "scripts/takt-marp-approve-slide-workflow-state.mjs";
 const SMOKE_SCRIPT = "scripts/takt-marp-validate-slide-workflow-smoke.mjs";
 const REQUIRED_PROJECT_DIRS = [".takt/workflows", ".takt/facets"];
 
@@ -24,6 +29,8 @@ function usage() {
     "  compose <slides/deck> [options]   Run the compose workflow for a deck in the current project",
     "  polish <slides/deck> [options]    Run the polish workflow for a deck in the current project",
     "  deliver <slides/deck> [options]   Run the deliver workflow for a deck in the current project",
+    "  approve <slides/deck> <command> --by <name> [--force]",
+    "                                    Approve a workflow state (command: plan or compose)",
     "  smoke [--provider <name>]         Run smoke validation in a temporary project (default provider: mock)",
     "",
     "Workflow options (passed through to the workflow runner unchanged):",
@@ -171,6 +178,62 @@ async function runSmoke(args) {
   return exitCode;
 }
 
+function approveUsage() {
+  return [
+    "Usage: takt-marp approve <slides/deck> <command> --by <name> [--force]",
+    "",
+    `Commands: ${APPROVAL_COMMANDS.join(", ")}`,
+    "",
+    "Options:",
+    "  --by <name>   Approver identifier (required)",
+    "  --force       Overwrite an existing approval",
+    "  --help, -h    Show this message",
+  ].join("\n");
+}
+
+async function runApprove(args) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args,
+      allowPositionals: true,
+      options: {
+        by: { type: "string" },
+        force: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false },
+      },
+    });
+  } catch (error) {
+    throw new SlideWorkflowError(
+      `Invalid approve arguments: ${error.message}. Run 'takt-marp approve --help' for usage.`,
+      "INVALID_ARGS",
+    );
+  }
+  if (parsed.values.help) {
+    console.log(approveUsage());
+    return 0;
+  }
+  assertProjectInitialized();
+  if (parsed.positionals.length !== 2) {
+    throw new SlideWorkflowError(
+      `Expected <slides/deck> and <command>. Run 'takt-marp approve --help' for usage.`,
+      "INVALID_ARGS",
+    );
+  }
+  const [target, command] = parsed.positionals;
+  if (!parsed.values.by) {
+    throw new SlideWorkflowError(
+      `Missing required --by <name>. Run 'takt-marp approve --help' for usage.`,
+      "INVALID_ARGS",
+    );
+  }
+  const approveArgs = [target, command, "--by", parsed.values.by];
+  if (parsed.values.force) {
+    approveArgs.push("--force");
+  }
+  return runPackageScript(APPROVE_SCRIPT, approveArgs);
+}
+
 export async function runCli(argv) {
   const [command, ...rest] = argv;
   if (command === undefined || command === "--help" || command === "-h" || command === "help") {
@@ -188,6 +251,9 @@ export async function runCli(argv) {
     if (command === "init") {
       return await runInit(rest);
     }
+    if (command === "approve") {
+      return await runApprove(rest);
+    }
     if (command === "smoke") {
       return await runSmoke(rest);
     }

package/scripts/takt-marp-validate-slide-workflow-foundation.mjs

@@ -20,6 +20,7 @@ import {
   supervisionPath,
   writeApproval,
 } from "./lib/takt-marp-slide-workflow.mjs";
+import { runCli } from "./lib/takt-marp-cli.mjs";
 
 const checks = [];
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -306,6 +307,47 @@ async function main() {
     assert(verifyResult.stdout.includes("skipped for non-successful verify report"), `verify verifier did not report skip: ${verifyResult.stdout}`);
   });
 
+  await check("approve command shows help without initialized project", async () => {
+    const root = await fixtureRoot();
+    const originalCwd = process.cwd();
+    let output;
+    try {
+      process.chdir(root);
+      output = await captureStdout(() => runCli(["approve", "--help"]));
+    } finally {
+      process.chdir(originalCwd);
+    }
+    assert(output.includes("Usage: takt-marp approve"), `approve help missing usage: ${output}`);
+  });
+
+  await check("approve command requires initialized project", async () => {
+    const root = await fixtureRoot();
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(root);
+      const code = await runCli(["approve", "slides/demo", "plan", "--by", "foundation-test"]);
+      assert(code !== 0, "approve unexpectedly succeeded in uninitialized project");
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  await check("approve command writes approval file", async () => {
+    const root = await initializedFixtureRoot();
+    const targetInfo = await makeDeck(root, "demo");
+    await writeSupervision(targetInfo, "plan", "planned", "passed", "run-plan-1");
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(root);
+      const code = await runCli(["approve", targetInfo.target, "plan", "--by", "foundation-test"]);
+      assert(code === 0, `approve command failed: check stderr`);
+    } finally {
+      process.chdir(originalCwd);
+    }
+    const approval = await readFile(path.join(targetInfo.reviewPath, "plan-approval.md"), "utf8");
+    assert(approval.includes("approved_by: foundation-test"), `approval file missing approver: ${approval}`);
+  });
+
   await check("package scripts expose canonical entrypoints only", async () => {
     const pkg = JSON.parse(await readFile(path.join(process.cwd(), "package.json"), "utf8"));
     const scripts = pkg.scripts ?? {};
@@ -348,6 +390,32 @@ async function fixtureRoot() {
   return root;
 }
 
+async function initializedFixtureRoot() {
+  const root = await fixtureRoot();
+  await mkdir(path.join(root, ".takt", "facets"), { recursive: true });
+  return root;
+}
+
+async function captureStdout(fn) {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const chunks = [];
+  process.stdout.write = (chunk, encoding, callback) => {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+    if (typeof encoding === "function") {
+      encoding();
+    } else if (typeof callback === "function") {
+      callback();
+    }
+    return true;
+  };
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+  return chunks.join("");
+}
+
 async function makeDeck(root, deckName) {
   const deckPath = path.join(root, "slides", deckName);
   await mkdir(path.join(deckPath, "review"), { recursive: true });