@byrde/cursor 0.1.1

package/dist/cli.js

@@ -0,0 +1,1241 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync5, realpathSync } from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
+import { Command, CommanderError } from "commander";
+
+// src/api/init.ts
+import path7 from "path";
+
+// src/domain/config.ts
+var PROJECT_CONFIG_FILENAME = "workflow.json";
+function createDefaultWorkflowModels() {
+  return {
+    planner: "gpt-5.4-high",
+    architect: "gpt-5.4-high",
+    developer: "composer-2-fast",
+    tester: "composer-2-fast"
+  };
+}
+function createDefaultProjectConfig() {
+  return {
+    backlog: {
+      provider: "file",
+      file: {
+        path: "docs/backlog.md"
+      }
+    },
+    workflow: {
+      defaults: {
+        architectReview: "required",
+        testing: "required"
+      },
+      models: createDefaultWorkflowModels()
+    }
+  };
+}
+var DEFAULT_PROJECT_CONFIG = createDefaultProjectConfig();
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.trim().length > 0;
+}
+function normalizeBacklog(raw, base) {
+  if (!raw || typeof raw !== "object") {
+    return base;
+  }
+  const b = raw;
+  const provider = b.provider === "github-issues" || b.provider === "file" ? b.provider : base.provider;
+  if (provider === "file") {
+    const fileRaw = b.file;
+    const pathFrom = fileRaw && typeof fileRaw === "object" && isNonEmptyString(fileRaw.path) ? String(fileRaw.path).trim() : base.file.path;
+    return { provider: "file", file: { path: pathFrom } };
+  }
+  const ghRaw = b["github-issues"];
+  const githubOptionalDefaults = {
+    priorityField: "Priority",
+    statusField: "Status",
+    mcpServerName: "github"
+  };
+  function parsePositiveInt(v) {
+    if (typeof v === "number" && Number.isFinite(v) && v > 0) {
+      return Math.trunc(v);
+    }
+    if (isNonEmptyString(v)) {
+      const n = Number.parseInt(String(v).trim(), 10);
+      if (Number.isFinite(n) && n > 0) {
+        return n;
+      }
+    }
+    return void 0;
+  }
+  if (ghRaw && typeof ghRaw === "object") {
+    const g = ghRaw;
+    const repository = isNonEmptyString(g.repository) ? g.repository.trim() : void 0;
+    const projectNumber = parsePositiveInt(g.projectNumber);
+    if (repository !== void 0 && projectNumber !== void 0) {
+      const priorityField = isNonEmptyString(g.priorityField) ? g.priorityField.trim() : githubOptionalDefaults.priorityField;
+      const statusField = isNonEmptyString(g.statusField) ? g.statusField.trim() : githubOptionalDefaults.statusField;
+      const labelRaw = g.label;
+      const label = isNonEmptyString(labelRaw) ? labelRaw.trim() : void 0;
+      return {
+        provider: "github-issues",
+        "github-issues": {
+          repository,
+          projectNumber,
+          projectOwner: isNonEmptyString(g.projectOwner) ? g.projectOwner.trim() : void 0,
+          priorityField,
+          statusField,
+          ...label !== void 0 ? { label } : {},
+          mcpServerName: isNonEmptyString(g.mcpServerName) ? g.mcpServerName.trim() : githubOptionalDefaults.mcpServerName
+        }
+      };
+    }
+  }
+  return base;
+}
+function normalizeWorkflow(raw, base) {
+  const models = { ...base.models };
+  let architectReview = base.defaults.architectReview;
+  let testing = base.defaults.testing;
+  if (raw && typeof raw === "object") {
+    const w = raw;
+    const d = w.defaults;
+    if (d && typeof d === "object") {
+      const def = d;
+      if (def.architectReview === "required" || def.architectReview === "optional") {
+        architectReview = def.architectReview;
+      }
+      if (def.testing === "required" || def.testing === "optional") {
+        testing = def.testing;
+      }
+    }
+    const m = w.models;
+    if (m && typeof m === "object") {
+      const mo = m;
+      const pick = (key) => {
+        const v = mo[key];
+        return isNonEmptyString(v) ? v.trim() : base.models[key];
+      };
+      models.planner = pick("planner");
+      models.architect = pick("architect");
+      models.developer = pick("developer");
+      models.tester = pick("tester");
+    }
+  }
+  return {
+    defaults: { architectReview, testing },
+    models
+  };
+}
+function normalizeProjectConfig(raw) {
+  const base = createDefaultProjectConfig();
+  if (!raw || typeof raw !== "object") {
+    return base;
+  }
+  const o = raw;
+  return {
+    backlog: normalizeBacklog(o.backlog, base.backlog),
+    workflow: normalizeWorkflow(o.workflow, base.workflow)
+  };
+}
+
+// src/domain/asset-manifest.ts
+var DEFAULT_MANIFEST = [
+  {
+    source: "assets/agents/architect.md",
+    target: "agents/architect.md",
+    renderAgent: "architect"
+  },
+  {
+    source: "assets/agents/developer.md",
+    target: "agents/developer.md",
+    renderAgent: "developer"
+  },
+  {
+    source: "assets/agents/planner.md",
+    target: "agents/planner.md",
+    renderAgent: "planner"
+  },
+  {
+    source: "assets/agents/tester.md",
+    target: "agents/tester.md",
+    renderAgent: "tester"
+  },
+  { source: "assets/rules/global.mdc", target: "rules/global.mdc" },
+  { source: "assets/rules/init.mdc", target: "rules/init.mdc" },
+  { source: "assets/templates/backlog.md", target: "templates/backlog.md" },
+  { source: "assets/templates/design.md", target: "templates/design.md" },
+  { source: "assets/templates/overview.md", target: "templates/overview.md" },
+  {
+    source: "assets/templates/testability/README.md",
+    target: "templates/testability/README.md"
+  }
+];
+
+// src/infrastructure/file-installer.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  statSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import path2 from "path";
+
+// src/domain/managed-state.ts
+import { createHash } from "crypto";
+function hashFileContents(data) {
+  const hex = createHash("sha256").update(data).digest("hex");
+  return `sha256:${hex}`;
+}
+
+// src/infrastructure/agent-template.ts
+var AGENT_MODEL_PLACEHOLDER = "{{MODEL}}";
+function renderAgentTemplate(templateUtf8, model) {
+  if (!templateUtf8.includes(AGENT_MODEL_PLACEHOLDER)) {
+    throw new Error(
+      `Agent template is missing ${AGENT_MODEL_PLACEHOLDER} placeholder`
+    );
+  }
+  return templateUtf8.replaceAll(AGENT_MODEL_PLACEHOLDER, model);
+}
+
+// src/infrastructure/managed-state-store.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+var MANAGED_STATE_FILENAME = ".managed.json";
+function managedStatePath(cursorDir) {
+  return path.join(cursorDir, MANAGED_STATE_FILENAME);
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseManagedState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(
+      `Invalid managed state JSON in ${MANAGED_STATE_FILENAME}: ${msg}`
+    );
+  }
+  if (!isPlainRecord(parsed)) {
+    throw new Error(
+      `Invalid managed state: root must be a JSON object (${MANAGED_STATE_FILENAME})`
+    );
+  }
+  const version = parsed.version;
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error(
+      `Invalid managed state: missing or invalid "version" string (${MANAGED_STATE_FILENAME})`
+    );
+  }
+  const filesRaw = parsed.files;
+  if (!isPlainRecord(filesRaw)) {
+    throw new Error(
+      `Invalid managed state: "files" must be an object (${MANAGED_STATE_FILENAME})`
+    );
+  }
+  const files = {};
+  for (const [target, rec] of Object.entries(filesRaw)) {
+    if (!isPlainRecord(rec)) {
+      throw new Error(
+        `Invalid managed state: files["${target}"] must be an object (${MANAGED_STATE_FILENAME})`
+      );
+    }
+    const hash = rec.hash;
+    const ver = rec.version;
+    if (typeof hash !== "string" || hash.length === 0) {
+      throw new Error(
+        `Invalid managed state: files["${target}"].hash must be a non-empty string (${MANAGED_STATE_FILENAME})`
+      );
+    }
+    if (typeof ver !== "string" || ver.length === 0) {
+      throw new Error(
+        `Invalid managed state: files["${target}"].version must be a non-empty string (${MANAGED_STATE_FILENAME})`
+      );
+    }
+    const installedAt2 = rec.installedAt;
+    files[target] = {
+      hash,
+      version: ver,
+      ...typeof installedAt2 === "string" ? { installedAt: installedAt2 } : {}
+    };
+  }
+  const installedAt = parsed.installedAt;
+  return {
+    version,
+    ...typeof installedAt === "string" ? { installedAt } : {},
+    files
+  };
+}
+function loadManagedState(cursorDir) {
+  const p = managedStatePath(cursorDir);
+  if (!existsSync(p)) {
+    return null;
+  }
+  const raw = readFileSync(p, "utf8");
+  return parseManagedState(raw);
+}
+function saveManagedStateAtomic(cursorDir, state) {
+  mkdirSync(cursorDir, { recursive: true });
+  const finalPath = managedStatePath(cursorDir);
+  const tmpPath = `${finalPath}.${process.pid}.tmp`;
+  const payload = `${JSON.stringify(state, null, 2)}
+`;
+  try {
+    writeFileSync(tmpPath, payload, "utf8");
+    renameSync(tmpPath, finalPath);
+  } catch (e) {
+    try {
+      if (existsSync(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+    }
+    throw e;
+  }
+}
+
+// src/infrastructure/file-installer.ts
+function resolveManifestSourceBytes(entry, packageRoot2, projectConfig) {
+  const absSource = path2.join(packageRoot2, entry.source);
+  const raw = readFileSync2(absSource);
+  if (!entry.renderAgent) {
+    return raw;
+  }
+  const utf8 = raw.toString("utf8");
+  const model = projectConfig.workflow.models[entry.renderAgent];
+  const rendered = renderAgentTemplate(utf8, model);
+  return Buffer.from(rendered, "utf8");
+}
+function nowRecord(hash, packageVersion2) {
+  return {
+    hash,
+    version: packageVersion2,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function installAssets(manifest, packageRoot2, targetDir, options) {
+  const resolvedRoot = path2.resolve(packageRoot2);
+  const resolvedTargetBase = path2.resolve(targetDir);
+  const projectConfig = normalizeProjectConfig(
+    options.projectConfig ?? createDefaultProjectConfig()
+  );
+  const initialState = loadManagedState(resolvedTargetBase);
+  const workingFiles = {
+    ...initialState?.files ?? {}
+  };
+  const manifestOutcomes = [];
+  const staleOutcomes = [];
+  const warnings = [];
+  const manifestTargets = new Set(manifest.map((e) => e.target));
+  for (const entry of manifest) {
+    const absSource = path2.join(resolvedRoot, entry.source);
+    const absTarget = path2.join(resolvedTargetBase, entry.target);
+    statSync(absSource);
+    const sourceBytes = resolveManifestSourceBytes(
+      entry,
+      resolvedRoot,
+      projectConfig
+    );
+    const sourceHash = hashFileContents(sourceBytes);
+    const record = workingFiles[entry.target];
+    if (!existsSync2(absTarget)) {
+      mkdirSync2(path2.dirname(absTarget), { recursive: true });
+      writeFileSync2(absTarget, sourceBytes);
+      const writtenHash = hashFileContents(readFileSync2(absTarget));
+      workingFiles[entry.target] = nowRecord(
+        writtenHash,
+        options.packageVersion
+      );
+      if (record) {
+        manifestOutcomes.push({
+          kind: "recreated",
+          target: entry.target,
+          source: entry.source,
+          absolutePath: absTarget,
+          hash: writtenHash
+        });
+      } else {
+        manifestOutcomes.push({
+          kind: "installed",
+          target: entry.target,
+          source: entry.source,
+          absolutePath: absTarget,
+          hash: writtenHash
+        });
+      }
+      continue;
+    }
+    const diskBytes = readFileSync2(absTarget);
+    const diskHash = hashFileContents(diskBytes);
+    if (record) {
+      if (diskHash === record.hash) {
+        writeFileSync2(absTarget, sourceBytes);
+        const newHash2 = hashFileContents(readFileSync2(absTarget));
+        workingFiles[entry.target] = nowRecord(newHash2, options.packageVersion);
+        manifestOutcomes.push({
+          kind: "updated",
+          target: entry.target,
+          source: entry.source,
+          absolutePath: absTarget,
+          hash: newHash2,
+          forced: false
+        });
+      } else if (!options.force) {
+        const msg = `Skipped managed file (modified on disk): ${entry.target}`;
+        warnings.push(msg);
+        if (entry.renderAgent) {
+          const desiredHash = sourceHash;
+          if (desiredHash !== record.hash) {
+            warnings.push(
+              `Model or template update not applied to ${entry.target} because the file was modified locally. Update the \`model:\` line yourself, or re-run init with --force to replace managed files.`
+            );
+          }
+        }
+        manifestOutcomes.push({
+          kind: "skipped",
+          target: entry.target,
+          source: entry.source,
+          absolutePath: absTarget,
+          reason: "tracked_hash_mismatch",
+          forced: false
+        });
+      } else {
+        writeFileSync2(absTarget, sourceBytes);
+        const newHash2 = hashFileContents(readFileSync2(absTarget));
+        workingFiles[entry.target] = nowRecord(newHash2, options.packageVersion);
+        warnings.push(
+          `Overwrote modified managed file (--force): ${entry.target}`
+        );
+        manifestOutcomes.push({
+          kind: "updated",
+          target: entry.target,
+          source: entry.source,
+          absolutePath: absTarget,
+          hash: newHash2,
+          forced: true
+        });
+      }
+      continue;
+    }
+    if (diskHash === sourceHash) {
+      workingFiles[entry.target] = nowRecord(diskHash, options.packageVersion);
+      manifestOutcomes.push({
+        kind: "adopted",
+        target: entry.target,
+        source: entry.source,
+        absolutePath: absTarget,
+        hash: diskHash
+      });
+      continue;
+    }
+    if (!options.force) {
+      const msg = `Skipped untracked file (differs from package): ${entry.target}`;
+      warnings.push(msg);
+      manifestOutcomes.push({
+        kind: "skipped",
+        target: entry.target,
+        source: entry.source,
+        absolutePath: absTarget,
+        reason: "untracked_bytes_mismatch",
+        forced: false
+      });
+      continue;
+    }
+    writeFileSync2(absTarget, sourceBytes);
+    const newHash = hashFileContents(readFileSync2(absTarget));
+    workingFiles[entry.target] = nowRecord(newHash, options.packageVersion);
+    warnings.push(
+      `Overwrote untracked file that differed from package (--force): ${entry.target}`
+    );
+    manifestOutcomes.push({
+      kind: "updated",
+      target: entry.target,
+      source: entry.source,
+      absolutePath: absTarget,
+      hash: newHash,
+      forced: true
+    });
+  }
+  const initialKeys = Object.keys(initialState?.files ?? {});
+  for (const target of initialKeys) {
+    if (manifestTargets.has(target)) {
+      continue;
+    }
+    const record = workingFiles[target];
+    if (!record) {
+      continue;
+    }
+    const absStale = path2.join(resolvedTargetBase, target);
+    if (!existsSync2(absStale)) {
+      delete workingFiles[target];
+      staleOutcomes.push({ kind: "stale_record_dropped", target });
+      continue;
+    }
+    const diskHash = hashFileContents(readFileSync2(absStale));
+    if (diskHash === record.hash) {
+      unlinkSync2(absStale);
+      delete workingFiles[target];
+      staleOutcomes.push({
+        kind: "stale_removed",
+        target,
+        absolutePath: absStale
+      });
+    } else {
+      const msg = `Stale managed file not in manifest; keeping local changes: ${target}`;
+      warnings.push(msg);
+      staleOutcomes.push({
+        kind: "stale_kept_warn",
+        target,
+        absolutePath: absStale,
+        reason: "content_mismatch"
+      });
+    }
+  }
+  const finalState = {
+    version: options.packageVersion,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: workingFiles
+  };
+  saveManagedStateAtomic(resolvedTargetBase, finalState);
+  return {
+    manifestOutcomes,
+    staleOutcomes,
+    warnings
+  };
+}
+
+// src/infrastructure/install-output-validator.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import path3 from "path";
+var PACKAGE_OWNED_KINDS = /* @__PURE__ */ new Set(["installed", "updated", "adopted", "recreated"]);
+function displayPath(cwd, absolutePath) {
+  const rel = path3.relative(cwd, absolutePath);
+  return rel.split(path3.sep).join("/");
+}
+function failureReason(absolutePath) {
+  if (!existsSync3(absolutePath)) {
+    return "missing";
+  }
+  const st = statSync2(absolutePath);
+  if (!st.isFile()) {
+    return "not a regular file";
+  }
+  if (st.size === 0) {
+    return "empty file";
+  }
+  return null;
+}
+function validateInstalledPackageOutputs(cwd, outcomes) {
+  const resolvedCwd = path3.resolve(cwd);
+  const failures = [];
+  for (const o of outcomes) {
+    if (!PACKAGE_OWNED_KINDS.has(o.kind)) {
+      continue;
+    }
+    const reason = failureReason(o.absolutePath);
+    if (reason !== null) {
+      failures.push(`${displayPath(resolvedCwd, o.absolutePath)} (${reason})`);
+    }
+  }
+  if (failures.length > 0) {
+    const msg = `Post-install validation failed:
+${failures.map((f) => `  - ${f}`).join("\n")}`;
+    throw new Error(msg);
+  }
+}
+
+// src/infrastructure/doc-template-installer.ts
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync3 } from "fs";
+import path4 from "path";
+var BASE_TEMPLATE_DOC_ENTRIES = [
+  { source: "overview.md", target: "docs/overview.md" },
+  { source: "design.md", target: "docs/design.md" },
+  { source: "testability/README.md", target: "docs/testability/README.md" }
+];
+function scaffoldTemplateDocs(packageRoot2, cwd, config) {
+  const created = [];
+  const skipped = [];
+  const entries = resolveTemplateEntries(config);
+  mkdirSync3(path4.join(cwd, "docs"), { recursive: true });
+  for (const entry of entries) {
+    const source = path4.join(packageRoot2, "assets", "templates", entry.source);
+    const target = path4.join(cwd, entry.target);
+    statSync3(source);
+    mkdirSync3(path4.dirname(target), { recursive: true });
+    if (existsSync4(target)) {
+      skipped.push(target);
+      continue;
+    }
+    copyFileSync(source, target);
+    created.push(target);
+  }
+  return {
+    created,
+    skipped
+  };
+}
+function resolveTemplateEntries(config) {
+  const entries = [...BASE_TEMPLATE_DOC_ENTRIES];
+  if (!config || config.backlog.provider === "file") {
+    entries.splice(2, 0, {
+      source: "backlog.md",
+      target: config?.backlog.file?.path ?? "docs/backlog.md"
+    });
+  }
+  return entries;
+}
+
+// src/infrastructure/project-config-store.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import path5 from "path";
+var LEGACY_PROJECT_CONFIG_FILENAME = "byrde.json";
+function projectConfigPath(cwd) {
+  return path5.join(cwd, ".cursor", PROJECT_CONFIG_FILENAME);
+}
+function loadProjectConfig(cwd) {
+  const configPath = projectConfigPath(cwd);
+  const legacyPath = path5.join(cwd, ".cursor", LEGACY_PROJECT_CONFIG_FILENAME);
+  if (existsSync5(configPath)) {
+    return normalizeProjectConfig(
+      JSON.parse(readFileSync3(configPath, "utf8"))
+    );
+  }
+  if (existsSync5(legacyPath)) {
+    return normalizeProjectConfig(
+      JSON.parse(readFileSync3(legacyPath, "utf8"))
+    );
+  }
+  return void 0;
+}
+function ensureProjectConfig(cwd, config = DEFAULT_PROJECT_CONFIG) {
+  const configPath = projectConfigPath(cwd);
+  if (existsSync5(configPath)) {
+    return {
+      path: configPath,
+      created: false
+    };
+  }
+  mkdirSync4(path5.dirname(configPath), { recursive: true });
+  const normalized = normalizeProjectConfig(config);
+  writeFileSync3(configPath, `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+  return {
+    path: configPath,
+    created: true
+  };
+}
+function saveProjectConfig(cwd, config = DEFAULT_PROJECT_CONFIG) {
+  const configPath = projectConfigPath(cwd);
+  const created = !existsSync5(configPath);
+  mkdirSync4(path5.dirname(configPath), { recursive: true });
+  const normalized = normalizeProjectConfig(config);
+  writeFileSync3(configPath, `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+  return {
+    path: configPath,
+    created
+  };
+}
+
+// src/infrastructure/github-mcp-store.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import path6 from "path";
+var MANAGED_GITHUB_SERVER_PREFIX = "cursor-workflow:";
+function mcpConfigPath(cwd) {
+  return path6.join(cwd, ".cursor", "mcp.json");
+}
+function readExistingConfig(cwd) {
+  const filePath = mcpConfigPath(cwd);
+  if (!existsSync6(filePath)) {
+    return { mcpServers: {} };
+  }
+  const raw = JSON.parse(readFileSync4(filePath, "utf8"));
+  return {
+    mcpServers: raw.mcpServers ?? {}
+  };
+}
+function managedServerKey(serverName) {
+  return `${MANAGED_GITHUB_SERVER_PREFIX}${serverName}`;
+}
+function writeGitHubMcpServer(params) {
+  const filePath = mcpConfigPath(params.cwd);
+  const created = !existsSync6(filePath);
+  const existing = readExistingConfig(params.cwd);
+  const serverKey = managedServerKey(params.serverName);
+  const nextServers = {};
+  for (const [key, value] of Object.entries(existing.mcpServers)) {
+    if (!key.startsWith(MANAGED_GITHUB_SERVER_PREFIX)) {
+      nextServers[key] = value;
+    }
+  }
+  nextServers[serverKey] = {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    env: {
+      GITHUB_PERSONAL_ACCESS_TOKEN: params.token
+    }
+  };
+  mkdirSync5(path6.dirname(filePath), { recursive: true });
+  writeFileSync4(
+    filePath,
+    `${JSON.stringify({ mcpServers: nextServers }, null, 2)}
+`,
+    "utf8"
+  );
+  return {
+    path: filePath,
+    created,
+    serverKey
+  };
+}
+
+// src/api/init.ts
+async function runInit(params, packageRoot2) {
+  const targetDir = path7.join(params.cwd, ".cursor");
+  const projectConfig = normalizeProjectConfig(
+    params.projectConfig ?? DEFAULT_PROJECT_CONFIG
+  );
+  const result = installAssets(DEFAULT_MANIFEST, packageRoot2, targetDir, {
+    force: params.force,
+    packageVersion: params.packageVersion,
+    projectConfig
+  });
+  const warnings = [...result.warnings];
+  validateInstalledPackageOutputs(params.cwd, result.manifestOutcomes);
+  const configResult = params.overwriteProjectConfig ? saveProjectConfig(params.cwd, projectConfig) : ensureProjectConfig(params.cwd, projectConfig);
+  const docsResult = scaffoldTemplateDocs(packageRoot2, params.cwd, projectConfig);
+  const shouldConfigureGitHubMcp = projectConfig.backlog.provider === "github-issues";
+  let mcpLabel;
+  if (shouldConfigureGitHubMcp && !params.skipMcp) {
+    const token = params.githubMcpToken;
+    if (!token) {
+      warnings.push(
+        "GitHub backlog selected, but no GitHub token was provided for Cursor MCP setup. Re-run `init` or edit `.cursor/mcp.json` manually."
+      );
+    } else {
+      const mcpResult = writeGitHubMcpServer({
+        cwd: params.cwd,
+        serverName: projectConfig.backlog["github-issues"]?.mcpServerName ?? "github",
+        token
+      });
+      mcpLabel = `${mcpResult.created ? "GitHub MCP config created" : "GitHub MCP config updated"}: ${mcpResult.path}`;
+    }
+  } else if (shouldConfigureGitHubMcp) {
+    mcpLabel = "Skipped GitHub MCP setup (--skip-mcp).";
+  } else {
+    mcpLabel = "No GitHub MCP setup needed for the selected backlog.";
+  }
+  console.log("Project scaffolded.");
+  for (const w of warnings) {
+    console.warn(w);
+  }
+  if (params.verbose) {
+    const configLabel = params.overwriteProjectConfig ? configResult.created ? "Project config created" : "Project config updated" : configResult.created ? "Project config created" : "Project config preserved";
+    console.log(`${configLabel}: ${configResult.path}`);
+    console.log(
+      `Docs scaffolded: ${docsResult.created.length} created, ${docsResult.skipped.length} preserved.`
+    );
+    console.log(mcpLabel);
+    if (configResult.created) {
+      console.log(`config created: ${configResult.path}`);
+    } else {
+      console.log(`config preserved: ${configResult.path}`);
+    }
+    for (const created of docsResult.created) {
+      console.log(`doc created: ${created}`);
+    }
+    for (const skipped of docsResult.skipped) {
+      console.log(`doc preserved: ${skipped}`);
+    }
+    for (const o of result.manifestOutcomes) {
+      const dest = `${o.target} -> ${o.absolutePath}`;
+      if (o.kind === "skipped") {
+        console.log(`skipped (${o.reason}): ${dest}`);
+      } else {
+        console.log(`${o.kind}: ${dest}`);
+      }
+    }
+    for (const s of result.staleOutcomes) {
+      if (s.kind === "stale_removed") {
+        console.log(`stale removed: ${s.target} (${s.absolutePath})`);
+      } else if (s.kind === "stale_record_dropped") {
+        console.log(`stale record dropped (file missing): ${s.target}`);
+      } else {
+        console.log(
+          `stale kept (${s.reason}): ${s.target} (${s.absolutePath})`
+        );
+      }
+    }
+  }
+  return {
+    ...result,
+    warnings
+  };
+}
+
+// src/infrastructure/init-questionnaire.ts
+import { confirm, input, password, select } from "@inquirer/prompts";
+import { styleText } from "util";
+
+// src/infrastructure/github-auth.ts
+import { execFile, execFileSync } from "child_process";
+function execFileResult(command, args) {
+  return new Promise((resolve) => {
+    execFile(command, args, (error, stdout, stderr) => {
+      const exitCode = error && typeof error === "object" && "code" in error ? error.code : error ? 1 : 0;
+      resolve({
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? ""),
+        exitCode
+      });
+    });
+  });
+}
+function parseGitHubAccounts(output) {
+  const accounts = [];
+  const lines = output.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const accountMatch = line.match(/Logged in to (\S+) account (\S+)/);
+    if (!accountMatch) {
+      continue;
+    }
+    const host = accountMatch[1];
+    const account = accountMatch[2];
+    let active = line.includes("\u2713");
+    for (let j = i + 1; j < Math.min(i + 8, lines.length); j++) {
+      const next = lines[j];
+      if (/Logged in to \S+ account \S+/.test(next)) {
+        break;
+      }
+      if (/Active account:\s*true\b/.test(next)) {
+        active = true;
+        break;
+      }
+      if (/Active account:\s*false\b/.test(next)) {
+        active = false;
+        break;
+      }
+    }
+    accounts.push({ host, account, active });
+  }
+  return accounts;
+}
+async function listGitHubAccounts() {
+  let result;
+  try {
+    result = await execFileResult("gh", ["auth", "status"]);
+  } catch {
+    return [];
+  }
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  const combined = `${result.stdout}
+${result.stderr}`;
+  return parseGitHubAccounts(combined);
+}
+async function resolveGitHubTokenForAccount(account) {
+  const args = ["auth", "token"];
+  if (account) {
+    args.push("--user", account);
+  }
+  try {
+    const result = await execFileResult("gh", args);
+    const token = result.stdout.trim();
+    if (result.exitCode !== 0 || !token) {
+      return void 0;
+    }
+    return token;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/infrastructure/init-questionnaire.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var DEFAULT_PROMPTS = {
+  select,
+  input,
+  confirm,
+  password
+};
+async function runInitQuestionnaire(options, prompts = DEFAULT_PROMPTS) {
+  printBanner();
+  const existingConfig = options.existingConfig;
+  if (existingConfig) {
+    const reconfigure = await prompts.confirm({
+      message: "Reconfigure workflow setup (.cursor/workflow.json)?",
+      default: false
+    });
+    if (!reconfigure) {
+      return {
+        projectConfig: normalizeProjectConfig(existingConfig),
+        shouldWriteProjectConfig: false
+      };
+    }
+  }
+  const projectConfig = await promptProjectConfig(
+    existingConfig ?? createDefaultProjectConfig(),
+    prompts
+  );
+  const githubMcpToken = projectConfig.backlog.provider === "github-issues" ? await promptGitHubMcpToken(prompts) : void 0;
+  return {
+    projectConfig,
+    shouldWriteProjectConfig: true,
+    githubMcpToken
+  };
+}
+async function promptProjectConfig(defaults, prompts) {
+  const provider = await prompts.select({
+    message: "Which backlog style should this project use?",
+    choices: [
+      {
+        name: "Markdown file in the repository",
+        description: "Track work in a markdown backlog file that the workflow updates directly.",
+        value: "file"
+      },
+      {
+        name: "GitHub Project (v2) + issues",
+        description: "Track work in a GitHub Project (v2): milestones = epics, Project Priority orders work, Project Status maps to workflow state. Uses GitHub MCP instead of a local backlog file.",
+        value: "github-issues"
+      }
+    ],
+    default: defaults.backlog.provider
+  });
+  const backlog = await promptBacklogConfig(provider, defaults, prompts);
+  const architectReview = await promptDefaultMode(
+    "Default architect review behavior?",
+    defaults.workflow.defaults.architectReview,
+    prompts,
+    {
+      required: "Require a second architect review by default",
+      optional: "Let the orchestrator skip architect review by default when the task is clearly small and low-risk"
+    }
+  );
+  const testing = await promptDefaultMode(
+    "Default adversarial testing behavior?",
+    defaults.workflow.defaults.testing,
+    prompts,
+    {
+      required: "Require `/tester` by default",
+      optional: "Let the orchestrator skip `/tester` by default when developer verification is sufficient"
+    }
+  );
+  const models = await promptWorkflowModels(defaults.workflow.models, prompts);
+  return {
+    backlog,
+    workflow: {
+      defaults: {
+        architectReview,
+        testing
+      },
+      models
+    }
+  };
+}
+async function promptWorkflowModels(defaults, prompts) {
+  const useRecommended = await prompts.confirm({
+    message: "Use recommended Cursor models for /planner, /architect, /developer, and /tester?",
+    default: true
+  });
+  if (useRecommended) {
+    return defaults;
+  }
+  const planner = (await prompts.input({
+    message: "Model id for /planner:",
+    default: defaults.planner,
+    validate: (value) => value.trim() ? true : "Enter a model id (see Cursor docs)."
+  })).trim();
+  const architect = (await prompts.input({
+    message: "Model id for /architect:",
+    default: defaults.architect,
+    validate: (value) => value.trim() ? true : "Enter a model id (see Cursor docs)."
+  })).trim();
+  const developer = (await prompts.input({
+    message: "Model id for /developer:",
+    default: defaults.developer,
+    validate: (value) => value.trim() ? true : "Enter a model id (see Cursor docs)."
+  })).trim();
+  const tester = (await prompts.input({
+    message: "Model id for /tester:",
+    default: defaults.tester,
+    validate: (value) => value.trim() ? true : "Enter a model id (see Cursor docs)."
+  })).trim();
+  return { planner, architect, developer, tester };
+}
+async function promptBacklogConfig(provider, defaults, prompts) {
+  if (provider === "github-issues") {
+    const githubDefaults = defaults.backlog["github-issues"];
+    const repository = (await prompts.input({
+      message: "GitHub repository for issues (owner/name):",
+      default: githubDefaults?.repository ?? "",
+      validate: (value) => value.trim().match(/^[^/\s]+\/[^/\s]+$/) ? true : "Use the form owner/name."
+    })).trim();
+    const projectNumberStr = await prompts.input({
+      message: "GitHub Project (v2) number:",
+      default: githubDefaults?.projectNumber != null ? String(githubDefaults.projectNumber) : "",
+      validate: (value) => {
+        const n = Number.parseInt(value.trim(), 10);
+        return Number.isFinite(n) && n > 0 ? true : "Enter a positive Project number (from the Projects tab).";
+      }
+    });
+    const projectNumber = Number.parseInt(projectNumberStr.trim(), 10);
+    const projectOwner = (await prompts.input({
+      message: "Project owner (org or user login; leave blank to use the repository owner):",
+      default: githubDefaults?.projectOwner ?? ""
+    })).trim();
+    const priorityField = (await prompts.input({
+      message: "Project field name for backlog ordering:",
+      default: githubDefaults?.priorityField ?? "Priority",
+      validate: (value) => value.trim() ? true : "Field name is required."
+    })).trim();
+    const statusField = (await prompts.input({
+      message: "Project field name for workflow status:",
+      default: githubDefaults?.statusField ?? "Status",
+      validate: (value) => value.trim() ? true : "Field name is required."
+    })).trim();
+    const labelRaw = (await prompts.input({
+      message: "Optional issue label filter (leave blank for none; secondary to Project items):",
+      default: githubDefaults?.label ?? ""
+    })).trim();
+    return {
+      provider,
+      "github-issues": {
+        repository,
+        projectNumber,
+        ...projectOwner.trim().length > 0 ? { projectOwner: projectOwner.trim() } : {},
+        priorityField,
+        statusField,
+        ...labelRaw.trim().length > 0 ? { label: labelRaw.trim() } : {},
+        mcpServerName: githubDefaults?.mcpServerName ?? "github"
+      }
+    };
+  }
+  const fileDefaults = defaults.backlog.file;
+  const backlogPath = (await prompts.input({
+    message: "Backlog file path:",
+    default: fileDefaults?.path ?? "docs/backlog.md",
+    validate: (value) => value.trim() ? true : "Path is required."
+  })).trim();
+  return {
+    provider,
+    file: {
+      path: backlogPath
+    }
+  };
+}
+var GITHUB_MCP_AUTH_QUESTION = "How should Cursor authenticate to GitHub for the MCP server?";
+var GITHUB_MCP_TOKEN_PROMPT = "GitHub personal access token for the Cursor MCP server:";
+function formatGitHubMcpContextBlock() {
+  return `${BOLD}GitHub MCP${RESET}
+${DIM}The GitHub MCP server needs a token so Cursor can reach your repository, Project (v2), and issues.${RESET}`;
+}
+function githubMcpAuthSelectMessage() {
+  return `${formatGitHubMcpContextBlock()}
+
+${GITHUB_MCP_AUTH_QUESTION}`;
+}
+function githubMcpAuthSelectTheme() {
+  return {
+    style: {
+      message: (text, status) => {
+        if (status === "done") {
+          return styleText("bold", GITHUB_MCP_AUTH_QUESTION);
+        }
+        return text;
+      }
+    }
+  };
+}
+function githubMcpPasswordMessageNoGhAccounts() {
+  return `${formatGitHubMcpContextBlock()}
+
+${DIM}No GitHub CLI accounts were found (install \`gh\` and run \`gh auth login\` to sign in).${RESET}
+${DIM}You can paste a fine-grained or classic PAT with repo scope for the MCP GitHub server.${RESET}
+
+${GITHUB_MCP_TOKEN_PROMPT}`;
+}
+function githubMcpPasswordTheme() {
+  return {
+    style: {
+      message: (text, status) => {
+        if (status === "done") {
+          return styleText("bold", GITHUB_MCP_TOKEN_PROMPT);
+        }
+        return text;
+      }
+    }
+  };
+}
+function maskTokenHint(token) {
+  const t = token.trim();
+  if (t.length <= 8) {
+    return "\u2026";
+  }
+  return `${t.slice(0, 4)}\u2026${t.slice(-4)}`;
+}
+function formatAccountChoice(a) {
+  const active = a.active ? " \u2014 active" : "";
+  return `${a.account} @ ${a.host}${active}`;
+}
+async function promptGitHubMcpToken(prompts) {
+  const envToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN?.trim();
+  const accounts = await listGitHubAccounts();
+  const choices = [];
+  if (envToken) {
+    choices.push({
+      name: `Use GITHUB_PERSONAL_ACCESS_TOKEN from the environment (${maskTokenHint(envToken)})`,
+      value: { kind: "env" }
+    });
+  }
+  for (const account of accounts) {
+    choices.push({
+      name: formatAccountChoice(account),
+      value: { kind: "gh-account", account: account.account }
+    });
+  }
+  choices.push({
+    name: "Enter a personal access token manually",
+    value: { kind: "manual" }
+  });
+  if (accounts.length === 0 && !envToken) {
+    return (await prompts.password({
+      message: githubMcpPasswordMessageNoGhAccounts(),
+      theme: githubMcpPasswordTheme(),
+      validate: (value) => value.trim() ? true : "GitHub token is required."
+    })).trim();
+  }
+  const selected = await prompts.select({
+    message: githubMcpAuthSelectMessage(),
+    choices,
+    theme: githubMcpAuthSelectTheme()
+  });
+  if (selected.kind === "env") {
+    return envToken;
+  }
+  if (selected.kind === "manual") {
+    return (await prompts.password({
+      message: GITHUB_MCP_TOKEN_PROMPT,
+      validate: (value) => value.trim() ? true : "GitHub token is required."
+    })).trim();
+  }
+  const resolved = await resolveGitHubTokenForAccount(selected.account);
+  if (resolved) {
+    return resolved;
+  }
+  console.warn(
+    `${BOLD}Could not read a token for that account via \`gh auth token\`.${RESET} ${DIM}Sign in with \`gh auth login\` or enter a token below.${RESET}`
+  );
+  return (await prompts.password({
+    message: GITHUB_MCP_TOKEN_PROMPT,
+    validate: (value) => value.trim() ? true : "GitHub token is required."
+  })).trim();
+}
+async function promptDefaultMode(message, defaultValue, prompts, labels) {
+  return prompts.select({
+    message,
+    choices: [
+      { name: labels.required, value: "required" },
+      { name: labels.optional, value: "optional" }
+    ],
+    default: defaultValue
+  });
+}
+function printBanner() {
+  console.log(`
+  ${BOLD}@byrde/cursor${RESET}
+  ${DIM}Install and configure the workflow so the project starts with the
+  right backlog, review, testing, and GitHub tooling from day one.${RESET}
+`);
+}
+
+// src/cli.ts
+var packageRoot = path8.resolve(
+  path8.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+function readPackageVersion() {
+  const pkgPath = path8.join(packageRoot, "package.json");
+  const raw = readFileSync5(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  return pkg.version;
+}
+var packageVersion = readPackageVersion();
+function createProgram(deps = {}) {
+  const runInitCommand = deps.runInit ?? runInit;
+  const runQuestionnaire = deps.runInitQuestionnaire ?? runInitQuestionnaire;
+  const program = new Command();
+  program.name("byrde-cursor").description("Byrde Cursor workflow CLI and assets").version(packageVersion);
+  program.command("init").description("Interactively configure and install the workflow into the target project").option(
+    "--cwd <path>",
+    "target working directory",
+    process.cwd()
+  ).option("--skip-mcp", "skip GitHub MCP setup", false).option("--force", "overwrite managed files when needed", false).option("--verbose", "print extra diagnostics", false).action(async (options) => {
+    const questionnaire = await runQuestionnaire({
+      cwd: options.cwd,
+      existingConfig: loadProjectConfig(options.cwd)
+    });
+    await runInitCommand(
+      {
+        cwd: options.cwd,
+        skipMcp: options.skipMcp,
+        verbose: options.verbose,
+        force: options.force,
+        packageVersion,
+        projectConfig: questionnaire.projectConfig,
+        overwriteProjectConfig: questionnaire.shouldWriteProjectConfig,
+        githubMcpToken: questionnaire.githubMcpToken
+      },
+      packageRoot
+    );
+  });
+  return program;
+}
+function isExecutedAsCli() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    const modulePath = realpathSync(fileURLToPath(import.meta.url));
+    const argvPath = realpathSync(path8.resolve(entry));
+    return modulePath === argvPath;
+  } catch {
+    return false;
+  }
+}
+function reportCliFailure(err) {
+  if (err instanceof CommanderError) {
+    const code = err.exitCode ?? 1;
+    if (code !== 0) {
+      console.error(err.message);
+    }
+    process.exit(code);
+  } else if (err instanceof Error) {
+    console.error(err.message);
+    process.exit(1);
+  } else {
+    console.error(String(err));
+    process.exit(1);
+  }
+}
+if (isExecutedAsCli()) {
+  void createProgram().parseAsync(process.argv).catch(reportCliFailure);
+}
+export {
+  createProgram,
+  reportCliFailure
+};
+//# sourceMappingURL=cli.js.map