kiro-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,2067 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import process13 from "process";
+import { Command } from "commander";
+
+// src/commands/init.ts
+import fs10 from "fs";
+import path9 from "path";
+import process5 from "process";
+import readline from "readline";
+import crypto3 from "crypto";
+
+// src/core/PresetLoader.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/core/ManifestParser.ts
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+
+// src/core/errors.ts
+var KKError = class _KKError extends Error {
+  code;
+  suggestion;
+  constructor(code, message, suggestion) {
+    super(message);
+    this.name = "KKError";
+    this.code = code;
+    this.suggestion = suggestion;
+    Object.setPrototypeOf(this, _KKError.prototype);
+  }
+  format() {
+    let output = `[${this.code}] ${this.message}`;
+    if (this.suggestion) {
+      output += `
+  Suggestion: ${this.suggestion}`;
+    }
+    return output;
+  }
+};
+var ErrorCodes = {
+  NODE_VERSION: "KK001",
+  MANIFEST_INVALID: "KK010",
+  MANIFEST_MISSING_FIELD: "KK011",
+  MANIFEST_ORPHAN_FILE: "KK012",
+  MANIFEST_INCOMPLETE: "KK013",
+  PRESET_NOT_FOUND: "KK020",
+  PRESET_LOAD_FAILED: "KK021",
+  CONFLICT_UNRESOLVED: "KK030",
+  TRACKING_CORRUPT: "KK040",
+  TRACKING_WRITE_FAILED: "KK041",
+  BACKUP_NOT_FOUND: "KK050",
+  BACKUP_WRITE_FAILED: "KK051",
+  MCP_MERGE_CONFLICT: "KK060",
+  MCP_INVALID_JSON: "KK061",
+  SETTINGS_MERGE_WARN: "KK070",
+  FRONTMATTER_INVALID: "KK080",
+  FRONTMATTER_MISSING: "KK081",
+  DOCTOR_FAIL: "KK090",
+  DOCTOR_WARN: "KK091"
+};
+
+// src/core/ManifestParser.ts
+var ArtifactTypeSchema = z.enum([
+  "steering",
+  "hook",
+  "mcp",
+  "skill",
+  "agent",
+  "command",
+  "workflow",
+  "statusline",
+  "metadata",
+  "settings",
+  "env",
+  "spec",
+  "docs",
+  "doc",
+  "config",
+  "other"
+]);
+var PresetNameSchema = z.enum([
+  "frontend",
+  "backend",
+  "fullstack",
+  "mobile",
+  "devops",
+  "data-ai"
+]);
+var FileEntrySchema = z.object({
+  source: z.string().min(1),
+  target: z.string().min(1),
+  type: ArtifactTypeSchema,
+  executable: z.boolean().optional()
+});
+var MCPServerDefSchema = z.object({
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional()
+});
+var HookEntrySchema = z.union([
+  z.object({
+    matcher: z.string().optional(),
+    command: z.string().min(1)
+  }),
+  z.string().min(1)
+]);
+var ManifestSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  description: z.string().min(1),
+  category: PresetNameSchema,
+  files: z.array(FileEntrySchema).min(1),
+  dependencies: z.array(PresetNameSchema).optional(),
+  mcpServers: z.record(MCPServerDefSchema).optional(),
+  hooks: z.object({
+    PreToolUse: z.array(HookEntrySchema).optional(),
+    PostToolUse: z.array(HookEntrySchema).optional(),
+    agentStop: z.array(HookEntrySchema).optional(),
+    fileEdited: z.array(HookEntrySchema).optional()
+  }).optional(),
+  tags: z.array(z.string()).optional(),
+  minCounts: z.object({
+    agents: z.number().int().nonnegative().optional(),
+    skills: z.number().int().nonnegative().optional(),
+    commands: z.number().int().nonnegative().optional(),
+    hooks: z.number().int().nonnegative().optional(),
+    workflows: z.number().int().nonnegative().optional()
+  }).optional()
+});
+function parse(json) {
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    return {
+      ok: false,
+      error: {
+        code: ErrorCodes.MANIFEST_INVALID,
+        message: "Manifest is not valid JSON."
+      }
+    };
+  }
+  const result = ManifestSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return {
+      ok: false,
+      error: {
+        code: ErrorCodes.MANIFEST_MISSING_FIELD,
+        message: `Manifest schema validation failed: ${issues}`
+      }
+    };
+  }
+  return { ok: true, value: result.data };
+}
+
+// src/core/PresetLoader.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function getPresetsDir() {
+  const candidates = [
+    path2.resolve(__dirname, "presets"),
+    // dist/presets (current bundle)
+    path2.resolve(__dirname, "../presets"),
+    // legacy layout
+    path2.resolve(__dirname, "../../../../presets")
+    // dev/source checkout
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  throw new KKError(
+    ErrorCodes.PRESET_NOT_FOUND,
+    "Cannot locate presets directory.",
+    "Ensure kiro-kit is installed correctly."
+  );
+}
+function load(name) {
+  const presetsDir = getPresetsDir();
+  const presetDir = path2.join(presetsDir, name);
+  if (!fs2.existsSync(presetDir)) {
+    throw new KKError(
+      ErrorCodes.PRESET_NOT_FOUND,
+      `Preset "${name}" not found.`,
+      `Available presets: ${listAvailable().join(", ")}`
+    );
+  }
+  const manifestPath = path2.join(presetDir, "manifest.json");
+  if (!fs2.existsSync(manifestPath)) {
+    throw new KKError(
+      ErrorCodes.PRESET_LOAD_FAILED,
+      `Preset "${name}" is missing manifest.json.`
+    );
+  }
+  const raw = fs2.readFileSync(manifestPath, "utf-8");
+  const result = parse(raw);
+  if (!result.ok) {
+    throw new KKError(
+      ErrorCodes.PRESET_LOAD_FAILED,
+      `Preset "${name}" manifest parse error: ${result.error.message}`
+    );
+  }
+  return { manifest: result.value, dir: presetDir };
+}
+function loadAll(names) {
+  return names.map((n) => load(n));
+}
+function listAvailable() {
+  const presetsDir = getPresetsDir();
+  try {
+    return fs2.readdirSync(presetsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => !d.name.startsWith("_")).filter(
+      (d) => fs2.existsSync(path2.join(presetsDir, d.name, "manifest.json"))
+    ).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+// src/core/ConflictResolver.ts
+import fs3 from "fs";
+import crypto from "crypto";
+function sha256(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+async function resolve(opts) {
+  const { target, sourceContent, mode, sessionState, prompt, showDiff: showDiff2 } = opts;
+  if (!fs3.existsSync(target)) {
+    return "WRITE_NEW";
+  }
+  const currentContent = fs3.readFileSync(target);
+  const currentHash = sha256(currentContent);
+  const newHash = sha256(sourceContent);
+  if (currentHash === newHash) {
+    return "NO_OP";
+  }
+  if (mode === "force") {
+    return "OVERWRITE_WITH_BACKUP";
+  }
+  if (mode === "skip-existing") {
+    return "SKIP";
+  }
+  if (sessionState.overwriteAll) {
+    return "OVERWRITE_WITH_BACKUP";
+  }
+  if (!prompt) {
+    return "SKIP";
+  }
+  while (true) {
+    const choice = await prompt(target);
+    switch (choice) {
+      case "view-diff":
+        if (showDiff2) {
+          showDiff2(target, sourceContent);
+        }
+        continue;
+      case "overwrite":
+        return "OVERWRITE_WITH_BACKUP";
+      case "skip":
+        return "SKIP";
+      case "overwrite-all":
+        sessionState.overwriteAll = true;
+        return "OVERWRITE_WITH_BACKUP";
+    }
+  }
+}
+
+// src/core/BackupManager.ts
+import fs4 from "fs";
+import path3 from "path";
+var BACKUP_DIR = ".kiro/.backup";
+function generateTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}${mo}${d}-${h}${mi}${s}-${ms}`;
+}
+function backup(workspaceRoot, target, timestamp) {
+  const ts = timestamp ?? generateTimestamp();
+  const relPath = path3.relative(workspaceRoot, target);
+  const backupPath = path3.join(workspaceRoot, BACKUP_DIR, ts, relPath);
+  const backupDir = path3.dirname(backupPath);
+  fs4.mkdirSync(backupDir, { recursive: true });
+  fs4.copyFileSync(target, backupPath);
+  return ts;
+}
+function restore(workspaceRoot, timestamp) {
+  const ts = timestamp ?? getLatestTimestamp(workspaceRoot);
+  if (!ts) {
+    throw new KKError(
+      ErrorCodes.BACKUP_NOT_FOUND,
+      "No backup found.",
+      "Run kiro-kit init or add first to create backups."
+    );
+  }
+  const backupRoot = path3.join(workspaceRoot, BACKUP_DIR, ts);
+  if (!fs4.existsSync(backupRoot)) {
+    throw new KKError(
+      ErrorCodes.BACKUP_NOT_FOUND,
+      `Backup timestamp "${ts}" not found.`,
+      `Available: ${listTimestamps(workspaceRoot).join(", ") || "none"}`
+    );
+  }
+  const restored = [];
+  const walkAndRestore = (dir, relPrefix) => {
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walkAndRestore(fullPath, rel);
+      } else if (entry.isFile()) {
+        const targetPath = path3.join(workspaceRoot, rel);
+        const targetDir = path3.dirname(targetPath);
+        fs4.mkdirSync(targetDir, { recursive: true });
+        fs4.copyFileSync(fullPath, targetPath);
+        restored.push(rel);
+      }
+    }
+  };
+  walkAndRestore(backupRoot, "");
+  return restored;
+}
+function listTimestamps(workspaceRoot) {
+  const backupBase = path3.join(workspaceRoot, BACKUP_DIR);
+  if (!fs4.existsSync(backupBase)) return [];
+  try {
+    return fs4.readdirSync(backupBase, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+function getLatestTimestamp(workspaceRoot) {
+  const timestamps = listTimestamps(workspaceRoot);
+  return timestamps[0];
+}
+
+// src/core/TrackingStore.ts
+import fs5 from "fs";
+import path4 from "path";
+
+// src/utils/logger.ts
+import process3 from "process";
+
+// src/utils/color.ts
+import pc from "picocolors";
+import process2 from "process";
+var isColorDisabled = !!process2.env["NO_COLOR"] || process2.argv.includes("--no-color") || !process2.stdout.isTTY;
+function wrap(fn) {
+  return (s) => isColorDisabled ? s : fn(s);
+}
+var color = {
+  green: wrap(pc.green),
+  red: wrap(pc.red),
+  yellow: wrap(pc.yellow),
+  blue: wrap(pc.blue),
+  cyan: wrap(pc.cyan),
+  gray: wrap(pc.gray),
+  bold: wrap(pc.bold),
+  dim: wrap(pc.dim)
+};
+
+// src/utils/logger.ts
+var verboseEnabled = false;
+var quietEnabled = false;
+function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+function setQuiet(enabled) {
+  quietEnabled = enabled;
+}
+var logger = {
+  info(msg) {
+    if (!quietEnabled) {
+      process3.stdout.write(`${msg}
+`);
+    }
+  },
+  success(msg) {
+    if (!quietEnabled) {
+      process3.stdout.write(`${color.green(msg)}
+`);
+    }
+  },
+  warn(msg) {
+    process3.stderr.write(`${color.yellow("WARN")} ${msg}
+`);
+  },
+  error(msg) {
+    process3.stderr.write(`${color.red("ERROR")} ${msg}
+`);
+  },
+  debug(msg) {
+    if (verboseEnabled) {
+      process3.stderr.write(`${color.dim("[debug]")} ${msg}
+`);
+    }
+  }
+};
+
+// src/core/TrackingStore.ts
+var TRACKING_FILE = ".kiro/.kiro-kit.json";
+function getTrackingPath(workspaceRoot) {
+  return path4.join(workspaceRoot, TRACKING_FILE);
+}
+function read(workspaceRoot) {
+  const filePath = getTrackingPath(workspaceRoot);
+  if (!fs5.existsSync(filePath)) {
+    return null;
+  }
+  const raw = fs5.readFileSync(filePath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    logger.warn(`Tracking file is corrupt: ${filePath}`);
+    throw new KKError(
+      ErrorCodes.TRACKING_CORRUPT,
+      "Tracking file .kiro/.kiro-kit.json is corrupt (invalid JSON).",
+      "Delete the file and re-run kiro-kit init to regenerate."
+    );
+  }
+}
+function write(workspaceRoot, data) {
+  const filePath = getTrackingPath(workspaceRoot);
+  const dir = path4.dirname(filePath);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function upsertPreset(data, preset) {
+  const existing = data.presets.findIndex((p) => p.name === preset.name);
+  if (existing >= 0) {
+    data.presets[existing] = preset;
+  } else {
+    data.presets.push(preset);
+  }
+  data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return data;
+}
+function createInitial(kitVersion) {
+  return {
+    kitVersion,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    presets: []
+  };
+}
+
+// src/core/MetadataWriter.ts
+import fs6 from "fs";
+import path5 from "path";
+var METADATA_FILE = ".kiro/metadata.json";
+function compose(opts) {
+  return {
+    version: "1.0.0",
+    name: "kiro-kit",
+    description: "Kiro IDE workspace bootstrapped by kiro-kit.",
+    buildDate: (/* @__PURE__ */ new Date()).toISOString(),
+    repository: opts.repository,
+    presets: opts.presets,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    kitVersion: opts.kitVersion
+  };
+}
+function write2(workspaceRoot, metadata) {
+  const filePath = path5.join(workspaceRoot, METADATA_FILE);
+  const dir = path5.dirname(filePath);
+  fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(filePath, JSON.stringify(metadata, null, 2) + "\n", "utf-8");
+}
+function read2(workspaceRoot) {
+  const filePath = path5.join(workspaceRoot, METADATA_FILE);
+  if (!fs6.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function mergePresets(existing, newPresets) {
+  const merged = [...existing.presets];
+  for (const p of newPresets) {
+    const idx = merged.findIndex((m) => m.name === p.name);
+    if (idx >= 0) {
+      merged[idx] = p;
+    } else {
+      merged.push(p);
+    }
+  }
+  return { ...existing, presets: merged, buildDate: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+// src/core/StatuslineSelector.ts
+import fs7 from "fs";
+import path6 from "path";
+import process4 from "process";
+var STATUSLINE_FILES = ["statusline.js", "statusline.sh", "statusline.ps1"];
+function getCommand() {
+  switch (process4.platform) {
+    case "win32":
+      return "powershell -ExecutionPolicy Bypass -File .kiro/statusline.ps1";
+    default:
+      return "node .kiro/statusline.js";
+  }
+}
+function install(presetDir, workspaceRoot) {
+  const installed = [];
+  const targetDir = path6.join(workspaceRoot, ".kiro");
+  fs7.mkdirSync(targetDir, { recursive: true });
+  for (const file of STATUSLINE_FILES) {
+    const source = path6.join(presetDir, file);
+    if (!fs7.existsSync(source)) continue;
+    const target = path6.join(targetDir, file);
+    fs7.copyFileSync(source, target);
+    installed.push(`.kiro/${file}`);
+    if (file.endsWith(".sh") && process4.platform !== "win32") {
+      try {
+        fs7.chmodSync(target, 493);
+      } catch {
+      }
+    }
+  }
+  return installed;
+}
+function resolveSettingsCommand(settings) {
+  const statusLine = settings["statusLine"];
+  if (statusLine && statusLine["type"] === "command") {
+    statusLine["command"] = getCommand();
+  }
+  return settings;
+}
+
+// src/core/merge/mergeMCP.ts
+function mergeMCP(existing, presetServers, presetName) {
+  const result = existing ? structuredClone(existing) : { mcpServers: {} };
+  if (!result.mcpServers) {
+    result.mcpServers = {};
+  }
+  for (const [serverName, def] of Object.entries(presetServers)) {
+    if (serverName in result.mcpServers) {
+      logger.warn(
+        `MCP server "${serverName}" already exists, keeping user definition.` + (presetName ? ` (from preset: ${presetName})` : "")
+      );
+      continue;
+    }
+    result.mcpServers[serverName] = structuredClone(def);
+  }
+  return result;
+}
+
+// src/core/merge/mergeSettings.ts
+function mergeSettings(existing, preset) {
+  const result = existing ? structuredClone(existing) : {};
+  if (preset.hooks) {
+    if (!result.hooks) result.hooks = {};
+    for (const key of ["PreToolUse", "PostToolUse", "agentStop"]) {
+      const presetArr = preset.hooks[key];
+      if (!presetArr || presetArr.length === 0) continue;
+      const existingArr = result.hooks[key] ?? [];
+      const existingCommands = new Set(existingArr.map((h) => h.command));
+      for (const hook of presetArr) {
+        if (!existingCommands.has(hook.command)) {
+          existingArr.push(structuredClone(hook));
+        }
+      }
+      result.hooks[key] = existingArr;
+    }
+  }
+  if (preset.statusLine !== void 0) {
+    if (result.statusLine !== void 0) {
+      logger.warn("statusLine already set in settings, overwriting with preset value.");
+    }
+    result.statusLine = structuredClone(preset.statusLine);
+  }
+  if (preset.includeCoAuthoredBy !== void 0) {
+    if (result.includeCoAuthoredBy !== void 0 && result.includeCoAuthoredBy !== preset.includeCoAuthoredBy) {
+      logger.warn("includeCoAuthoredBy already set, overwriting with preset value.");
+    }
+    result.includeCoAuthoredBy = preset.includeCoAuthoredBy;
+  }
+  return result;
+}
+
+// src/prompts/DiffViewer.ts
+import fs8 from "fs";
+import { createTwoFilesPatch } from "diff";
+function showDiff(target, sourceContent) {
+  const existing = fs8.existsSync(target) ? fs8.readFileSync(target, "utf-8") : "";
+  const incoming = sourceContent.toString("utf-8");
+  const patch = createTwoFilesPatch(
+    `a/${target}`,
+    `b/${target}`,
+    existing,
+    incoming,
+    "current",
+    "incoming",
+    { context: 3 }
+  );
+  const lines = patch.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      process.stdout.write(color.green(line) + "\n");
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      process.stdout.write(color.red(line) + "\n");
+    } else if (line.startsWith("@@")) {
+      process.stdout.write(color.cyan(line) + "\n");
+    } else {
+      process.stdout.write(line + "\n");
+    }
+  }
+}
+
+// src/utils/fs-safe.ts
+import fs9 from "fs";
+import path7 from "path";
+import crypto2 from "crypto";
+import os from "os";
+var LF_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".yaml", ".yml"]);
+function getLineEnding(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  if (LF_EXTENSIONS.has(ext)) return "\n";
+  return os.EOL;
+}
+function normalizeLineEndings(content, filePath) {
+  const eol = getLineEnding(filePath);
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\n") return normalized;
+  return normalized.replace(/\n/g, eol);
+}
+function atomicWrite(target, content) {
+  const dir = path7.dirname(target);
+  fs9.mkdirSync(dir, { recursive: true });
+  const rand = crypto2.randomBytes(6).toString("hex");
+  const tmpPath = path7.join(dir, `.tmp.${rand}`);
+  let data;
+  if (typeof content === "string") {
+    const normalized = normalizeLineEndings(content, target);
+    data = Buffer.from(normalized, "utf-8");
+  } else {
+    data = content;
+  }
+  try {
+    fs9.writeFileSync(tmpPath, data);
+    fs9.renameSync(tmpPath, target);
+  } catch (err) {
+    try {
+      fs9.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/utils/paths.ts
+import path8 from "path";
+function safePathInside(workspaceRoot, target) {
+  const resolved = path8.resolve(workspaceRoot, target);
+  const root = path8.resolve(workspaceRoot);
+  return resolved.startsWith(root + path8.sep) || resolved === root;
+}
+
+// src/commands/init.ts
+function setupSigintHandler() {
+  process5.on("SIGINT", () => {
+    process5.exit(130);
+  });
+}
+async function multiPickPrompt(items) {
+  const selected = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  const rl = readline.createInterface({
+    input: process5.stdin,
+    output: process5.stdout,
+    terminal: false
+  });
+  if (!process5.stdin.isTTY) {
+    rl.close();
+    return [];
+  }
+  return new Promise((resolve2, reject) => {
+    const render = () => {
+      if (cursor >= 0) {
+        process5.stdout.write(`\x1B[${items.length + 1}A`);
+      }
+      process5.stdout.write(
+        color.bold("? Select presets to install:") + color.dim(" (Space to select, <a> toggle all, Enter to confirm)") + "\n"
+      );
+      for (let i = 0; i < items.length; i++) {
+        const marker = cursor === i ? color.cyan(">") : " ";
+        const check = selected.has(i) ? color.green("[x]") : "[ ]";
+        const name = color.bold(items[i].name.padEnd(12));
+        const desc = color.dim(`- ${items[i].description}`);
+        process5.stdout.write(`  ${marker} ${check} ${name} ${desc}
+`);
+      }
+    };
+    process5.stdout.write("\n".repeat(items.length + 1));
+    render();
+    process5.stdin.setRawMode(true);
+    process5.stdin.resume();
+    process5.stdin.setEncoding("utf-8");
+    const onData = (key) => {
+      if (key === "") {
+        process5.stdin.setRawMode(false);
+        process5.stdin.removeListener("data", onData);
+        process5.stdin.pause();
+        rl.close();
+        reject(new Error("SIGINT"));
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        process5.stdin.setRawMode(false);
+        process5.stdin.removeListener("data", onData);
+        process5.stdin.pause();
+        rl.close();
+        const result = [...selected].map((i) => items[i].name);
+        resolve2(result);
+        return;
+      }
+      if (key === " ") {
+        if (selected.has(cursor)) {
+          selected.delete(cursor);
+        } else {
+          selected.add(cursor);
+        }
+        render();
+        return;
+      }
+      if (key === "a" || key === "A") {
+        if (selected.size === items.length) {
+          selected.clear();
+        } else {
+          for (let i = 0; i < items.length; i++) selected.add(i);
+        }
+        render();
+        return;
+      }
+      if (key === "\x1B[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+        return;
+      }
+      if (key === "\x1B[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+        render();
+        return;
+      }
+    };
+    process5.stdin.on("data", onData);
+  });
+}
+async function confirmPrompt(message) {
+  if (!process5.stdin.isTTY) return true;
+  return new Promise((resolve2, reject) => {
+    const rl = readline.createInterface({
+      input: process5.stdin,
+      output: process5.stdout
+    });
+    rl.question(`${color.bold("?")} ${message} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve2(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      reject(new Error("SIGINT"));
+    });
+  });
+}
+async function conflictPrompt(target) {
+  if (!process5.stdin.isTTY) return "skip";
+  const relTarget = path9.relative(process5.cwd(), target);
+  process5.stdout.write(
+    `
+${color.yellow("?")} File ${color.bold(relTarget)} already exists with different content.
+  ${color.cyan(">")} overwrite       - Replace existing file (backup will be saved)
+    skip            - Keep existing file
+    view diff       - Show unified diff and ask again
+    overwrite all   - Replace this and all remaining conflicting files
+`
+  );
+  return new Promise((resolve2, reject) => {
+    const rl = readline.createInterface({
+      input: process5.stdin,
+      output: process5.stdout
+    });
+    rl.question(`  Choice (overwrite/skip/diff/all): `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "o" || a === "overwrite") resolve2("overwrite");
+      else if (a === "s" || a === "skip") resolve2("skip");
+      else if (a === "d" || a === "diff" || a === "view diff") resolve2("view-diff");
+      else if (a === "a" || a === "all" || a === "overwrite all") resolve2("overwrite-all");
+      else resolve2("skip");
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      reject(new Error("SIGINT"));
+    });
+  });
+}
+function sha2562(data) {
+  return crypto3.createHash("sha256").update(data).digest("hex");
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize workspace with selected presets").option("-y, --yes", "Skip confirmation, accept defaults").option("--preset <name>", "Specify preset (repeatable)", collectPreset, []).option("--force", "Overwrite all files (with backup)").option("--skip-existing", "Skip all existing files").option("--no-color", "Disable ANSI colors").action(async (opts) => {
+    setupSigintHandler();
+    try {
+      await runInit(opts);
+    } catch (err) {
+      if (err instanceof Error && err.message === "SIGINT") {
+        process5.exit(130);
+      }
+      logger.error(err instanceof Error ? err.message : String(err));
+      process5.exit(1);
+    }
+  });
+}
+function collectPreset(value, previous) {
+  return [...previous, value];
+}
+async function runInit(opts) {
+  const workspaceRoot = process5.cwd();
+  const available = listAvailable();
+  let selectedNames;
+  if (opts.preset && opts.preset.length > 0) {
+    for (const name of opts.preset) {
+      if (!available.includes(name)) {
+        logger.error(
+          `Preset "${name}" not found. Available: ${available.join(", ")}`
+        );
+        process5.exit(1);
+      }
+    }
+    selectedNames = opts.preset;
+  } else {
+    const items = available.map((name) => {
+      try {
+        const preset = load(name);
+        return { name, description: preset.manifest.description };
+      } catch {
+        return { name, description: "" };
+      }
+    });
+    selectedNames = await multiPickPrompt(items);
+  }
+  if (selectedNames.length === 0) {
+    logger.info("No presets selected. Exiting.");
+    process5.exit(0);
+  }
+  const presets = loadAll(selectedNames);
+  let totalFiles = 0;
+  for (const preset of presets) {
+    totalFiles += preset.manifest.files.length;
+  }
+  if (!opts.yes) {
+    const confirmed = await confirmPrompt(
+      `About to write ${totalFiles} files into .kiro/ and workspace. Continue? (Y/n)`
+    );
+    if (!confirmed) {
+      logger.info("Cancelled.");
+      process5.exit(0);
+    }
+  }
+  let mode = "interactive";
+  if (opts.force) mode = "force";
+  else if (opts.skipExisting) mode = "skip-existing";
+  else if (opts.yes) mode = "skip-existing";
+  const sessionState = { overwriteAll: false };
+  const timestamp = generateTimestamp2();
+  const allTrackedFiles = [];
+  let filesWritten = 0;
+  let filesSkipped = 0;
+  for (const preset of presets) {
+    const { manifest, dir: presetDir } = preset;
+    const regularFiles = manifest.files.filter(
+      (f) => !["mcp", "settings", "statusline"].includes(f.type)
+    );
+    const mcpFiles = manifest.files.filter((f) => f.type === "mcp");
+    const settingsFiles = manifest.files.filter((f) => f.type === "settings");
+    const statuslineFiles = manifest.files.filter((f) => f.type === "statusline");
+    for (const fileEntry of regularFiles) {
+      const sourcePath = path9.join(presetDir, fileEntry.source);
+      const targetPath = path9.resolve(workspaceRoot, fileEntry.target);
+      if (!safePathInside(workspaceRoot, fileEntry.target)) {
+        logger.warn(`Skipping unsafe path: ${fileEntry.target}`);
+        filesSkipped++;
+        continue;
+      }
+      if (!fs10.existsSync(sourcePath)) {
+        logger.debug(`Source file missing: ${sourcePath}`);
+        continue;
+      }
+      const sourceContent = fs10.readFileSync(sourcePath);
+      const action = await resolve({
+        target: targetPath,
+        sourceContent,
+        mode,
+        sessionState,
+        prompt: conflictPrompt,
+        showDiff: (t, s) => showDiff(t, s)
+      });
+      switch (action) {
+        case "WRITE_NEW":
+          fs10.mkdirSync(path9.dirname(targetPath), { recursive: true });
+          atomicWrite(targetPath, sourceContent.toString("utf-8"));
+          if (fileEntry.executable && process5.platform !== "win32") {
+            try {
+              fs10.chmodSync(targetPath, 493);
+            } catch {
+            }
+          }
+          filesWritten++;
+          break;
+        case "OVERWRITE_WITH_BACKUP":
+          backup(workspaceRoot, targetPath, timestamp);
+          atomicWrite(targetPath, sourceContent.toString("utf-8"));
+          if (fileEntry.executable && process5.platform !== "win32") {
+            try {
+              fs10.chmodSync(targetPath, 493);
+            } catch {
+            }
+          }
+          filesWritten++;
+          break;
+        case "SKIP":
+          filesSkipped++;
+          break;
+        case "NO_OP":
+          break;
+      }
+      if (action !== "SKIP") {
+        allTrackedFiles.push({
+          target: fileEntry.target,
+          sourcePreset: manifest.name,
+          contentHash: sha2562(sourceContent),
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    if (statuslineFiles.length > 0) {
+      const installed = install(presetDir, workspaceRoot);
+      filesWritten += installed.length;
+      for (const f of installed) {
+        allTrackedFiles.push({
+          target: f,
+          sourcePreset: manifest.name,
+          contentHash: "",
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    if (mcpFiles.length > 0 && manifest.mcpServers) {
+      const mcpPath = path9.join(workspaceRoot, ".kiro/settings/mcp.json");
+      let existingMcp = null;
+      if (fs10.existsSync(mcpPath)) {
+        try {
+          existingMcp = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
+        } catch {
+          existingMcp = null;
+        }
+      }
+      const merged = mergeMCP(existingMcp, manifest.mcpServers, manifest.name);
+      fs10.mkdirSync(path9.dirname(mcpPath), { recursive: true });
+      atomicWrite(mcpPath, JSON.stringify(merged, null, 2) + "\n");
+      filesWritten++;
+    }
+    if (settingsFiles.length > 0) {
+      const settingsPath = path9.join(workspaceRoot, ".kiro/settings.json");
+      let existingSettings = null;
+      if (fs10.existsSync(settingsPath)) {
+        try {
+          existingSettings = JSON.parse(
+            fs10.readFileSync(settingsPath, "utf-8")
+          );
+        } catch {
+          existingSettings = null;
+        }
+      }
+      const presetSettingsPath = path9.join(presetDir, "settings.json");
+      if (fs10.existsSync(presetSettingsPath)) {
+        const presetSettings = JSON.parse(
+          fs10.readFileSync(presetSettingsPath, "utf-8")
+        );
+        const resolvedSettings = resolveSettingsCommand(
+          presetSettings
+        );
+        const merged = mergeSettings(existingSettings, resolvedSettings);
+        fs10.mkdirSync(path9.dirname(settingsPath), { recursive: true });
+        atomicWrite(settingsPath, JSON.stringify(merged, null, 2) + "\n");
+        filesWritten++;
+      }
+    }
+    const mcpExampleSource = path9.join(presetDir, ".mcp.json.example");
+    if (fs10.existsSync(mcpExampleSource)) {
+      const mcpExampleTarget = path9.join(workspaceRoot, ".kiro/.mcp.json.example");
+      if (!fs10.existsSync(mcpExampleTarget)) {
+        fs10.mkdirSync(path9.dirname(mcpExampleTarget), { recursive: true });
+        fs10.copyFileSync(mcpExampleSource, mcpExampleTarget);
+      }
+    }
+  }
+  const kitVersion = getKitVersion();
+  const presetMetas = presets.map((p) => ({
+    name: p.manifest.name,
+    version: p.manifest.version
+  }));
+  const existingMeta = read2(workspaceRoot);
+  const metadata = existingMeta ? mergePresets(existingMeta, presetMetas) : compose({
+    kitVersion,
+    repository: "https://github.com/ihatesea69/kiro-kit.git",
+    presets: presetMetas
+  });
+  write2(workspaceRoot, metadata);
+  let trackingData = read(workspaceRoot) ?? createInitial(kitVersion);
+  for (const preset of presets) {
+    const presetFiles = allTrackedFiles.filter(
+      (f) => f.sourcePreset === preset.manifest.name
+    );
+    const trackedPreset = {
+      name: preset.manifest.name,
+      version: preset.manifest.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: presetFiles
+    };
+    trackingData = upsertPreset(trackingData, trackedPreset);
+  }
+  trackingData.kitVersion = kitVersion;
+  write(workspaceRoot, trackingData);
+  logger.success(
+    `Done! ${filesWritten} files written, ${filesSkipped} skipped.`
+  );
+  logger.info(
+    `Presets installed: ${selectedNames.join(", ")}`
+  );
+}
+function generateTimestamp2() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}${mo}${d}-${h}${mi}${s}-${ms}`;
+}
+function getKitVersion() {
+  try {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    return pkg2.version;
+  } catch {
+    return "0.1.0";
+  }
+}
+
+// src/commands/add.ts
+import fs11 from "fs";
+import path10 from "path";
+import process6 from "process";
+import crypto4 from "crypto";
+function sha2563(data) {
+  return crypto4.createHash("sha256").update(data).digest("hex");
+}
+function generateTimestamp3() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}${mo}${d}-${h}${mi}${s}-${ms}`;
+}
+function getKitVersion2() {
+  try {
+    const pkgPath = new URL("../../package.json", import.meta.url);
+    const pkg2 = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    return pkg2.version;
+  } catch {
+    return "0.1.0";
+  }
+}
+async function conflictPrompt2(target) {
+  if (!process6.stdin.isTTY) return "skip";
+  const { default: readline2 } = await import("readline");
+  const relTarget = path10.relative(process6.cwd(), target);
+  process6.stdout.write(
+    `
+${color.yellow("?")} File ${color.bold(relTarget)} already exists with different content.
+  ${color.cyan(">")} overwrite       - Replace existing file (backup will be saved)
+    skip            - Keep existing file
+    view diff       - Show unified diff and ask again
+    overwrite all   - Replace this and all remaining conflicting files
+`
+  );
+  return new Promise((resolve2) => {
+    const rl = readline2.createInterface({ input: process6.stdin, output: process6.stdout });
+    rl.question(`  Choice (overwrite/skip/diff/all): `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "o" || a === "overwrite") resolve2("overwrite");
+      else if (a === "s" || a === "skip") resolve2("skip");
+      else if (a === "d" || a === "diff" || a === "view diff") resolve2("view-diff");
+      else if (a === "a" || a === "all" || a === "overwrite all") resolve2("overwrite-all");
+      else resolve2("skip");
+    });
+  });
+}
+function registerAddCommand(program2) {
+  program2.command("add <preset>").description("Add a preset to existing workspace").option("-y, --yes", "Skip confirmation").option("--force", "Overwrite all files (with backup)").option("--skip-existing", "Skip all existing files").option("--no-color", "Disable ANSI colors").action(async (presetName, opts) => {
+    try {
+      await runAdd(presetName, opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process6.exit(1);
+    }
+  });
+}
+async function runAdd(presetName, opts) {
+  const workspaceRoot = process6.cwd();
+  const available = listAvailable();
+  if (!available.includes(presetName)) {
+    logger.error(
+      `Preset "${presetName}" not found. Available: ${available.join(", ")}`
+    );
+    process6.exit(1);
+  }
+  const kiroDir = path10.join(workspaceRoot, ".kiro");
+  if (!fs11.existsSync(kiroDir)) {
+    fs11.mkdirSync(kiroDir, { recursive: true });
+    logger.info("Created .kiro/ directory.");
+  }
+  const preset = load(presetName);
+  let mode = "interactive";
+  if (opts.force) mode = "force";
+  else if (opts.skipExisting) mode = "skip-existing";
+  else if (opts.yes) mode = "skip-existing";
+  const sessionState = { overwriteAll: false };
+  const timestamp = generateTimestamp3();
+  const allTrackedFiles = [];
+  let filesWritten = 0;
+  let filesSkipped = 0;
+  const { manifest, dir: presetDir } = preset;
+  const regularFiles = manifest.files.filter(
+    (f) => !["mcp", "settings", "statusline"].includes(f.type)
+  );
+  const statuslineFiles = manifest.files.filter((f) => f.type === "statusline");
+  for (const fileEntry of regularFiles) {
+    const sourcePath = path10.join(presetDir, fileEntry.source);
+    const targetPath = path10.resolve(workspaceRoot, fileEntry.target);
+    if (!safePathInside(workspaceRoot, fileEntry.target)) {
+      logger.warn(`Skipping unsafe path: ${fileEntry.target}`);
+      filesSkipped++;
+      continue;
+    }
+    if (!fs11.existsSync(sourcePath)) {
+      logger.debug(`Source file missing: ${sourcePath}`);
+      continue;
+    }
+    const sourceContent = fs11.readFileSync(sourcePath);
+    const action = await resolve({
+      target: targetPath,
+      sourceContent,
+      mode,
+      sessionState,
+      prompt: conflictPrompt2,
+      showDiff: (t, s) => showDiff(t, s)
+    });
+    switch (action) {
+      case "WRITE_NEW":
+        fs11.mkdirSync(path10.dirname(targetPath), { recursive: true });
+        atomicWrite(targetPath, sourceContent.toString("utf-8"));
+        if (fileEntry.executable && process6.platform !== "win32") {
+          try {
+            fs11.chmodSync(targetPath, 493);
+          } catch {
+          }
+        }
+        filesWritten++;
+        break;
+      case "OVERWRITE_WITH_BACKUP":
+        backup(workspaceRoot, targetPath, timestamp);
+        atomicWrite(targetPath, sourceContent.toString("utf-8"));
+        if (fileEntry.executable && process6.platform !== "win32") {
+          try {
+            fs11.chmodSync(targetPath, 493);
+          } catch {
+          }
+        }
+        filesWritten++;
+        break;
+      case "SKIP":
+        filesSkipped++;
+        break;
+      case "NO_OP":
+        break;
+    }
+    if (action !== "SKIP") {
+      allTrackedFiles.push({
+        target: fileEntry.target,
+        sourcePreset: manifest.name,
+        contentHash: sha2563(sourceContent),
+        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  if (statuslineFiles.length > 0) {
+    const installed = install(presetDir, workspaceRoot);
+    filesWritten += installed.length;
+    for (const f of installed) {
+      allTrackedFiles.push({
+        target: f,
+        sourcePreset: manifest.name,
+        contentHash: "",
+        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  if (manifest.mcpServers) {
+    const mcpPath = path10.join(workspaceRoot, ".kiro/settings/mcp.json");
+    let existingMcp = null;
+    if (fs11.existsSync(mcpPath)) {
+      try {
+        existingMcp = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
+      } catch {
+        existingMcp = null;
+      }
+    }
+    const merged = mergeMCP(existingMcp, manifest.mcpServers, manifest.name);
+    fs11.mkdirSync(path10.dirname(mcpPath), { recursive: true });
+    atomicWrite(mcpPath, JSON.stringify(merged, null, 2) + "\n");
+    filesWritten++;
+  }
+  const presetSettingsPath = path10.join(presetDir, "settings.json");
+  if (fs11.existsSync(presetSettingsPath)) {
+    const settingsPath = path10.join(workspaceRoot, ".kiro/settings.json");
+    let existingSettings = null;
+    if (fs11.existsSync(settingsPath)) {
+      try {
+        existingSettings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+      } catch {
+        existingSettings = null;
+      }
+    }
+    const presetSettings = JSON.parse(fs11.readFileSync(presetSettingsPath, "utf-8"));
+    const resolvedSettings = resolveSettingsCommand(
+      presetSettings
+    );
+    const merged = mergeSettings(existingSettings, resolvedSettings);
+    fs11.mkdirSync(path10.dirname(settingsPath), { recursive: true });
+    atomicWrite(settingsPath, JSON.stringify(merged, null, 2) + "\n");
+    filesWritten++;
+  }
+  const kitVersion = getKitVersion2();
+  const presetMeta = { name: manifest.name, version: manifest.version };
+  const existingMeta = read2(workspaceRoot);
+  const metadata = existingMeta ? mergePresets(existingMeta, [presetMeta]) : compose({ kitVersion, repository: "https://github.com/ihatesea69/kiro-kit.git", presets: [presetMeta] });
+  write2(workspaceRoot, metadata);
+  let trackingData = read(workspaceRoot) ?? createInitial(kitVersion);
+  const trackedPreset = {
+    name: manifest.name,
+    version: manifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: allTrackedFiles
+  };
+  trackingData = upsertPreset(trackingData, trackedPreset);
+  trackingData.kitVersion = kitVersion;
+  write(workspaceRoot, trackingData);
+  logger.success(`Done! ${filesWritten} files written, ${filesSkipped} skipped.`);
+  logger.info(`Preset added: ${presetName}`);
+}
+
+// src/commands/list.ts
+import process7 from "process";
+function countArtifacts(files) {
+  const counts = {
+    agent: 0,
+    skill: 0,
+    command: 0,
+    hook: 0,
+    workflow: 0,
+    mcp: 0
+  };
+  for (const f of files) {
+    if (f.type in counts) {
+      counts[f.type]++;
+    }
+  }
+  return counts;
+}
+function registerListCommand(program2) {
+  program2.command("list").description("List available presets").option("--json", "Output as JSON").action((opts) => {
+    try {
+      runList(opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process7.exit(1);
+    }
+  });
+}
+function runList(opts) {
+  const available = listAvailable();
+  const summaries = [];
+  for (const name of available) {
+    try {
+      const preset = load(name);
+      const counts = countArtifacts(preset.manifest.files);
+      summaries.push({
+        name,
+        description: preset.manifest.description,
+        agents: counts["agent"],
+        skills: counts["skill"],
+        commands: counts["command"],
+        hooks: counts["hook"],
+        workflows: counts["workflow"],
+        mcp: Object.keys(preset.manifest.mcpServers ?? {}).length
+      });
+    } catch {
+      summaries.push({
+        name,
+        description: "(failed to load)",
+        agents: 0,
+        skills: 0,
+        commands: 0,
+        hooks: 0,
+        workflows: 0,
+        mcp: 0
+      });
+    }
+  }
+  if (opts.json) {
+    process7.stdout.write(JSON.stringify(summaries, null, 2) + "\n");
+    return;
+  }
+  for (const s of summaries) {
+    const nameStr = color.bold(s.name.padEnd(12));
+    const descStr = color.dim(`- ${s.description}`);
+    process7.stdout.write(`  ${nameStr} ${descStr}
+`);
+    const counts = `${s.agents} agents, ${s.skills} skills, ${s.commands} commands, ${s.hooks} hooks, ${s.workflows} workflows, ${s.mcp} MCP servers`;
+    process7.stdout.write(`${"".padEnd(14)} ${color.gray(counts)}
+`);
+  }
+}
+
+// src/commands/info.ts
+import process8 from "process";
+function registerInfoCommand(program2) {
+  program2.command("info <preset>").description("Show detailed preset information").option("--json", "Output as JSON").action((presetName, opts) => {
+    try {
+      runInfo(presetName, opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process8.exit(1);
+    }
+  });
+}
+function runInfo(presetName, opts) {
+  const available = listAvailable();
+  if (!available.includes(presetName)) {
+    logger.error(
+      `Preset "${presetName}" not found. Available: ${available.join(", ")}`
+    );
+    process8.exit(1);
+  }
+  const preset = load(presetName);
+  const { manifest } = preset;
+  const agents = manifest.files.filter((f) => f.type === "agent").map((f) => f.source);
+  const skills = manifest.files.filter((f) => f.type === "skill").map((f) => f.source);
+  const commands = manifest.files.filter((f) => f.type === "command").map((f) => f.source);
+  const workflows = manifest.files.filter((f) => f.type === "workflow").map((f) => f.source);
+  const hooks = manifest.files.filter((f) => f.type === "hook").map((f) => f.source);
+  const mcpServers = Object.keys(manifest.mcpServers ?? {});
+  const info = {
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description,
+    category: manifest.category,
+    files: manifest.files.map((f) => ({ source: f.source, target: f.target, type: f.type })),
+    mcpServers,
+    hooks,
+    agents,
+    skills,
+    commands,
+    workflows
+  };
+  if (opts.json) {
+    process8.stdout.write(JSON.stringify(info, null, 2) + "\n");
+    return;
+  }
+  process8.stdout.write(`
+${color.bold(manifest.name)} v${manifest.version}
+`);
+  process8.stdout.write(`${manifest.description}
+
+`);
+  process8.stdout.write(`${color.dim("Category:")} ${manifest.category}
+`);
+  process8.stdout.write(`${color.dim("Total files:")} ${manifest.files.length}
+
+`);
+  if (mcpServers.length > 0) {
+    process8.stdout.write(`${color.bold("MCP Servers")} (${mcpServers.length}):
+`);
+    for (const s of mcpServers) {
+      process8.stdout.write(`  - ${s}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  if (agents.length > 0) {
+    process8.stdout.write(`${color.bold("Agents")} (${agents.length}):
+`);
+    for (const a of agents) {
+      process8.stdout.write(`  - ${a}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  if (skills.length > 0) {
+    process8.stdout.write(`${color.bold("Skills")} (${skills.length}):
+`);
+    for (const s of skills) {
+      process8.stdout.write(`  - ${s}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  if (commands.length > 0) {
+    process8.stdout.write(`${color.bold("Commands")} (${commands.length}):
+`);
+    for (const c of commands) {
+      process8.stdout.write(`  - ${c}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  if (workflows.length > 0) {
+    process8.stdout.write(`${color.bold("Workflows")} (${workflows.length}):
+`);
+    for (const w of workflows) {
+      process8.stdout.write(`  - ${w}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  if (hooks.length > 0) {
+    process8.stdout.write(`${color.bold("Hooks")} (${hooks.length}):
+`);
+    for (const h of hooks) {
+      process8.stdout.write(`  - ${h}
+`);
+    }
+    process8.stdout.write("\n");
+  }
+  process8.stdout.write(`${color.bold("File Targets")}:
+`);
+  for (const f of manifest.files) {
+    process8.stdout.write(`  ${color.dim(f.type.padEnd(12))} ${f.target}
+`);
+  }
+}
+
+// src/commands/update.ts
+import fs12 from "fs";
+import path11 from "path";
+import process9 from "process";
+import crypto5 from "crypto";
+function sha2564(data) {
+  return crypto5.createHash("sha256").update(data).digest("hex");
+}
+function generateTimestamp4() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}${mo}${d}-${h}${mi}${s}-${ms}`;
+}
+function getKitVersion3() {
+  try {
+    const pkgPath = new URL("../../package.json", import.meta.url);
+    const pkg2 = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    return pkg2.version;
+  } catch {
+    return "0.1.0";
+  }
+}
+async function conflictPrompt3(target) {
+  if (!process9.stdin.isTTY) return "skip";
+  const { default: readline2 } = await import("readline");
+  const relTarget = path11.relative(process9.cwd(), target);
+  process9.stdout.write(
+    `
+${color.yellow("?")} File ${color.bold(relTarget)} has changed in the new version.
+  ${color.cyan(">")} overwrite       - Replace with new version (backup saved)
+    skip            - Keep current file
+    view diff       - Show unified diff and ask again
+    overwrite all   - Replace all remaining changed files
+`
+  );
+  return new Promise((resolve2) => {
+    const rl = readline2.createInterface({ input: process9.stdin, output: process9.stdout });
+    rl.question(`  Choice (overwrite/skip/diff/all): `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "o" || a === "overwrite") resolve2("overwrite");
+      else if (a === "s" || a === "skip") resolve2("skip");
+      else if (a === "d" || a === "diff" || a === "view diff") resolve2("view-diff");
+      else if (a === "a" || a === "all" || a === "overwrite all") resolve2("overwrite-all");
+      else resolve2("skip");
+    });
+  });
+}
+function registerUpdateCommand(program2) {
+  program2.command("update").description("Update installed presets to latest bundled version").option("-y, --yes", "Skip confirmation, auto-skip conflicts").option("--force", "Overwrite all changed files (with backup)").option("--skip-existing", "Skip all changed files").action(async (opts) => {
+    try {
+      await runUpdate(opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process9.exit(1);
+    }
+  });
+}
+async function runUpdate(opts) {
+  const workspaceRoot = process9.cwd();
+  const tracking = read(workspaceRoot);
+  if (!tracking || tracking.presets.length === 0) {
+    logger.info("No presets installed. Nothing to update.");
+    process9.exit(0);
+  }
+  let mode = "interactive";
+  if (opts.force) mode = "force";
+  else if (opts.skipExisting) mode = "skip-existing";
+  else if (opts.yes) mode = "skip-existing";
+  const sessionState = { overwriteAll: false };
+  const timestamp = generateTimestamp4();
+  let totalUpdated = 0;
+  let totalSkipped = 0;
+  for (const trackedPreset of tracking.presets) {
+    let bundled;
+    try {
+      bundled = load(trackedPreset.name);
+    } catch {
+      logger.warn(`Preset "${trackedPreset.name}" not found in bundled presets. Skipping.`);
+      continue;
+    }
+    const bundledVersion = bundled.manifest.version;
+    if (bundledVersion === trackedPreset.version) {
+      logger.debug(`Preset "${trackedPreset.name}" is up to date (v${bundledVersion}).`);
+      continue;
+    }
+    logger.info(
+      `Updating ${color.bold(trackedPreset.name)}: v${trackedPreset.version} -> v${bundledVersion}`
+    );
+    const presetDir = bundled.dir;
+    const updatedFiles = [];
+    for (const fileEntry of bundled.manifest.files) {
+      if (["mcp", "settings", "statusline"].includes(fileEntry.type)) continue;
+      const sourcePath = path11.join(presetDir, fileEntry.source);
+      const targetPath = path11.resolve(workspaceRoot, fileEntry.target);
+      if (!safePathInside(workspaceRoot, fileEntry.target)) continue;
+      if (!fs12.existsSync(sourcePath)) continue;
+      const sourceContent = fs12.readFileSync(sourcePath);
+      const newHash = sha2564(sourceContent);
+      const trackedFile = trackedPreset.files.find((f) => f.target === fileEntry.target);
+      if (trackedFile && trackedFile.contentHash === newHash) {
+        continue;
+      }
+      const action = await resolve({
+        target: targetPath,
+        sourceContent,
+        mode,
+        sessionState,
+        prompt: conflictPrompt3,
+        showDiff: (t, s) => showDiff(t, s)
+      });
+      switch (action) {
+        case "WRITE_NEW":
+          fs12.mkdirSync(path11.dirname(targetPath), { recursive: true });
+          atomicWrite(targetPath, sourceContent.toString("utf-8"));
+          if (fileEntry.executable && process9.platform !== "win32") {
+            try {
+              fs12.chmodSync(targetPath, 493);
+            } catch {
+            }
+          }
+          totalUpdated++;
+          break;
+        case "OVERWRITE_WITH_BACKUP":
+          backup(workspaceRoot, targetPath, timestamp);
+          atomicWrite(targetPath, sourceContent.toString("utf-8"));
+          if (fileEntry.executable && process9.platform !== "win32") {
+            try {
+              fs12.chmodSync(targetPath, 493);
+            } catch {
+            }
+          }
+          totalUpdated++;
+          break;
+        case "SKIP":
+          totalSkipped++;
+          break;
+        case "NO_OP":
+          break;
+      }
+      updatedFiles.push({
+        target: fileEntry.target,
+        sourcePreset: bundled.manifest.name,
+        contentHash: newHash,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    trackedPreset.version = bundledVersion;
+    trackedPreset.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const uf of updatedFiles) {
+      const idx = trackedPreset.files.findIndex((f) => f.target === uf.target);
+      if (idx >= 0) {
+        trackedPreset.files[idx] = uf;
+      } else {
+        trackedPreset.files.push(uf);
+      }
+    }
+  }
+  tracking.kitVersion = getKitVersion3();
+  tracking.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  write(workspaceRoot, tracking);
+  if (totalUpdated === 0 && totalSkipped === 0) {
+    logger.success("All presets are up to date.");
+  } else {
+    logger.success(`Update complete: ${totalUpdated} files updated, ${totalSkipped} skipped.`);
+  }
+}
+
+// src/commands/restore.ts
+import process10 from "process";
+function registerRestoreCommand(program2) {
+  program2.command("restore").description("Restore files from backup").option("--timestamp <ts>", "Restore from specific backup timestamp").option("--list", "List available backup timestamps").action((opts) => {
+    try {
+      runRestore(opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process10.exit(1);
+    }
+  });
+}
+function runRestore(opts) {
+  const workspaceRoot = process10.cwd();
+  if (opts.list) {
+    const timestamps2 = listTimestamps(workspaceRoot);
+    if (timestamps2.length === 0) {
+      logger.info("No backups available.");
+      process10.exit(0);
+    }
+    process10.stdout.write(`${color.bold("Available backups")}:
+`);
+    for (const ts of timestamps2) {
+      process10.stdout.write(`  ${ts}
+`);
+    }
+    process10.exit(0);
+  }
+  const timestamps = listTimestamps(workspaceRoot);
+  if (timestamps.length === 0) {
+    logger.error("No backups found. Nothing to restore.");
+    process10.exit(1);
+  }
+  const restored = restore(workspaceRoot, opts.timestamp);
+  if (restored.length === 0) {
+    logger.info("No files to restore from backup.");
+    process10.exit(0);
+  }
+  process10.stdout.write(`${color.bold("Restored files")}:
+`);
+  for (const file of restored) {
+    process10.stdout.write(`  ${color.green("+")} ${file}
+`);
+  }
+  logger.success(`Restored ${restored.length} files.`);
+}
+
+// src/commands/doctor.ts
+import fs13 from "fs";
+import path12 from "path";
+import process11 from "process";
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Run workspace health checks").option("--fix", "Auto-fix fixable issues").action((opts) => {
+    try {
+      runDoctor(opts);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process11.exit(1);
+    }
+  });
+}
+function runDoctor(opts) {
+  const workspaceRoot = process11.cwd();
+  const checks = [];
+  checks.push(checkNodeVersion());
+  checks.push(checkKiroDir(workspaceRoot));
+  checks.push(checkMcpJson(workspaceRoot));
+  checks.push(checkTracking(workspaceRoot));
+  checks.push(checkTrackedFiles(workspaceRoot));
+  checks.push(checkSteeringFrontMatter(workspaceRoot));
+  checks.push(checkMetadataJson(workspaceRoot));
+  checks.push(checkStatuslineExecBit(workspaceRoot));
+  let hasFail = false;
+  for (const check of checks) {
+    const tag = formatTag(check.result);
+    process11.stdout.write(`${tag} ${check.message}
+`);
+    if (check.result === "FAIL") hasFail = true;
+    if (opts.fix && check.fixable && check.fixAction) {
+      check.fixAction();
+      process11.stdout.write(`       ${color.green("Fixed!")}
+`);
+    }
+  }
+  process11.exit(hasFail ? 1 : 0);
+}
+function formatTag(result) {
+  switch (result) {
+    case "PASS":
+      return color.green("[PASS]");
+    case "FAIL":
+      return color.red("[FAIL]");
+    case "WARN":
+      return color.yellow("[WARN]");
+  }
+}
+function checkNodeVersion() {
+  const major2 = parseInt(process11.versions.node.split(".")[0], 10);
+  if (major2 >= 18) {
+    return {
+      name: "node-version",
+      result: "PASS",
+      message: `Node.js version >= 18 (${process11.version})`
+    };
+  }
+  return {
+    name: "node-version",
+    result: "FAIL",
+    message: `Node.js version >= 18 required (current: ${process11.version})`
+  };
+}
+function checkKiroDir(workspaceRoot) {
+  const kiroDir = path12.join(workspaceRoot, ".kiro");
+  if (fs13.existsSync(kiroDir) && fs13.statSync(kiroDir).isDirectory()) {
+    return { name: "kiro-dir", result: "PASS", message: ".kiro/ directory exists" };
+  }
+  return {
+    name: "kiro-dir",
+    result: "FAIL",
+    message: ".kiro/ directory not found. Run `kiro-kit init` to create it."
+  };
+}
+function checkMcpJson(workspaceRoot) {
+  const mcpPath = path12.join(workspaceRoot, ".kiro/settings/mcp.json");
+  if (!fs13.existsSync(mcpPath)) {
+    return { name: "mcp-json", result: "WARN", message: ".kiro/settings/mcp.json not found (optional)" };
+  }
+  try {
+    const content = fs13.readFileSync(mcpPath, "utf-8");
+    JSON.parse(content);
+    return { name: "mcp-json", result: "PASS", message: ".kiro/settings/mcp.json is valid JSON" };
+  } catch {
+    return {
+      name: "mcp-json",
+      result: "FAIL",
+      message: ".kiro/settings/mcp.json is not valid JSON",
+      fixable: true,
+      fixAction: () => {
+        const mcpPath2 = path12.join(workspaceRoot, ".kiro/settings/mcp.json");
+        fs13.writeFileSync(mcpPath2, '{\n  "mcpServers": {}\n}\n', "utf-8");
+      }
+    };
+  }
+}
+function checkTracking(workspaceRoot) {
+  const trackingPath = path12.join(workspaceRoot, ".kiro/.kiro-kit.json");
+  if (!fs13.existsSync(trackingPath)) {
+    return { name: "tracking", result: "WARN", message: ".kiro/.kiro-kit.json not found (no presets installed)" };
+  }
+  try {
+    const content = fs13.readFileSync(trackingPath, "utf-8");
+    JSON.parse(content);
+    return { name: "tracking", result: "PASS", message: ".kiro/.kiro-kit.json is valid" };
+  } catch {
+    return {
+      name: "tracking",
+      result: "FAIL",
+      message: ".kiro/.kiro-kit.json is corrupt (invalid JSON)"
+    };
+  }
+}
+function checkTrackedFiles(workspaceRoot) {
+  let tracking;
+  try {
+    tracking = read(workspaceRoot);
+  } catch {
+    return { name: "tracked-files", result: "WARN", message: "Cannot read tracking file, skipping file check" };
+  }
+  if (!tracking || tracking.presets.length === 0) {
+    return { name: "tracked-files", result: "PASS", message: "No tracked files to verify" };
+  }
+  const missing = [];
+  for (const preset of tracking.presets) {
+    for (const file of preset.files) {
+      const fullPath = path12.resolve(workspaceRoot, file.target);
+      if (!fs13.existsSync(fullPath)) {
+        missing.push(file.target);
+      }
+    }
+  }
+  if (missing.length === 0) {
+    return { name: "tracked-files", result: "PASS", message: "All tracked files exist on disk" };
+  }
+  return {
+    name: "tracked-files",
+    result: "FAIL",
+    message: `${missing.length} tracked file(s) missing: ${missing.slice(0, 3).join(", ")}${missing.length > 3 ? "..." : ""}`
+  };
+}
+function checkSteeringFrontMatter(workspaceRoot) {
+  const steeringDir = path12.join(workspaceRoot, ".kiro/steering");
+  if (!fs13.existsSync(steeringDir)) {
+    return { name: "steering-fm", result: "PASS", message: "No steering files to check" };
+  }
+  const issues = [];
+  const walkDir = (dir) => {
+    let entries;
+    try {
+      entries = fs13.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path12.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        checkSingleSteering(fullPath, issues);
+      }
+    }
+  };
+  walkDir(steeringDir);
+  if (issues.length === 0) {
+    return { name: "steering-fm", result: "PASS", message: "Steering front-matter has no trailing whitespace" };
+  }
+  return {
+    name: "steering-fm",
+    result: "WARN",
+    message: `${issues.length} steering file(s) have trailing whitespace in front-matter`,
+    fixable: true,
+    fixAction: () => {
+      fixSteeringWhitespace(steeringDir);
+    }
+  };
+}
+function checkSingleSteering(filePath, issues) {
+  try {
+    const content = fs13.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    if (lines[0]?.trim() !== "---") return;
+    let endIdx = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === "---") {
+        endIdx = i;
+        break;
+      }
+    }
+    if (endIdx === -1) return;
+    for (let i = 1; i < endIdx; i++) {
+      if (lines[i] !== lines[i].trimEnd()) {
+        issues.push(filePath);
+        return;
+      }
+    }
+  } catch {
+  }
+}
+function fixSteeringWhitespace(steeringDir) {
+  const walkAndFix = (dir) => {
+    let entries;
+    try {
+      entries = fs13.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path12.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkAndFix(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = fs13.readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        if (lines[0]?.trim() !== "---") continue;
+        let endIdx = -1;
+        for (let i = 1; i < lines.length; i++) {
+          if (lines[i]?.trim() === "---") {
+            endIdx = i;
+            break;
+          }
+        }
+        if (endIdx === -1) continue;
+        let changed = false;
+        for (let i = 1; i < endIdx; i++) {
+          const trimmed = lines[i].trimEnd();
+          if (lines[i] !== trimmed) {
+            lines[i] = trimmed;
+            changed = true;
+          }
+        }
+        if (changed) {
+          fs13.writeFileSync(fullPath, lines.join("\n"), "utf-8");
+        }
+      }
+    }
+  };
+  walkAndFix(steeringDir);
+}
+function checkMetadataJson(workspaceRoot) {
+  const metaPath = path12.join(workspaceRoot, ".kiro/metadata.json");
+  if (!fs13.existsSync(metaPath)) {
+    return { name: "metadata-json", result: "WARN", message: ".kiro/metadata.json not found (optional)" };
+  }
+  try {
+    const content = fs13.readFileSync(metaPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.version || !parsed.name) {
+      return { name: "metadata-json", result: "FAIL", message: ".kiro/metadata.json missing required fields (version, name)" };
+    }
+    return { name: "metadata-json", result: "PASS", message: ".kiro/metadata.json is valid" };
+  } catch {
+    return { name: "metadata-json", result: "FAIL", message: ".kiro/metadata.json is not valid JSON" };
+  }
+}
+function checkStatuslineExecBit(workspaceRoot) {
+  if (process11.platform === "win32") {
+    return { name: "statusline-exec", result: "PASS", message: "Statusline exec bit check (skipped on Windows)" };
+  }
+  const shPath = path12.join(workspaceRoot, ".kiro/statusline.sh");
+  if (!fs13.existsSync(shPath)) {
+    return { name: "statusline-exec", result: "PASS", message: "No statusline.sh to check" };
+  }
+  try {
+    const stat = fs13.statSync(shPath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (isExecutable) {
+      return { name: "statusline-exec", result: "PASS", message: "statusline.sh is executable" };
+    }
+    return {
+      name: "statusline-exec",
+      result: "WARN",
+      message: "statusline.sh is not executable",
+      fixable: true,
+      fixAction: () => {
+        fs13.chmodSync(shPath, 493);
+      }
+    };
+  } catch {
+    return { name: "statusline-exec", result: "WARN", message: "Cannot check statusline.sh permissions" };
+  }
+}
+
+// src/commands/telemetry.ts
+import fs14 from "fs";
+import path13 from "path";
+import os2 from "os";
+import process12 from "process";
+var CONFIG_DIR = path13.join(os2.homedir(), ".kiro-kit");
+var CONFIG_FILE = path13.join(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    if (fs14.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs14.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return { telemetry: false };
+}
+function writeConfig(config) {
+  fs14.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs14.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function registerTelemetryCommand(program2) {
+  const telemetry = program2.command("telemetry").description("Manage anonymous usage telemetry");
+  telemetry.command("enable").description("Opt in to anonymous telemetry").action(() => {
+    try {
+      const config = readConfig();
+      config.telemetry = true;
+      writeConfig(config);
+      logger.success("Telemetry enabled. Anonymous usage data will be collected.");
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process12.exit(1);
+    }
+  });
+  telemetry.command("disable").description("Opt out of telemetry").action(() => {
+    try {
+      const config = readConfig();
+      config.telemetry = false;
+      writeConfig(config);
+      logger.success("Telemetry disabled. No data will be collected.");
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process12.exit(1);
+    }
+  });
+  telemetry.command("status").description("Show current telemetry status").action(() => {
+    try {
+      const config = readConfig();
+      const status = config.telemetry ? color.green("enabled") : color.yellow("disabled");
+      process12.stdout.write(`Telemetry: ${status}
+`);
+      process12.stdout.write(`Config: ${CONFIG_FILE}
+`);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process12.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var major = parseInt(process13.versions.node.split(".")[0], 10);
+if (major < 18) {
+  process13.stderr.write(
+    `[KK001] kiro-kit requires Node.js >= 18. Current version: ${process13.version}. Please upgrade Node.js.
+`
+  );
+  process13.exit(1);
+}
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command();
+program.name("kiro-kit").description("CLI tool for bootstrapping engineer-grade Kiro IDE workspaces.").version(pkg.version, "-v, --version");
+program.option("--verbose", "Enable verbose output");
+program.option("--quiet", "Suppress non-essential output");
+program.option("--no-color", "Disable colored output");
+registerInitCommand(program);
+registerAddCommand(program);
+registerListCommand(program);
+registerInfoCommand(program);
+registerUpdateCommand(program);
+registerRestoreCommand(program);
+registerDoctorCommand(program);
+registerTelemetryCommand(program);
+program.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts["verbose"]) setVerbose(true);
+  if (opts["quiet"]) setQuiet(true);
+});
+program.parse(process13.argv);
+//# sourceMappingURL=index.js.map