@sduck/sduck-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1149 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { checkbox } from "@inquirer/prompts";
+
+// src/core/agent-rules.ts
+import { readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/fs.ts
+import { constants } from "fs";
+import { access, copyFile, mkdir, stat } from "fs/promises";
+async function getFsEntryKind(targetPath) {
+  try {
+    const stats = await stat(targetPath);
+    if (stats.isDirectory()) {
+      return "directory";
+    }
+    if (stats.isFile()) {
+      return "file";
+    }
+    return "file";
+  } catch {
+    return "missing";
+  }
+}
+async function ensureDirectory(targetPath) {
+  await mkdir(targetPath, { recursive: true });
+}
+async function ensureReadableFile(targetPath) {
+  await access(targetPath, constants.R_OK);
+}
+async function copyFileIntoPlace(sourcePath, targetPath) {
+  await copyFile(sourcePath, targetPath);
+}
+
+// src/core/agent-rules.ts
+var SDD_RULES_BEGIN = "<!-- sduck:begin -->";
+var SDD_RULES_END = "<!-- sduck:end -->";
+var SUPPORTED_AGENTS = [
+  { id: "claude-code", label: "Claude Code" },
+  { id: "codex", label: "Codex" },
+  { id: "opencode", label: "OpenCode" },
+  { id: "gemini-cli", label: "Gemini CLI" },
+  { id: "cursor", label: "Cursor" },
+  { id: "antigravity", label: "Antigravity" }
+];
+var AGENT_RULE_TARGETS = [
+  { agentId: "claude-code", outputPath: "CLAUDE.md", kind: "root-file" },
+  { agentId: "codex", outputPath: "AGENTS.md", kind: "root-file" },
+  { agentId: "opencode", outputPath: "AGENTS.md", kind: "root-file" },
+  { agentId: "gemini-cli", outputPath: "GEMINI.md", kind: "root-file" },
+  {
+    agentId: "cursor",
+    outputPath: join(".cursor", "rules", "sduck-core.mdc"),
+    kind: "managed-file"
+  },
+  {
+    agentId: "antigravity",
+    outputPath: join(".agents", "rules", "sduck-core.md"),
+    kind: "managed-file"
+  }
+];
+var AGENT_TEMPLATE_FILES = {
+  "claude-code": "claude-code.md",
+  codex: "codex.md",
+  opencode: "opencode.md",
+  "gemini-cli": "gemini-cli.md",
+  cursor: "cursor.mdc",
+  antigravity: "antigravity.md"
+};
+function unique(values) {
+  return [...new Set(values)];
+}
+function parseAgentsOption(rawAgents) {
+  if (rawAgents === void 0 || rawAgents.trim() === "") {
+    return [];
+  }
+  const requestedAgents = unique(
+    rawAgents.split(",").map((value) => value.trim()).filter((value) => value !== "")
+  );
+  const validAgents = new Set(SUPPORTED_AGENTS.map((agent) => agent.id));
+  const invalidAgent = requestedAgents.find((agent) => !validAgents.has(agent));
+  if (invalidAgent !== void 0) {
+    throw new Error(`Unsupported agent: ${invalidAgent}`);
+  }
+  return requestedAgents;
+}
+function listAgentRuleTargets(selectedAgents) {
+  const selectedAgentSet = new Set(selectedAgents);
+  return AGENT_RULE_TARGETS.filter((target) => selectedAgentSet.has(target.agentId)).filter(
+    (target, index, allTargets) => index === allTargets.findIndex((candidate) => candidate.outputPath === target.outputPath)
+  );
+}
+function hasManagedBlock(content) {
+  return content.includes(SDD_RULES_BEGIN) && content.includes(SDD_RULES_END);
+}
+function prependManagedBlock(existingContent, blockContent) {
+  const normalizedExistingContent = existingContent.trimStart();
+  if (normalizedExistingContent === "") {
+    return `${blockContent}
+`;
+  }
+  return `${blockContent}
+
+${normalizedExistingContent}`;
+}
+function replaceManagedBlock(existingContent, blockContent) {
+  const blockPattern = new RegExp(`${SDD_RULES_BEGIN}[\\s\\S]*?${SDD_RULES_END}`);
+  if (!blockPattern.test(existingContent)) {
+    return prependManagedBlock(existingContent, blockContent);
+  }
+  return existingContent.replace(blockPattern, blockContent);
+}
+function renderManagedBlock(lines) {
+  return [SDD_RULES_BEGIN, ...lines, SDD_RULES_END].join("\n");
+}
+async function getAgentRulesAssetRoot() {
+  const currentDirectoryPath = dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    join(currentDirectoryPath, "..", "..", "sduck-assets", "agent-rules"),
+    join(currentDirectoryPath, "..", "sduck-assets", "agent-rules")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (await getFsEntryKind(candidatePath) === "directory") {
+      return candidatePath;
+    }
+  }
+  throw new Error("Unable to locate bundled sduck agent rule assets.");
+}
+async function readAssetFile(assetRoot, fileName) {
+  return await readFile(join(assetRoot, fileName), "utf8");
+}
+function buildRootFileLines(agentIds, agentSpecificContent) {
+  const labels = SUPPORTED_AGENTS.filter((agent) => agentIds.includes(agent.id)).map(
+    (agent) => agent.label
+  );
+  return [
+    "# sduck managed rules",
+    "",
+    `Selected agents: ${labels.join(", ")}`,
+    "",
+    ...agentSpecificContent
+  ];
+}
+async function renderAgentRuleContent(target, selectedAgents) {
+  const assetRoot = await getAgentRulesAssetRoot();
+  const coreContent = await readAssetFile(assetRoot, "core.md");
+  if (target.kind === "managed-file") {
+    const templateFileName = AGENT_TEMPLATE_FILES[target.agentId];
+    const specificContent = await readAssetFile(assetRoot, templateFileName);
+    return `${specificContent.trim()}
+
+${coreContent.trim()}
+`;
+  }
+  const relatedAgents = AGENT_RULE_TARGETS.filter(
+    (candidate) => candidate.outputPath === target.outputPath && selectedAgents.includes(candidate.agentId)
+  ).map((candidate) => candidate.agentId);
+  const specificSections = [];
+  for (const agentId of relatedAgents) {
+    const templateFileName = AGENT_TEMPLATE_FILES[agentId];
+    specificSections.push((await readAssetFile(assetRoot, templateFileName)).trim());
+  }
+  const lines = buildRootFileLines(relatedAgents, [...specificSections, coreContent.trim()]);
+  return `${renderManagedBlock(lines)}
+`;
+}
+function planAgentRuleActions(mode, targets, existingEntries, existingContents) {
+  return targets.map((target) => {
+    const currentKind = existingEntries.get(target.outputPath) ?? "missing";
+    if (currentKind === "missing") {
+      return { ...target, mergeMode: "create", currentKind };
+    }
+    if (currentKind !== "file") {
+      return { ...target, mergeMode: "overwrite", currentKind };
+    }
+    if (target.kind === "managed-file") {
+      return { ...target, mergeMode: mode === "force" ? "overwrite" : "keep", currentKind };
+    }
+    const content = existingContents.get(target.outputPath) ?? "";
+    if (mode === "safe") {
+      return { ...target, mergeMode: hasManagedBlock(content) ? "keep" : "prepend", currentKind };
+    }
+    return {
+      ...target,
+      mergeMode: hasManagedBlock(content) ? "replace-block" : "prepend",
+      currentKind
+    };
+  });
+}
+
+// src/core/init.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/core/assets.ts
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var SUPPORTED_TASK_TYPES = [
+  "build",
+  "feature",
+  "fix",
+  "refactor",
+  "chore"
+];
+var EVAL_ASSET_RELATIVE_PATHS = {
+  plan: join2("eval", "plan.yml"),
+  spec: join2("eval", "spec.yml")
+};
+var SPEC_TEMPLATE_RELATIVE_PATHS = {
+  build: join2("types", "build.md"),
+  feature: join2("types", "feature.md"),
+  fix: join2("types", "fix.md"),
+  refactor: join2("types", "refactor.md"),
+  chore: join2("types", "chore.md")
+};
+var INIT_ASSET_RELATIVE_PATHS = [
+  EVAL_ASSET_RELATIVE_PATHS.spec,
+  EVAL_ASSET_RELATIVE_PATHS.plan,
+  ...Object.values(SPEC_TEMPLATE_RELATIVE_PATHS)
+];
+async function getBundledAssetsRoot() {
+  const currentDirectoryPath = dirname2(fileURLToPath2(import.meta.url));
+  const candidatePaths = [
+    join2(currentDirectoryPath, "..", "..", "sduck-assets"),
+    join2(currentDirectoryPath, "..", "sduck-assets")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (await getFsEntryKind(candidatePath) === "directory") {
+      return candidatePath;
+    }
+  }
+  throw new Error("Unable to locate bundled sduck-assets directory.");
+}
+function isSupportedTaskType(value) {
+  return SUPPORTED_TASK_TYPES.includes(value);
+}
+function resolveSpecTemplateRelativePath(type) {
+  return SPEC_TEMPLATE_RELATIVE_PATHS[type];
+}
+
+// src/core/init.ts
+var ASSET_TEMPLATE_DEFINITIONS = [
+  {
+    key: "eval-spec",
+    relativePath: join3("sduck-assets", EVAL_ASSET_RELATIVE_PATHS.spec)
+  },
+  {
+    key: "eval-plan",
+    relativePath: join3("sduck-assets", EVAL_ASSET_RELATIVE_PATHS.plan)
+  },
+  {
+    key: "type-build",
+    relativePath: join3("sduck-assets", "types", "build.md")
+  },
+  {
+    key: "type-feature",
+    relativePath: join3("sduck-assets", "types", "feature.md")
+  },
+  { key: "type-fix", relativePath: join3("sduck-assets", "types", "fix.md") },
+  {
+    key: "type-refactor",
+    relativePath: join3("sduck-assets", "types", "refactor.md")
+  },
+  {
+    key: "type-chore",
+    relativePath: join3("sduck-assets", "types", "chore.md")
+  }
+];
+var ASSET_TEMPLATE_MAP = Object.fromEntries(
+  ASSET_TEMPLATE_DEFINITIONS.map((definition) => [definition.key, definition])
+);
+function planInitActions(mode, existingEntries) {
+  return ASSET_TEMPLATE_DEFINITIONS.map((definition) => {
+    const currentKind = existingEntries.get(definition.relativePath) ?? "missing";
+    if (currentKind === "missing") {
+      return {
+        key: definition.key,
+        targetPath: definition.relativePath,
+        currentKind,
+        action: "create",
+        collision: "none"
+      };
+    }
+    if (currentKind === "file") {
+      return {
+        key: definition.key,
+        targetPath: definition.relativePath,
+        currentKind,
+        action: mode === "force" ? "overwrite" : "keep",
+        collision: "none"
+      };
+    }
+    return {
+      key: definition.key,
+      targetPath: definition.relativePath,
+      currentKind,
+      action: "error",
+      collision: "directory-file-mismatch"
+    };
+  });
+}
+function summarizeInitActions(actions) {
+  const summary = {
+    created: [],
+    prepended: [],
+    kept: [],
+    overwritten: [],
+    warnings: [],
+    errors: [],
+    rows: []
+  };
+  for (const action of actions) {
+    if (action.action === "create") {
+      summary.created.push(action.targetPath);
+      summary.rows.push({ path: action.targetPath, status: "created" });
+      continue;
+    }
+    if (action.action === "keep") {
+      summary.kept.push(action.targetPath);
+      summary.rows.push({ path: action.targetPath, status: "kept" });
+      summary.warnings.push(`Kept existing asset: ${action.targetPath}`);
+      continue;
+    }
+    if (action.action === "overwrite") {
+      summary.overwritten.push(action.targetPath);
+      summary.rows.push({ path: action.targetPath, status: "overwritten" });
+      continue;
+    }
+    summary.errors.push(`Path conflict for ${action.targetPath}: ${action.collision}`);
+  }
+  if (summary.kept.length > 0) {
+    summary.warnings.push("Run `sduck init --force` if you want to regenerate bundled assets.");
+  }
+  return summary;
+}
+function getInitMode(options) {
+  return options.force ? "force" : "safe";
+}
+function resolveInitOptions(options) {
+  return {
+    mode: getInitMode(options),
+    agents: [...new Set(options.agents)]
+  };
+}
+async function collectExistingEntries(projectRoot) {
+  const existingEntries = /* @__PURE__ */ new Map();
+  for (const definition of ASSET_TEMPLATE_DEFINITIONS) {
+    existingEntries.set(
+      definition.relativePath,
+      await getFsEntryKind(join3(projectRoot, definition.relativePath))
+    );
+  }
+  return existingEntries;
+}
+async function collectExistingFileContents(projectRoot, targets) {
+  const contents = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const targetPath = join3(projectRoot, target.outputPath);
+    if (await getFsEntryKind(targetPath) === "file") {
+      contents.set(target.outputPath, await readFile2(targetPath, "utf8"));
+    }
+  }
+  return contents;
+}
+async function ensureRootDirectory(targetPath, errorCode) {
+  const kind = await getFsEntryKind(targetPath);
+  if (kind === "missing") {
+    await ensureDirectory(targetPath);
+    return "created";
+  }
+  if (kind === "directory") {
+    return "kept";
+  }
+  throw new Error(`${errorCode}: expected a directory at ${targetPath}.`);
+}
+async function initProject(options, projectRoot) {
+  const resolvedOptions = resolveInitOptions(options);
+  const { mode } = resolvedOptions;
+  const assetSourceRoot = await getBundledAssetsRoot();
+  const assetsRoot = join3(projectRoot, "sduck-assets");
+  const workspaceRoot = join3(projectRoot, "sduck-workspace");
+  const summary = {
+    created: [],
+    prepended: [],
+    kept: [],
+    overwritten: [],
+    warnings: [],
+    errors: [],
+    rows: []
+  };
+  const assetsRootStatus = await ensureRootDirectory(assetsRoot, "asset-root-conflict");
+  summary[assetsRootStatus].push("sduck-assets/");
+  summary.rows.push({ path: "sduck-assets/", status: assetsRootStatus });
+  const workspaceRootStatus = await ensureRootDirectory(workspaceRoot, "workspace-root-conflict");
+  summary[workspaceRootStatus].push("sduck-workspace/");
+  summary.rows.push({ path: "sduck-workspace/", status: workspaceRootStatus });
+  const actions = planInitActions(mode, await collectExistingEntries(projectRoot));
+  const actionSummary = summarizeInitActions(actions);
+  summary.created.push(...actionSummary.created);
+  summary.kept.push(...actionSummary.kept);
+  summary.overwritten.push(...actionSummary.overwritten);
+  summary.warnings.push(...actionSummary.warnings);
+  summary.errors.push(...actionSummary.errors);
+  summary.rows.push(...actionSummary.rows);
+  const conflict = actions.find((action) => action.action === "error");
+  if (conflict !== void 0) {
+    throw new Error(
+      `type-conflict: expected a file but found a directory at ${conflict.targetPath}. Resolve it manually or move the conflicting path before retrying.`
+    );
+  }
+  for (const action of actions) {
+    if (action.action === "keep") {
+      continue;
+    }
+    const definition = ASSET_TEMPLATE_MAP[action.key];
+    const sourcePath = join3(
+      assetSourceRoot,
+      definition.relativePath.replace(/^sduck-assets[\\/]/, "")
+    );
+    const targetPath = join3(projectRoot, definition.relativePath);
+    await ensureReadableFile(sourcePath);
+    await mkdir2(dirname3(targetPath), { recursive: true });
+    await copyFileIntoPlace(sourcePath, targetPath);
+  }
+  const agentTargets = listAgentRuleTargets(resolvedOptions.agents);
+  const agentEntryKinds = /* @__PURE__ */ new Map();
+  for (const target of agentTargets) {
+    agentEntryKinds.set(
+      target.outputPath,
+      await getFsEntryKind(join3(projectRoot, target.outputPath))
+    );
+  }
+  const existingContents = await collectExistingFileContents(projectRoot, agentTargets);
+  const agentActions = planAgentRuleActions(mode, agentTargets, agentEntryKinds, existingContents);
+  await applyAgentRuleActions(
+    projectRoot,
+    agentActions,
+    existingContents,
+    summary,
+    resolvedOptions.agents
+  );
+  return {
+    mode,
+    agents: resolvedOptions.agents,
+    summary,
+    didChange: summary.created.length > 0 || summary.prepended.length > 0 || summary.overwritten.length > 0
+  };
+}
+async function applyAgentRuleActions(projectRoot, actions, existingContents, summary, selectedAgents) {
+  for (const action of actions) {
+    const targetPath = join3(projectRoot, action.outputPath);
+    const content = await renderAgentRuleContent(action, selectedAgents);
+    if (action.mergeMode === "create") {
+      await mkdir2(dirname3(targetPath), { recursive: true });
+      await writeFile(targetPath, content, "utf8");
+      summary.created.push(action.outputPath);
+      summary.rows.push({ path: action.outputPath, status: "created" });
+      continue;
+    }
+    if (action.mergeMode === "keep") {
+      summary.kept.push(action.outputPath);
+      summary.rows.push({ path: action.outputPath, status: "kept" });
+      summary.warnings.push(`Kept existing rule file: ${action.outputPath}`);
+      continue;
+    }
+    await mkdir2(dirname3(targetPath), { recursive: true });
+    if (action.mergeMode === "prepend") {
+      const currentContent = existingContents.get(action.outputPath) ?? "";
+      await writeFile(targetPath, prependManagedBlock(currentContent, content.trimEnd()), "utf8");
+      summary.prepended.push(action.outputPath);
+      summary.rows.push({ path: action.outputPath, status: "prepended" });
+      continue;
+    }
+    if (action.mergeMode === "replace-block") {
+      const currentContent = existingContents.get(action.outputPath) ?? "";
+      await writeFile(targetPath, replaceManagedBlock(currentContent, content.trimEnd()), "utf8");
+      summary.overwritten.push(action.outputPath);
+      summary.rows.push({ path: action.outputPath, status: "overwritten" });
+      continue;
+    }
+    await writeFile(targetPath, content, "utf8");
+    summary.overwritten.push(action.outputPath);
+    summary.rows.push({ path: action.outputPath, status: "overwritten" });
+  }
+  if (summary.kept.some((path) => path.endsWith(".md") || path.endsWith(".mdc"))) {
+    summary.warnings.push(
+      "Run `sduck init --force` to refresh managed rule content for selected agents."
+    );
+  }
+}
+
+// src/commands/init.ts
+function padCell(value, width) {
+  return value.padEnd(width, " ");
+}
+function buildSummaryTable(rows) {
+  const statusWidth = Math.max("Status".length, ...rows.map((row) => row.status.length));
+  const pathWidth = Math.max("Path".length, ...rows.map((row) => row.path.length));
+  const border = `+-${"-".repeat(statusWidth)}-+-${"-".repeat(pathWidth)}-+`;
+  const header = `| ${padCell("Status", statusWidth)} | ${padCell("Path", pathWidth)} |`;
+  const body = rows.map(
+    (row) => `| ${padCell(row.status, statusWidth)} | ${padCell(row.path, pathWidth)} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
+}
+function formatResult(result) {
+  const lines = [
+    result.didChange ? "sduck init completed." : "sduck init completed with no file changes."
+  ];
+  if (result.agents.length > 0) {
+    lines.push(`Selected agents: ${result.agents.join(", ")}`);
+  }
+  lines.push("", buildSummaryTable(result.summary.rows));
+  if (result.summary.warnings.length > 0) {
+    lines.push("", "Warnings:");
+    lines.push(...result.summary.warnings.map((warning) => `- ${warning}`));
+  }
+  return lines.join("\n");
+}
+async function resolveSelectedAgents(options) {
+  const parsedAgents = parseAgentsOption(options.agents);
+  if (parsedAgents.length > 0 || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return parsedAgents;
+  }
+  return await checkbox({
+    message: "Select AI agents to generate repository rule files for",
+    choices: SUPPORTED_AGENTS.map((agent) => ({
+      name: agent.label,
+      value: agent.id
+    }))
+  });
+}
+async function runInitCommand(options, projectRoot) {
+  try {
+    const resolvedOptions = {
+      force: options.force,
+      agents: await resolveSelectedAgents(options)
+    };
+    const result = await initProject(resolvedOptions, projectRoot);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: formatResult(result)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown init failure.";
+    return {
+      exitCode: 1,
+      stderr: message,
+      stdout: ""
+    };
+  }
+}
+
+// src/commands/plan-approve.ts
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+
+// src/core/plan-approve.ts
+import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/core/workspace.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["IN_PROGRESS", "PENDING_SPEC_APPROVAL", "PENDING_PLAN_APPROVAL"]);
+function parseMetaText(content) {
+  const createdAtMatch = /^created_at:\s+(.+)$/m.exec(content);
+  const idMatch = /^id:\s+(.+)$/m.exec(content);
+  const slugMatch = /^slug:\s+(.+)$/m.exec(content);
+  const statusMatch = /^status:\s+(.+)$/m.exec(content);
+  const parsedMeta = {};
+  if (createdAtMatch?.[1] !== void 0) {
+    parsedMeta.createdAt = createdAtMatch[1].trim();
+  }
+  if (idMatch?.[1] !== void 0) {
+    parsedMeta.id = idMatch[1].trim();
+  }
+  if (slugMatch?.[1] !== void 0) {
+    parsedMeta.slug = slugMatch[1].trim();
+  }
+  if (statusMatch?.[1] !== void 0) {
+    parsedMeta.status = statusMatch[1].trim();
+  }
+  return parsedMeta;
+}
+function sortTasksByRecency(tasks) {
+  return [...tasks].sort((left, right) => {
+    const leftValue = left.createdAt ?? "";
+    const rightValue = right.createdAt ?? "";
+    return rightValue.localeCompare(leftValue);
+  });
+}
+async function listWorkspaceTasks(projectRoot) {
+  const workspaceRoot = join4(projectRoot, "sduck-workspace");
+  if (await getFsEntryKind(workspaceRoot) !== "directory") {
+    return [];
+  }
+  const { readdir } = await import("fs/promises");
+  const entries = await readdir(workspaceRoot, { withFileTypes: true });
+  const tasks = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const relativePath = join4("sduck-workspace", entry.name);
+    const metaPath = join4(projectRoot, relativePath, "meta.yml");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      continue;
+    }
+    const parsedMeta = parseMetaText(await readFile3(metaPath, "utf8"));
+    if (parsedMeta.id !== void 0 && parsedMeta.status !== void 0) {
+      const task = {
+        id: parsedMeta.id,
+        path: relativePath,
+        status: parsedMeta.status
+      };
+      if (parsedMeta.createdAt !== void 0) {
+        task.createdAt = parsedMeta.createdAt;
+      }
+      if (parsedMeta.slug !== void 0) {
+        task.slug = parsedMeta.slug;
+      }
+      tasks.push(task);
+    }
+  }
+  return sortTasksByRecency(tasks);
+}
+async function findActiveTask(projectRoot) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  for (const task of tasks) {
+    if (ACTIVE_STATUSES.has(task.status)) {
+      return {
+        id: task.id,
+        path: task.path,
+        status: task.status
+      };
+    }
+  }
+  return null;
+}
+
+// src/utils/utc-date.ts
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function formatUtcDate(date) {
+  const year = String(date.getUTCFullYear());
+  const month = pad2(date.getUTCMonth() + 1);
+  const day = pad2(date.getUTCDate());
+  return `${year}-${month}-${day}`;
+}
+function formatUtcTimestamp(date) {
+  const year = String(date.getUTCFullYear());
+  const month = pad2(date.getUTCMonth() + 1);
+  const day = pad2(date.getUTCDate());
+  const hour = pad2(date.getUTCHours());
+  const minute = pad2(date.getUTCMinutes());
+  const second = pad2(date.getUTCSeconds());
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`;
+}
+
+// src/core/plan-approve.ts
+function filterPlanApprovalCandidates(tasks) {
+  return tasks.filter((task) => task.status === "SPEC_APPROVED");
+}
+function resolvePlanApprovalCandidates(tasks, target) {
+  const candidates = filterPlanApprovalCandidates(tasks);
+  if (target === void 0 || target.trim() === "") {
+    return candidates;
+  }
+  const trimmedTarget = target.trim();
+  return candidates.filter(
+    (task) => task.id === trimmedTarget || task.slug === trimmedTarget || task.id.endsWith(trimmedTarget)
+  );
+}
+function countPlanSteps(planContent) {
+  const matches = planContent.match(/^## Step \d+\. .+$/gm);
+  return matches?.length ?? 0;
+}
+function updatePlanApprovalBlock(metaContent, approvedAt, totalSteps) {
+  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: IN_PROGRESS");
+  const withPlan = withStatus.replace(
+    /plan:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
+    `plan:
+  approved: true
+  approved_at: ${approvedAt}`
+  );
+  return withPlan.replace(
+    /steps:\n {2}total:\s+null\n {2}completed:\s+\[\]/m,
+    `steps:
+  total: ${String(totalSteps)}
+  completed: []`
+  );
+}
+async function approvePlans(projectRoot, tasks, approvedAt) {
+  const succeeded = [];
+  const failed = [];
+  for (const task of tasks) {
+    if (task.status !== "SPEC_APPROVED") {
+      failed.push({
+        note: `task is not awaiting plan approval (${task.status})`,
+        taskId: task.id
+      });
+      continue;
+    }
+    const metaPath = join5(projectRoot, task.path, "meta.yml");
+    const planPath = join5(projectRoot, task.path, "plan.md");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      failed.push({ note: "missing meta.yml", taskId: task.id });
+      continue;
+    }
+    if (await getFsEntryKind(planPath) !== "file") {
+      failed.push({ note: "missing plan.md", taskId: task.id });
+      continue;
+    }
+    const planContent = await readFile4(planPath, "utf8");
+    const totalSteps = countPlanSteps(planContent);
+    if (totalSteps === 0) {
+      failed.push({ note: "missing valid Step headers", taskId: task.id });
+      continue;
+    }
+    const updatedMeta = updatePlanApprovalBlock(
+      await readFile4(metaPath, "utf8"),
+      approvedAt,
+      totalSteps
+    );
+    await writeFile2(metaPath, updatedMeta, "utf8");
+    succeeded.push({ note: "moved to IN_PROGRESS", steps: totalSteps, taskId: task.id });
+  }
+  return {
+    approvedAt,
+    failed,
+    nextStatus: "IN_PROGRESS",
+    succeeded
+  };
+}
+async function loadPlanApprovalCandidates(projectRoot, input) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  return resolvePlanApprovalCandidates(tasks, input.target);
+}
+function createPlanApprovedAt(date = /* @__PURE__ */ new Date()) {
+  return formatUtcTimestamp(date);
+}
+
+// src/commands/plan-approve.ts
+function padCell2(value, width) {
+  return value.padEnd(width, " ");
+}
+function buildResultTable(result) {
+  const rows = [
+    ...result.succeeded.map((row) => ({
+      note: row.note,
+      result: "success",
+      steps: String(row.steps),
+      task: row.taskId
+    })),
+    ...result.failed.map((row) => ({
+      note: row.note,
+      result: "failed",
+      steps: "-",
+      task: row.taskId
+    }))
+  ];
+  const resultWidth = Math.max("Result".length, ...rows.map((row) => row.result.length));
+  const taskWidth = Math.max("Task".length, ...rows.map((row) => row.task.length));
+  const stepsWidth = Math.max("Steps".length, ...rows.map((row) => row.steps.length));
+  const noteWidth = Math.max("Note".length, ...rows.map((row) => row.note.length));
+  const border = `+-${"-".repeat(resultWidth)}-+-${"-".repeat(taskWidth)}-+-${"-".repeat(stepsWidth)}-+-${"-".repeat(noteWidth)}-+`;
+  const header = `| ${padCell2("Result", resultWidth)} | ${padCell2("Task", taskWidth)} | ${padCell2("Steps", stepsWidth)} | ${padCell2("Note", noteWidth)} |`;
+  const body = rows.map(
+    (row) => `| ${padCell2(row.result, resultWidth)} | ${padCell2(row.task, taskWidth)} | ${padCell2(row.steps, stepsWidth)} | ${padCell2(row.note, noteWidth)} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
+}
+function formatTaskLabel(task) {
+  return `${task.id} (${task.status})`;
+}
+function formatSuccess(result) {
+  const lines = [buildResultTable(result)];
+  if (result.succeeded.length > 0) {
+    lines.push("", "\uC0C1\uD0DC: IN_PROGRESS \u2192 \uC791\uC5C5\uC744 \uC2DC\uC791\uD569\uB2C8\uB2E4.");
+  }
+  return lines.join("\n");
+}
+async function selectTargets(tasks) {
+  if (tasks.length <= 1 || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return [...tasks];
+  }
+  const selectedIds = await checkbox2({
+    message: "Select tasks to approve plan for",
+    choices: tasks.map((task) => ({ checked: true, name: formatTaskLabel(task), value: task.id }))
+  });
+  return tasks.filter((task) => selectedIds.includes(task.id));
+}
+async function runPlanApproveCommand(input, projectRoot) {
+  try {
+    const candidates = await loadPlanApprovalCandidates(projectRoot, input);
+    if (candidates.length === 0) {
+      throw new Error("No matching tasks awaiting plan approval.");
+    }
+    if (input.target !== void 0 && candidates.length > 1 && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+      throw new Error(
+        "Multiple matching tasks found; rerun interactively to choose approval targets."
+      );
+    }
+    const selectedTasks = await selectTargets(candidates);
+    if (selectedTasks.length === 0) {
+      throw new Error("No tasks selected for plan approval.");
+    }
+    const result = await approvePlans(projectRoot, selectedTasks, createPlanApprovedAt());
+    if (result.succeeded.length === 0) {
+      return {
+        exitCode: 1,
+        stderr: buildResultTable(result),
+        stdout: ""
+      };
+    }
+    return {
+      exitCode: result.failed.length > 0 ? 1 : 0,
+      stderr: result.failed.length > 0 ? "" : "",
+      stdout: formatSuccess(result)
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown plan approval failure.",
+      stdout: ""
+    };
+  }
+}
+
+// src/commands/spec-approve.ts
+import { checkbox as checkbox3 } from "@inquirer/prompts";
+
+// src/core/spec-approve.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+function filterApprovalCandidates(tasks) {
+  return tasks.filter((task) => task.status === "PENDING_SPEC_APPROVAL");
+}
+function resolveTargetCandidates(tasks, target) {
+  const candidates = filterApprovalCandidates(tasks);
+  if (target === void 0 || target.trim() === "") {
+    return candidates;
+  }
+  const trimmedTarget = target.trim();
+  return candidates.filter(
+    (task) => task.id === trimmedTarget || task.slug === trimmedTarget || task.id.endsWith(trimmedTarget)
+  );
+}
+function validateSpecApprovalTargets(tasks) {
+  if (tasks.length === 0) {
+    throw new Error("No approvable spec tasks found.");
+  }
+  const invalidTask = tasks.find((task) => task.status !== "PENDING_SPEC_APPROVAL");
+  if (invalidTask !== void 0) {
+    throw new Error(
+      `Task ${invalidTask.id} is not awaiting spec approval (${invalidTask.status}).`
+    );
+  }
+}
+function updateSpecApprovalBlock(metaContent, approvedAt) {
+  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: SPEC_APPROVED");
+  return withStatus.replace(
+    /spec:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
+    `spec:
+  approved: true
+  approved_at: ${approvedAt}`
+  );
+}
+async function approveSpecs(projectRoot, tasks, approvedAt) {
+  validateSpecApprovalTargets(tasks);
+  for (const task of tasks) {
+    const metaPath = join6(projectRoot, task.path, "meta.yml");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      throw new Error(`Missing meta.yml for task ${task.id}.`);
+    }
+    const updatedContent = updateSpecApprovalBlock(await readFile5(metaPath, "utf8"), approvedAt);
+    await writeFile3(metaPath, updatedContent, "utf8");
+  }
+  return {
+    approvedAt,
+    approvedTaskIds: tasks.map((task) => task.id),
+    nextStatus: "SPEC_APPROVED"
+  };
+}
+async function loadSpecApprovalCandidates(projectRoot, input) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  return resolveTargetCandidates(tasks, input.target);
+}
+function createSpecApprovedAt(date = /* @__PURE__ */ new Date()) {
+  return formatUtcTimestamp(date);
+}
+
+// src/commands/spec-approve.ts
+function formatTaskLabel2(task) {
+  return `${task.id} (${task.status})`;
+}
+function formatSuccess2(result, tasks) {
+  const lines = ["\uC2A4\uD399 \uC2B9\uC778\uB428"];
+  for (const task of tasks) {
+    lines.push(`- ${task.path} -> ${result.nextStatus}`);
+  }
+  lines.push("\uC0C1\uD0DC: SPEC_APPROVED \u2192 \uD50C\uB79C \uC791\uC131\uC744 \uC2DC\uC791\uD569\uB2C8\uB2E4.");
+  return lines.join("\n");
+}
+async function selectTargets2(tasks) {
+  if (tasks.length <= 1 || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return [...tasks];
+  }
+  const selectedIds = await checkbox3({
+    message: "Select tasks to approve",
+    choices: tasks.map((task) => ({
+      checked: true,
+      name: formatTaskLabel2(task),
+      value: task.id
+    }))
+  });
+  return tasks.filter((task) => selectedIds.includes(task.id));
+}
+async function runSpecApproveCommand(input, projectRoot) {
+  try {
+    const candidates = await loadSpecApprovalCandidates(projectRoot, input);
+    if (candidates.length === 0) {
+      throw new Error("No matching tasks awaiting spec approval.");
+    }
+    if (input.target !== void 0 && candidates.length > 1 && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+      throw new Error(
+        "Multiple matching tasks found; rerun interactively to choose approval targets."
+      );
+    }
+    const selectedTasks = await selectTargets2(candidates);
+    if (selectedTasks.length === 0) {
+      throw new Error("No tasks selected for spec approval.");
+    }
+    const result = await approveSpecs(projectRoot, selectedTasks, createSpecApprovedAt());
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: formatSuccess2(result, selectedTasks)
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown spec approval failure.",
+      stdout: ""
+    };
+  }
+}
+
+// src/core/start.ts
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
+function normalizeSlug(input) {
+  return input.trim().toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function validateSlug(slug) {
+  if (slug === "") {
+    throw new Error("Invalid slug: slug cannot be empty after normalization.");
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+    throw new Error("Invalid slug: use lowercase kebab-case only.");
+  }
+}
+function createWorkspaceId(date, type, slug) {
+  const year = String(date.getUTCFullYear());
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hour = String(date.getUTCHours()).padStart(2, "0");
+  const minute = String(date.getUTCMinutes()).padStart(2, "0");
+  return `${year}${month}${day}-${hour}${minute}-${type}-${slug}`;
+}
+function renderInitialMeta(input) {
+  return [
+    `id: ${input.id}`,
+    `type: ${input.type}`,
+    `slug: ${input.slug}`,
+    `created_at: ${input.createdAt}`,
+    "",
+    "status: PENDING_SPEC_APPROVAL",
+    "",
+    "spec:",
+    "  approved: false",
+    "  approved_at: null",
+    "",
+    "plan:",
+    "  approved: false",
+    "  approved_at: null",
+    "",
+    "steps:",
+    "  total: null",
+    "  completed: []",
+    "",
+    "completed_at: null",
+    ""
+  ].join("\n");
+}
+async function resolveSpecTemplatePath(type) {
+  const assetsRoot = await getBundledAssetsRoot();
+  return join7(assetsRoot, resolveSpecTemplateRelativePath(type));
+}
+function applyTemplateDefaults(template, type, slug, currentDate) {
+  const displayName = slug.replace(/-/g, " ");
+  return template.replace(/\{기능명\}/g, displayName).replace(/\{버그 요약 한 줄\}/g, displayName).replace(/YYYY-MM-DD/g, formatUtcDate(currentDate)).replace(/> \*\*작성자:\*\*\s*$/m, "> **\uC791\uC131\uC790:** taehee").replace(/> \*\*연관 티켓:\*\*\s*$/m, "> **\uC5F0\uAD00 \uD2F0\uCF13:** -").replace(/^# \[(feature|fix|refactor|chore|build)\] .*/m, `# [${type}] ${displayName}`);
+}
+async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE__ */ new Date()) {
+  if (!isSupportedTaskType(rawType)) {
+    throw new Error(`Unsupported type: ${rawType}`);
+  }
+  const slug = normalizeSlug(rawSlug);
+  validateSlug(slug);
+  const activeTask = await findActiveTask(projectRoot);
+  if (activeTask !== null) {
+    throw new Error(
+      `Active task exists: ${activeTask.id} (${activeTask.status}) at ${activeTask.path}. Finish or approve it before starting a new task.`
+    );
+  }
+  const workspaceId = createWorkspaceId(currentDate, rawType, slug);
+  const workspacePath = join7("sduck-workspace", workspaceId);
+  const absoluteWorkspacePath = join7(projectRoot, workspacePath);
+  if (await getFsEntryKind(absoluteWorkspacePath) !== "missing") {
+    throw new Error(`Workspace already exists: ${workspacePath}`);
+  }
+  const workspaceRoot = join7(projectRoot, "sduck-workspace");
+  await mkdir3(workspaceRoot, { recursive: true });
+  await mkdir3(absoluteWorkspacePath, { recursive: false });
+  const templatePath = await resolveSpecTemplatePath(rawType);
+  if (await getFsEntryKind(templatePath) !== "file") {
+    throw new Error(`Missing spec template for type '${rawType}' at ${templatePath}`);
+  }
+  const specTemplate = await readFile6(templatePath, "utf8");
+  const specContent = applyTemplateDefaults(specTemplate, rawType, slug, currentDate);
+  const metaContent = renderInitialMeta({
+    createdAt: formatUtcTimestamp(currentDate),
+    id: workspaceId,
+    slug,
+    type: rawType
+  });
+  await writeFile4(join7(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
+  await writeFile4(join7(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
+  await writeFile4(join7(absoluteWorkspacePath, "plan.md"), "", "utf8");
+  return {
+    workspaceId,
+    workspacePath,
+    status: "PENDING_SPEC_APPROVAL"
+  };
+}
+
+// src/commands/start.ts
+async function runStartCommand(type, slug, projectRoot) {
+  try {
+    const result = await startTask(type, slug, projectRoot);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: [
+        "\uC791\uC5C5 \uB514\uB809\uD1A0\uB9AC \uC0DD\uC131\uB428",
+        `\uACBD\uB85C: ${result.workspacePath}/`,
+        `\uC0C1\uD0DC: ${result.status}`
+      ].join("\n")
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown start failure.",
+      stdout: ""
+    };
+  }
+}
+
+// src/core/command-metadata.ts
+var CLI_NAME = "sduck";
+var CLI_DESCRIPTION = "Spec-Driven Development workflow bootstrap CLI";
+var PLACEHOLDER_MESSAGE = "Core workflow commands are planned but not implemented in this bootstrap yet.";
+function normalizeCommandName(input) {
+  return input.trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name(CLI_NAME).description(CLI_DESCRIPTION).version("0.1.0");
+program.command("init").description("Initialize the current repository for the SDD workflow").option("--force", "Regenerate the bundled assets in sduck-assets").option(
+  "--agents <agents>",
+  "Comma-separated agents (claude-code,codex,opencode,gemini-cli,cursor,antigravity)"
+).action(async (options) => {
+  const initOptions = options.agents === void 0 ? { force: options.force ?? false } : { agents: options.agents, force: options.force ?? false };
+  const result = await runInitCommand(initOptions, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("preview <name>").description("Print the normalized command name for bootstrap verification").action((name) => {
+  console.log(normalizeCommandName(name));
+});
+program.command("start <type> <slug>").description("Create a new task workspace from a type template").action(async (type, slug) => {
+  const result = await runStartCommand(type, slug, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("spec").description("Manage spec workflow state").command("approve [target]").description("Approve a task spec and move it to plan writing").action(async (target) => {
+  const input = target === void 0 ? {} : { target };
+  const result = await runSpecApproveCommand(input, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("plan").description("Manage plan workflow state").command("approve [target]").description("Approve a task plan and move it to implementation").action(async (target) => {
+  const input = target === void 0 ? {} : { target };
+  const result = await runPlanApproveCommand(input, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("roadmap").description("Show the current bootstrap status").action(() => {
+  console.log(PLACEHOLDER_MESSAGE);
+});
+await program.parseAsync(process.argv);
+//# sourceMappingURL=cli.js.map