@mikulgohil/ai-kit 1.1.0 → 1.2.1

package/dist/index.js

@@ -13,15 +13,20 @@ var TEMPLATES_DIR = path.join(PACKAGE_ROOT, "templates");
 var COMMANDS_DIR = path.join(PACKAGE_ROOT, "commands");
 var GUIDES_DIR = path.join(PACKAGE_ROOT, "guides");
 var DOCS_SCAFFOLDS_DIR = path.join(PACKAGE_ROOT, "docs-scaffolds");
-var VERSION = "1.1.0";
+var AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
+var CONTEXTS_DIR = path.join(PACKAGE_ROOT, "contexts");
+var VERSION = "1.2.0";
 var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
 var GENERATED_FILES = {
   claudeMd: "CLAUDE.md",
   cursorRules: ".cursorrules",
   cursorMdcDir: ".cursor/rules",
   claudeSettings: ".claude/settings.json",
+  claudeSettingsLocal: ".claude/settings.local.json",
   claudeCommands: ".claude/commands",
   claudeSkills: ".claude/skills",
+  claudeAgents: ".claude/agents",
+  claudeContexts: ".claude/contexts",
   cursorSkills: ".cursor/skills"
 };
 var TEMPLATE_FRAGMENTS = [
@@ -36,8 +41,8 @@ var TEMPLATE_FRAGMENTS = [
 ];
 
 // src/commands/init.ts
-import path15 from "path";
-import fs6 from "fs-extra";
+import path17 from "path";
+import fs8 from "fs-extra";
 import { select, confirm } from "@inquirer/prompts";
 import ora from "ora";
 
@@ -307,6 +312,7 @@ function detectTools(projectPath, pkg) {
     storybook: detectStorybook(projectPath, deps),
     eslint: detectEslint(projectPath, deps),
     prettier: detectPrettier(projectPath, deps),
+    biome: detectBiome(projectPath, deps),
     axeCore: detectAxeCore(deps),
     snyk: detectSnyk(projectPath, deps),
     knip: detectKnip(projectPath, deps),
@@ -362,6 +368,12 @@ function detectPrettier(projectPath, deps) {
   }
   return false;
 }
+function detectBiome(projectPath, deps) {
+  if ("@biomejs/biome" in deps) return true;
+  if (fileExists(path8.join(projectPath, "biome.json"))) return true;
+  if (fileExists(path8.join(projectPath, "biome.jsonc"))) return true;
+  return false;
+}
 function detectAxeCore(deps) {
   return "@axe-core/playwright" in deps || "axe-core" in deps;
 }
@@ -675,11 +687,107 @@ function generateConfig(scan, templates, commands, guides, options) {
     templates,
     commands,
     guides,
+    agents: options?.agents || [],
+    contexts: options?.contexts || [],
+    hooks: options?.hooks || false,
+    hookProfile: options?.hookProfile || "standard",
     strictness: options?.strictness || "standard",
     customFragments: options?.customFragments || []
   };
 }
 
+// src/generator/hooks.ts
+function generateHooks(scan, profile = "standard") {
+  const hooks = {};
+  const preToolUse = [];
+  const postToolUse = [];
+  const stop = [];
+  preToolUse.push({
+    matcher: "Bash(git push*)",
+    hooks: [
+      {
+        type: "command",
+        command: 'echo "\u26A0\uFE0F  Review your changes before pushing. Run tests and type-check first."'
+      }
+    ]
+  });
+  if (scan.tools.biome) {
+    postToolUse.push({
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `npx @biomejs/biome check --write --unsafe "$CLAUDE_FILE_PATH" 2>/dev/null || true`
+        }
+      ]
+    });
+  } else if (scan.tools.prettier) {
+    postToolUse.push({
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `npx prettier --write "$CLAUDE_FILE_PATH" 2>/dev/null || true`
+        }
+      ]
+    });
+  }
+  if (scan.typescript && profile !== "minimal") {
+    postToolUse.push({
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: 'case "$CLAUDE_FILE_PATH" in *.ts|*.tsx) npx tsc --noEmit --pretty 2>&1 | head -20 ;; esac'
+        }
+      ]
+    });
+  }
+  if (scan.tools.eslint && profile === "strict") {
+    postToolUse.push({
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: 'case "$CLAUDE_FILE_PATH" in *.ts|*.tsx|*.js|*.jsx) npx eslint "$CLAUDE_FILE_PATH" --max-warnings 0 2>&1 | head -15 ;; esac'
+        }
+      ]
+    });
+  }
+  if (profile !== "minimal") {
+    postToolUse.push({
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: 'case "$CLAUDE_FILE_PATH" in *.ts|*.tsx|*.js|*.jsx) grep -n "console\\.log" "$CLAUDE_FILE_PATH" && echo "\u26A0\uFE0F  console.log detected \u2014 remove before committing" || true ;; esac'
+        }
+      ]
+    });
+  }
+  if (profile === "strict") {
+    stop.push({
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: 'git diff --name-only --diff-filter=M 2>/dev/null | grep -E "\\.(ts|tsx|js|jsx)$" | xargs grep -l "console\\.log" 2>/dev/null && echo "\u26A0\uFE0F  console.log found in modified files" || true'
+        }
+      ]
+    });
+  }
+  if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
+  if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
+  if (stop.length > 0) hooks.Stop = stop;
+  return hooks;
+}
+function generateSettingsLocal(scan, profile = "standard") {
+  const hooks = generateHooks(scan, profile);
+  return {
+    hooks
+  };
+}
+
 // src/copier/skills.ts
 import path12 from "path";
 import fs3 from "fs-extra";
@@ -715,14 +823,16 @@ var AVAILABLE_SKILLS = [
   "bundle-check",
   "i18n-check",
   "schema-gen",
-  "docker-debug",
-  "ci-fix",
   "changelog",
   "release",
   "storybook-gen",
-  "visual-diff",
-  "db-migrate",
-  "dependency-graph"
+  // New skills (v1.2.0) — hooks, agents, sessions, orchestration
+  "save-session",
+  "resume-session",
+  "checkpoint",
+  "orchestrate",
+  "quality-gate",
+  "harness-audit"
 ];
 var SKILL_DESCRIPTIONS = {
   "prompt-help": "Help developers write effective AI prompts with structured context",
@@ -756,14 +866,16 @@ var SKILL_DESCRIPTIONS = {
   "bundle-check": "Analyze bundle size, find heavy imports, suggest tree-shaking and code splitting",
   "i18n-check": "Find hardcoded strings, missing translation keys, and internationalization gaps",
   "schema-gen": "Generate TypeScript types and Zod schemas from API responses, JSON, or GraphQL",
-  "docker-debug": "Analyze Dockerfiles for security, efficiency, and best practice violations",
-  "ci-fix": "Debug CI/CD pipeline failures, optimize caching, and improve build performance",
   "changelog": "Generate formatted changelogs from git history following Keep a Changelog format",
   "release": "Guided release workflow with versioning, changelog, tagging, and release notes",
   "storybook-gen": "Generate Storybook stories with controls, play functions, and visual tests",
-  "visual-diff": "Visual regression testing plan for changed components and pages",
-  "db-migrate": "Create safe database migrations with rollback strategies for Prisma, Drizzle, or SQL",
-  "dependency-graph": "Map module dependencies, find circular imports, and analyze coupling metrics"
+  // New skills (v1.2.0) — hooks, agents, sessions, orchestration
+  "save-session": "Persist current session context, decisions, and pending work for later resumption",
+  "resume-session": "Restore context from a previous session and continue where you left off",
+  "checkpoint": "Create a verification snapshot \u2014 run all quality checks and record pass/fail status",
+  "orchestrate": "Multi-agent orchestration \u2014 break complex tasks into subtasks and delegate to agents",
+  "quality-gate": "Run comprehensive quality checks: types, lint, format, tests, bundle, a11y, security",
+  "harness-audit": "Audit AI agent configuration \u2014 check CLAUDE.md, hooks, agents, skills, MCP servers"
 };
 async function copySkills(targetDir) {
   const copied = [];
@@ -802,7 +914,8 @@ var AVAILABLE_GUIDES = [
   "prompt-playbook",
   "when-to-use-ai",
   "token-saving-tips",
-  "figma-workflow"
+  "figma-workflow",
+  "hooks-and-agents"
 ];
 async function copyGuides(targetDir) {
   const guidesTarget = path13.join(targetDir, "ai-kit", "guides");
@@ -841,12 +954,76 @@ async function scaffoldDocs(targetDir) {
   return created;
 }
 
+// src/copier/agents.ts
+import path15 from "path";
+import fs6 from "fs-extra";
+var UNIVERSAL_AGENTS = [
+  "planner",
+  "code-reviewer",
+  "security-reviewer",
+  "build-resolver",
+  "doc-updater",
+  "refactor-cleaner"
+];
+var CONDITIONAL_AGENTS = [
+  {
+    name: "e2e-runner",
+    condition: (scan) => scan.tools.playwright
+  },
+  {
+    name: "sitecore-specialist",
+    condition: (scan) => scan.cms !== "none"
+  }
+];
+async function copyAgents(targetDir, scan) {
+  const agentsTarget = path15.join(targetDir, ".claude", "agents");
+  await fs6.ensureDir(agentsTarget);
+  const copied = [];
+  for (const agent of UNIVERSAL_AGENTS) {
+    const src = path15.join(AGENTS_DIR, `${agent}.md`);
+    if (!await fs6.pathExists(src)) continue;
+    await fs6.copy(src, path15.join(agentsTarget, `${agent}.md`), {
+      overwrite: true
+    });
+    copied.push(agent);
+  }
+  for (const { name, condition } of CONDITIONAL_AGENTS) {
+    if (!condition(scan)) continue;
+    const src = path15.join(AGENTS_DIR, `${name}.md`);
+    if (!await fs6.pathExists(src)) continue;
+    await fs6.copy(src, path15.join(agentsTarget, `${name}.md`), {
+      overwrite: true
+    });
+    copied.push(name);
+  }
+  return copied;
+}
+
+// src/copier/contexts.ts
+import path16 from "path";
+import fs7 from "fs-extra";
+var AVAILABLE_CONTEXTS = ["dev", "review", "research"];
+async function copyContexts(targetDir) {
+  const contextsTarget = path16.join(targetDir, ".claude", "contexts");
+  await fs7.ensureDir(contextsTarget);
+  const copied = [];
+  for (const context of AVAILABLE_CONTEXTS) {
+    const src = path16.join(CONTEXTS_DIR, `${context}.md`);
+    if (!await fs7.pathExists(src)) continue;
+    await fs7.copy(src, path16.join(contextsTarget, `${context}.md`), {
+      overwrite: true
+    });
+    copied.push(context);
+  }
+  return copied;
+}
+
 // src/commands/init.ts
 async function initCommand(targetPath) {
-  const projectDir = path15.resolve(targetPath || process.cwd());
+  const projectDir = path17.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Project Setup");
   logInfo(`Scanning: ${projectDir}`);
-  const configPath = path15.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path17.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
     const overwrite = await confirm({
       message: "AI Kit is already configured in this project. Re-initialize?",
@@ -874,14 +1051,20 @@ async function initCommand(targetPath) {
   logInfo(`TypeScript: ${scan.typescript ? "Yes" : "No"}`);
   logInfo(`Monorepo: ${scan.monorepo ? `Yes (${scan.monorepoTool})` : "No"}`);
   logInfo(`Package Manager: ${scan.packageManager}`);
+  logInfo(`Formatter: ${scan.tools.biome ? "Biome" : scan.tools.prettier ? "Prettier" : "None detected"}`);
   const clarifications = await askClarifications(scan);
   scan = applyClarifications(scan, clarifications);
   const tools = await selectTools();
   const strictness = await selectStrictness();
+  const hookProfile = await selectHookProfile();
   const customFragments = loadCustomFragments(projectDir);
   const conflict = await selectConflictStrategy(projectDir);
   logSection("Generating Files");
-  const results = await generate(projectDir, scan, tools, conflict, { strictness, customFragments });
+  const results = await generate(projectDir, scan, tools, conflict, {
+    strictness,
+    customFragments,
+    hookProfile
+  });
   logSection("Setup Complete");
   if (results.claudeMd) logSuccess(`CLAUDE.md generated`);
   if (results.cursorRules) logSuccess(`.cursorrules generated`);
@@ -889,6 +1072,12 @@ async function initCommand(targetPath) {
     logSuccess(`${results.cursorMdcFiles} .cursor/rules/*.mdc files generated`);
   if (results.commands.length > 0)
     logSuccess(`${results.commands.length} skills generated (.claude/skills/ + .cursor/skills/)`);
+  if (results.agents.length > 0)
+    logSuccess(`${results.agents.length} agents generated (.claude/agents/)`);
+  if (results.contexts.length > 0)
+    logSuccess(`${results.contexts.length} context modes generated (.claude/contexts/)`);
+  if (results.hooks)
+    logSuccess(`Hooks configured (.claude/settings.local.json) \u2014 profile: ${hookProfile}`);
   if (results.guides.length > 0)
     logSuccess(`${results.guides.length} guides added to ai-kit/guides/`);
   if (results.docs.length > 0)
@@ -896,6 +1085,7 @@ async function initCommand(targetPath) {
   showRecommendations(scan);
   console.log("");
   logInfo("Run `ai-kit update` anytime to refresh configs after project changes.");
+  logInfo("Run `ai-kit audit` to check your AI agent configuration health.");
   logInfo("Check ai-kit/guides/getting-started.md to get started.");
 }
 function formatFramework(scan) {
@@ -953,8 +1143,28 @@ async function selectStrictness() {
     default: "standard"
   });
 }
+async function selectHookProfile() {
+  return select({
+    message: "Hook automation profile (runs checks automatically as you code):",
+    choices: [
+      {
+        name: "Standard \u2014 auto-format + typecheck + console.log warnings",
+        value: "standard"
+      },
+      {
+        name: "Strict \u2014 all standard hooks + ESLint + stop checks",
+        value: "strict"
+      },
+      {
+        name: "Minimal \u2014 auto-format + git push safety only",
+        value: "minimal"
+      }
+    ],
+    default: "standard"
+  });
+}
 async function selectConflictStrategy(projectDir) {
-  const hasExisting = fileExists(path15.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path15.join(projectDir, GENERATED_FILES.cursorRules));
+  const hasExisting = fileExists(path17.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path17.join(projectDir, GENERATED_FILES.cursorRules));
   if (!hasExisting) return "overwrite";
   return select({
     message: "Existing AI config files detected. How should we handle conflicts?",
@@ -977,34 +1187,45 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     cursorRules: false,
     cursorMdcFiles: 0,
     commands: [],
+    agents: [],
+    contexts: [],
+    hooks: false,
     guides: [],
     docs: []
   };
   if (tools.claude) {
-    const claudeMdPath = path15.join(projectDir, GENERATED_FILES.claudeMd);
+    const claudeMdPath = path17.join(projectDir, GENERATED_FILES.claudeMd);
     if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
       const content = generateClaudeMd(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
-      await fs6.writeFile(claudeMdPath, content, "utf-8");
+      await fs8.writeFile(claudeMdPath, content, "utf-8");
       result.claudeMd = true;
     } else {
       logWarning("CLAUDE.md exists, skipping");
     }
     result.commands = await copySkills(projectDir);
+    result.agents = await copyAgents(projectDir, scan);
+    result.contexts = await copyContexts(projectDir);
+    const hookProfile = opts?.hookProfile || "standard";
+    const settingsLocalPath = path17.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocal = generateSettingsLocal(scan, hookProfile);
+    await fs8.ensureDir(path17.dirname(settingsLocalPath));
+    await fs8.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+    result.hooks = true;
   }
   if (tools.cursor) {
-    const cursorPath = path15.join(projectDir, GENERATED_FILES.cursorRules);
+    const cursorPath = path17.join(projectDir, GENERATED_FILES.cursorRules);
     if (conflict === "overwrite" || !fileExists(cursorPath)) {
       const content = generateCursorRules(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
-      await fs6.writeFile(cursorPath, content, "utf-8");
+      await fs8.writeFile(cursorPath, content, "utf-8");
       result.cursorRules = true;
     } else {
       logWarning(".cursorrules exists, skipping");
     }
-    const mdcDir = path15.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs6.ensureDir(mdcDir);
+    const mdcDir = path17.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs8.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs6.writeFile(path15.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs8.writeFile(path17.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     result.cursorMdcFiles = mdcFiles.length;
   }
@@ -1013,9 +1234,16 @@ async function generate(projectDir, scan, tools, conflict, opts) {
   const templates = [];
   if (result.claudeMd) templates.push("CLAUDE.md");
   if (result.cursorRules) templates.push(".cursorrules");
-  const config = generateConfig(scan, templates, result.commands, result.guides, { strictness: opts?.strictness, customFragments: opts?.customFragments });
-  await fs6.writeJson(
-    path15.join(projectDir, AI_KIT_CONFIG_FILE),
+  const config = generateConfig(scan, templates, result.commands, result.guides, {
+    strictness: opts?.strictness,
+    customFragments: opts?.customFragments,
+    agents: result.agents,
+    contexts: result.contexts,
+    hooks: result.hooks,
+    hookProfile: opts?.hookProfile
+  });
+  await fs8.writeJson(
+    path17.join(projectDir, AI_KIT_CONFIG_FILE),
     config,
     { spaces: 2 }
   );
@@ -1034,9 +1262,9 @@ function showRecommendations(scan) {
       hint: "  npm install -D eslint @typescript-eslint/eslint-plugin"
     },
     {
-      check: scan.tools.prettier,
-      label: "Prettier not detected \u2014 install for code formatting:",
-      hint: "  npm install -D prettier"
+      check: scan.tools.prettier || scan.tools.biome,
+      label: "No formatter detected \u2014 install Prettier or Biome for auto-formatting hooks:",
+      hint: "  npm install -D prettier  (or)  npm install -D @biomejs/biome"
     },
     {
       check: scan.tools.axeCore,
@@ -1091,13 +1319,13 @@ function showRecommendations(scan) {
 }
 
 // src/commands/update.ts
-import path16 from "path";
-import fs7 from "fs-extra";
+import path18 from "path";
+import fs9 from "fs-extra";
 import ora2 from "ora";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function updateCommand(targetPath) {
-  const projectDir = path16.resolve(targetPath || process.cwd());
-  const configPath = path16.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path18.resolve(targetPath || process.cwd());
+  const configPath = path18.join(projectDir, AI_KIT_CONFIG_FILE);
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
     return;
@@ -1124,57 +1352,75 @@ async function updateCommand(targetPath) {
   spinner.succeed("Project re-scanned");
   logSection("Updating Files");
   const strictness = existingConfig.strictness || "standard";
+  const hookProfile = existingConfig.hookProfile || "standard";
   const customFragments = loadCustomFragments(projectDir);
   const genOpts = { strictness, customFragments };
   const templates = [];
-  if (existingConfig.templates.includes("CLAUDE.md") || fileExists(path16.join(projectDir, GENERATED_FILES.claudeMd))) {
-    const claudeMdPath = path16.join(projectDir, GENERATED_FILES.claudeMd);
+  if (existingConfig.templates.includes("CLAUDE.md") || fileExists(path18.join(projectDir, GENERATED_FILES.claudeMd))) {
+    const claudeMdPath = path18.join(projectDir, GENERATED_FILES.claudeMd);
     const newContent = generateClaudeMd(scan, genOpts);
     const existing = readFileSafe(claudeMdPath);
     if (existing) {
-      await fs7.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs9.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs7.writeFile(claudeMdPath, newContent, "utf-8");
+      await fs9.writeFile(claudeMdPath, newContent, "utf-8");
     }
     templates.push("CLAUDE.md");
     logSuccess("CLAUDE.md updated");
   }
-  if (existingConfig.templates.includes(".cursorrules") || fileExists(path16.join(projectDir, GENERATED_FILES.cursorRules))) {
-    const cursorRulesPath = path16.join(projectDir, GENERATED_FILES.cursorRules);
+  if (existingConfig.templates.includes(".cursorrules") || fileExists(path18.join(projectDir, GENERATED_FILES.cursorRules))) {
+    const cursorRulesPath = path18.join(projectDir, GENERATED_FILES.cursorRules);
     const newContent = generateCursorRules(scan, genOpts);
     const existing = readFileSafe(cursorRulesPath);
     if (existing) {
-      await fs7.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs9.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs7.writeFile(cursorRulesPath, newContent, "utf-8");
+      await fs9.writeFile(cursorRulesPath, newContent, "utf-8");
     }
     templates.push(".cursorrules");
     logSuccess(".cursorrules updated");
-    const mdcDir = path16.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs7.ensureDir(mdcDir);
+    const mdcDir = path18.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs9.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs7.writeFile(path16.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs9.writeFile(path18.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
   }
   const commands = await copySkills(projectDir);
   logSuccess(`${commands.length} skills updated (.claude/skills/ + .cursor/skills/)`);
+  const agents = await copyAgents(projectDir, scan);
+  logSuccess(`${agents.length} agents updated (.claude/agents/)`);
+  const contexts = await copyContexts(projectDir);
+  logSuccess(`${contexts.length} context modes updated (.claude/contexts/)`);
+  if (existingConfig.hooks !== false) {
+    const settingsLocalPath = path18.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocal = generateSettingsLocal(scan, hookProfile);
+    await fs9.ensureDir(path18.dirname(settingsLocalPath));
+    await fs9.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+    logSuccess(`Hooks updated (profile: ${hookProfile})`);
+  }
   const guides = await copyGuides(projectDir);
   logSuccess(`${guides.length} guides updated`);
-  const config = generateConfig(scan, templates, commands, guides, genOpts);
-  await fs7.writeJson(configPath, config, { spaces: 2 });
+  const config = generateConfig(scan, templates, commands, guides, {
+    ...genOpts,
+    agents,
+    contexts,
+    hooks: existingConfig.hooks !== false,
+    hookProfile
+  });
+  await fs9.writeJson(configPath, config, { spaces: 2 });
   logSuccess("ai-kit.config.json updated");
   console.log("");
   logInfo("All AI configs refreshed with latest project scan.");
 }
 
 // src/commands/reset.ts
-import path17 from "path";
-import fs8 from "fs-extra";
+import path19 from "path";
+import fs10 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function resetCommand(targetPath) {
-  const projectDir = path17.resolve(targetPath || process.cwd());
+  const projectDir = path19.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Reset");
   logWarning("This will remove all AI Kit generated files:");
   logInfo(`  - ${GENERATED_FILES.claudeMd}`);
@@ -1195,44 +1441,44 @@ async function resetCommand(targetPath) {
     return;
   }
   const removed = [];
-  const claudeMdPath = path17.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path19.join(projectDir, GENERATED_FILES.claudeMd);
   if (fileExists(claudeMdPath)) {
-    await fs8.remove(claudeMdPath);
+    await fs10.remove(claudeMdPath);
     removed.push(GENERATED_FILES.claudeMd);
   }
-  const cursorPath = path17.join(projectDir, GENERATED_FILES.cursorRules);
+  const cursorPath = path19.join(projectDir, GENERATED_FILES.cursorRules);
   if (fileExists(cursorPath)) {
-    await fs8.remove(cursorPath);
+    await fs10.remove(cursorPath);
     removed.push(GENERATED_FILES.cursorRules);
   }
-  const cursorMdcDir = path17.join(projectDir, GENERATED_FILES.cursorMdcDir);
+  const cursorMdcDir = path19.join(projectDir, GENERATED_FILES.cursorMdcDir);
   if (fileExists(cursorMdcDir)) {
-    await fs8.remove(cursorMdcDir);
+    await fs10.remove(cursorMdcDir);
     removed.push(GENERATED_FILES.cursorMdcDir);
   }
-  const commandsDir = path17.join(projectDir, GENERATED_FILES.claudeCommands);
+  const commandsDir = path19.join(projectDir, GENERATED_FILES.claudeCommands);
   if (fileExists(commandsDir)) {
-    await fs8.remove(commandsDir);
+    await fs10.remove(commandsDir);
     removed.push(GENERATED_FILES.claudeCommands);
   }
-  const claudeSkillsDir = path17.join(projectDir, GENERATED_FILES.claudeSkills);
+  const claudeSkillsDir = path19.join(projectDir, GENERATED_FILES.claudeSkills);
   if (fileExists(claudeSkillsDir)) {
-    await fs8.remove(claudeSkillsDir);
+    await fs10.remove(claudeSkillsDir);
     removed.push(GENERATED_FILES.claudeSkills);
   }
-  const cursorSkillsDir = path17.join(projectDir, GENERATED_FILES.cursorSkills);
+  const cursorSkillsDir = path19.join(projectDir, GENERATED_FILES.cursorSkills);
   if (fileExists(cursorSkillsDir)) {
-    await fs8.remove(cursorSkillsDir);
+    await fs10.remove(cursorSkillsDir);
     removed.push(GENERATED_FILES.cursorSkills);
   }
-  const aiKitDir = path17.join(projectDir, "ai-kit");
+  const aiKitDir = path19.join(projectDir, "ai-kit");
   if (fileExists(aiKitDir)) {
-    await fs8.remove(aiKitDir);
+    await fs10.remove(aiKitDir);
     removed.push("ai-kit/");
   }
-  const configPath = path17.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path19.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
-    await fs8.remove(configPath);
+    await fs10.remove(configPath);
     removed.push(AI_KIT_CONFIG_FILE);
   }
   logSection("Reset Complete");
@@ -1244,8 +1490,8 @@ async function resetCommand(targetPath) {
 }
 
 // src/commands/tokens.ts
-import path18 from "path";
-import fs9 from "fs-extra";
+import path20 from "path";
+import fs11 from "fs-extra";
 import chalk2 from "chalk";
 import ora3 from "ora";
 import os from "os";
@@ -1255,14 +1501,14 @@ var PRICING = {
 };
 var PLAN_BUDGET = 20;
 function findSessionFiles() {
-  const claudeDir = path18.join(os.homedir(), ".claude", "projects");
-  if (!fs9.existsSync(claudeDir)) return [];
+  const claudeDir = path20.join(os.homedir(), ".claude", "projects");
+  if (!fs11.existsSync(claudeDir)) return [];
   const files = [];
   function walkDir(dir) {
     try {
-      const entries = fs9.readdirSync(dir, { withFileTypes: true });
+      const entries = fs11.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path18.join(dir, entry.name);
+        const full = path20.join(dir, entry.name);
         if (entry.isDirectory()) {
           walkDir(full);
         } else if (entry.name.endsWith(".jsonl")) {
@@ -1277,7 +1523,7 @@ function findSessionFiles() {
 }
 function parseSessionFile(filePath) {
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const usage = {
       inputTokens: 0,
@@ -1314,11 +1560,11 @@ function parseSessionFile(filePath) {
     }
     if (usage.inputTokens === 0 && usage.outputTokens === 0) return null;
     if (!sessionDate) {
-      const stat = fs9.statSync(filePath);
+      const stat = fs11.statSync(filePath);
       sessionDate = stat.mtime.toISOString().slice(0, 10);
     }
-    const sessionId = path18.basename(filePath, ".jsonl");
-    const projectName = path18.basename(path18.dirname(filePath));
+    const sessionId = path20.basename(filePath, ".jsonl");
+    const projectName = path20.basename(path20.dirname(filePath));
     return {
       sessionId,
       filePath,
@@ -1547,13 +1793,13 @@ ${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
   );
   console.log("");
   if (options.csv) {
-    const csvPath = path18.join(process.cwd(), "token-usage.csv");
+    const csvPath = path20.join(process.cwd(), "token-usage.csv");
     const csvHeader = "Date,Sessions,Input Tokens,Output Tokens,Cache Tokens,Cost\n";
     const daily = aggregateByDate(sessions);
     const csvRows = daily.map(
       (d) => `${d.date},${d.sessions},${d.usage.inputTokens},${d.usage.outputTokens},${d.usage.cacheReadTokens},${d.cost.toFixed(2)}`
     ).join("\n");
-    await fs9.writeFile(csvPath, csvHeader + csvRows, "utf-8");
+    await fs11.writeFile(csvPath, csvHeader + csvRows, "utf-8");
     logSuccess(`CSV exported to ${csvPath}`);
   }
   if (options.export) {
@@ -1590,13 +1836,13 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
     }
   };
   const outputDir = process.cwd();
-  const dataPath = path18.join(outputDir, "token-data.json");
-  const dashboardSrc = path18.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
-  const dashboardDest = path18.join(outputDir, "token-dashboard.html");
-  await fs9.writeJson(dataPath, exportData, { spaces: 2 });
+  const dataPath = path20.join(outputDir, "token-data.json");
+  const dashboardSrc = path20.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
+  const dashboardDest = path20.join(outputDir, "token-dashboard.html");
+  await fs11.writeJson(dataPath, exportData, { spaces: 2 });
   logInfo(`Token data written to ${dataPath}`);
-  if (await fs9.pathExists(dashboardSrc)) {
-    await fs9.copy(dashboardSrc, dashboardDest, { overwrite: true });
+  if (await fs11.pathExists(dashboardSrc)) {
+    await fs11.copy(dashboardSrc, dashboardDest, { overwrite: true });
     logInfo(`Dashboard copied to ${dashboardDest}`);
   } else {
     logWarning("Dashboard template not found. Skipping HTML export.");
@@ -1613,12 +1859,12 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
 }
 
 // src/commands/doctor.ts
-import path19 from "path";
+import path21 from "path";
 import chalk3 from "chalk";
 import ora4 from "ora";
 async function doctorCommand(targetPath) {
-  const projectDir = path19.resolve(targetPath || process.cwd());
-  const configPath = path19.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path21.resolve(targetPath || process.cwd());
+  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
   let passed = 0;
   let warnings = 0;
   let issues = 0;
@@ -1650,7 +1896,7 @@ async function doctorCommand(targetPath) {
   }
   for (const template of config.templates) {
     const templateFile = template === "CLAUDE.md" ? GENERATED_FILES.claudeMd : template === ".cursorrules" ? GENERATED_FILES.cursorRules : template;
-    const templatePath = path19.join(projectDir, templateFile);
+    const templatePath = path21.join(projectDir, templateFile);
     if (fileExists(templatePath)) {
       logSuccess(`${template} exists and in sync`);
       passed++;
@@ -1661,8 +1907,8 @@ async function doctorCommand(targetPath) {
   }
   const missingSkills = [];
   for (const skill of config.commands) {
-    const claudeSkillPath = path19.join(projectDir, GENERATED_FILES.claudeSkills, skill);
-    const cursorSkillPath = path19.join(projectDir, GENERATED_FILES.cursorSkills, skill);
+    const claudeSkillPath = path21.join(projectDir, GENERATED_FILES.claudeSkills, skill);
+    const cursorSkillPath = path21.join(projectDir, GENERATED_FILES.cursorSkills, skill);
     if (!fileExists(claudeSkillPath) && !fileExists(cursorSkillPath)) {
       missingSkills.push(skill);
     }
@@ -1676,10 +1922,10 @@ async function doctorCommand(targetPath) {
     );
     issues++;
   }
-  const guidesDir = path19.join(projectDir, "ai-kit", "guides");
+  const guidesDir = path21.join(projectDir, "ai-kit", "guides");
   const missingGuides = [];
   for (const guide of config.guides) {
-    const guidePath = path19.join(guidesDir, guide);
+    const guidePath = path21.join(guidesDir, guide);
     if (!fileExists(guidePath)) {
       missingGuides.push(guide);
     }
@@ -1817,13 +2063,13 @@ function compareScanResults(previous, current) {
 }
 
 // src/commands/diff.ts
-import path20 from "path";
-import fs10 from "fs-extra";
+import path22 from "path";
+import fs12 from "fs-extra";
 import chalk4 from "chalk";
 import ora5 from "ora";
 async function diffCommand(targetPath) {
-  const projectDir = path20.resolve(targetPath || process.cwd());
-  const configPath = path20.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path22.resolve(targetPath || process.cwd());
+  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log(chalk4.bold("AI Kit \u2014 Diff (dry run)\n"));
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
@@ -1890,11 +2136,11 @@ async function diffCommand(targetPath) {
   if (cursorRulesStatus.status === "modified") modified++;
   else if (cursorRulesStatus.status === "added") added++;
   else unchanged++;
-  const skillsDir = path20.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path22.join(projectDir, GENERATED_FILES.claudeSkills);
   const skillCount = countFilesInDir(skillsDir);
   console.log(chalk4.dim(`  unchanged ${GENERATED_FILES.claudeSkills}/ (${skillCount} skills)`));
   unchanged++;
-  const guidesDir = path20.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
+  const guidesDir = path22.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
   const guideCount = existingConfig.guides?.length || 0;
   console.log(chalk4.dim(`  unchanged ai-kit/guides/ (${guideCount} guides)`));
   unchanged++;
@@ -2003,7 +2249,7 @@ function diffStack(oldScan, newScan) {
   return changes;
 }
 function diffGeneratedFile(projectDir, filename, config, generate2, oldFragments, newFragments) {
-  const filePath = path20.join(projectDir, filename);
+  const filePath = path22.join(projectDir, filename);
   const currentContent = readFileSafe(filePath);
   const newContent = generate2();
   if (!currentContent) {
@@ -2040,8 +2286,8 @@ function logFileChange(result) {
 }
 function countFilesInDir(dirPath) {
   try {
-    if (!fs10.existsSync(dirPath)) return 0;
-    const entries = fs10.readdirSync(dirPath);
+    if (!fs12.existsSync(dirPath)) return 0;
+    const entries = fs12.readdirSync(dirPath);
     return entries.filter((e) => !e.startsWith(".")).length;
   } catch {
     return 0;
@@ -2049,8 +2295,8 @@ function countFilesInDir(dirPath) {
 }
 
 // src/commands/export.ts
-import path21 from "path";
-import fs11 from "fs-extra";
+import path23 from "path";
+import fs13 from "fs-extra";
 import ora6 from "ora";
 import { select as select2 } from "@inquirer/prompts";
 var EXPORT_TARGETS = {
@@ -2086,9 +2332,9 @@ function toCline(content) {
 ${stripped}`;
 }
 async function exportCommand(targetPath, options) {
-  const projectDir = path21.resolve(targetPath || process.cwd());
-  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
-  const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
+  const projectDir = path23.resolve(targetPath || process.cwd());
+  const configPath = path23.join(projectDir, AI_KIT_CONFIG_FILE);
+  const claudeMdPath = path23.join(projectDir, GENERATED_FILES.claudeMd);
   logSection("AI Kit \u2014 Export");
   if (!fileExists(configPath) && !fileExists(claudeMdPath)) {
     logError("No ai-kit.config.json or CLAUDE.md found. Run `ai-kit init` first.");
@@ -2130,9 +2376,9 @@ async function exportCommand(targetPath, options) {
   for (const fmt2 of formats) {
     const target = EXPORT_TARGETS[fmt2];
     const transformer = transformers[fmt2];
-    const outputPath = path21.join(projectDir, target.file);
+    const outputPath = path23.join(projectDir, target.file);
     const transformed = transformer(claudeContent);
-    await fs11.writeFile(outputPath, transformed, "utf-8");
+    await fs13.writeFile(outputPath, transformed, "utf-8");
     exported++;
   }
   spinner.succeed("Export complete");
@@ -2148,7 +2394,7 @@ async function exportCommand(targetPath, options) {
 }
 
 // src/commands/stats.ts
-import path22 from "path";
+import path24 from "path";
 import chalk5 from "chalk";
 var SKILL_CATEGORIES = {
   "Getting Started": ["prompt-help", "understand"],
@@ -2251,8 +2497,8 @@ var MCP_DISPLAY_NAMES = {
   perplexity: "Perplexity"
 };
 async function statsCommand(targetPath) {
-  const projectDir = path22.resolve(targetPath || process.cwd());
-  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path24.resolve(targetPath || process.cwd());
+  const configPath = path24.join(projectDir, AI_KIT_CONFIG_FILE);
   logSection("AI Kit \u2014 Project Stats");
   console.log("");
   if (!fileExists(configPath)) {
@@ -2345,6 +2591,146 @@ async function statsCommand(targetPath) {
   console.log("");
 }
 
+// src/commands/audit.ts
+import path25 from "path";
+import fs14 from "fs-extra";
+import chalk6 from "chalk";
+async function auditCommand(targetPath) {
+  const projectDir = path25.resolve(targetPath || process.cwd());
+  logSection("AI Kit \u2014 Security & Configuration Audit");
+  logInfo(`Auditing: ${projectDir}`);
+  const checks = [];
+  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
+  if (fileExists(configPath)) {
+    checks.push({ name: "Config file", status: "pass", message: "ai-kit.config.json found" });
+  } else {
+    checks.push({ name: "Config file", status: "fail", message: "ai-kit.config.json missing \u2014 run `ai-kit init`" });
+  }
+  const claudeMdPath = path25.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMd = readFileSafe(claudeMdPath);
+  if (claudeMd) {
+    if (claudeMd.includes("AI-KIT:START") && claudeMd.includes("AI-KIT:END")) {
+      checks.push({ name: "CLAUDE.md", status: "pass", message: "CLAUDE.md has AI-KIT markers" });
+    } else {
+      checks.push({ name: "CLAUDE.md", status: "warn", message: "CLAUDE.md exists but missing AI-KIT markers \u2014 may not update correctly" });
+    }
+  } else {
+    checks.push({ name: "CLAUDE.md", status: "warn", message: "CLAUDE.md not found" });
+  }
+  if (claudeMd) {
+    const secretPatterns = [
+      /(?:api[_-]?key|secret|token|password|credential)\s*[:=]\s*['"][^'"]+['"]/i,
+      /(?:sk|pk|rk)[-_][a-zA-Z0-9]{20,}/,
+      /ghp_[a-zA-Z0-9]{36}/,
+      /xox[bpoas]-[a-zA-Z0-9-]+/
+    ];
+    const hasSecrets = secretPatterns.some((p) => p.test(claudeMd));
+    if (hasSecrets) {
+      checks.push({ name: "Secrets in CLAUDE.md", status: "fail", message: "Potential secrets detected in CLAUDE.md \u2014 remove immediately" });
+    } else {
+      checks.push({ name: "Secrets in CLAUDE.md", status: "pass", message: "No secrets detected" });
+    }
+  }
+  const settingsLocalPath = path25.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+  if (fileExists(settingsLocalPath)) {
+    const settings2 = readJsonSafe(settingsLocalPath);
+    if (settings2?.hooks) {
+      checks.push({ name: "Hooks", status: "pass", message: "Hooks configured in settings.local.json" });
+    } else {
+      checks.push({ name: "Hooks", status: "warn", message: "settings.local.json exists but no hooks defined" });
+    }
+  } else {
+    checks.push({ name: "Hooks", status: "warn", message: "No hooks configured \u2014 run `ai-kit init` to generate" });
+  }
+  const agentsDir = path25.join(projectDir, GENERATED_FILES.claudeAgents);
+  if (await fs14.pathExists(agentsDir)) {
+    const agentFiles = (await fs14.readdir(agentsDir)).filter((f) => f.endsWith(".md"));
+    if (agentFiles.length > 0) {
+      checks.push({ name: "Agents", status: "pass", message: `${agentFiles.length} agent(s) configured` });
+      let invalidAgents = 0;
+      for (const file of agentFiles) {
+        const content = readFileSafe(path25.join(agentsDir, file));
+        if (content && !content.startsWith("---")) {
+          invalidAgents++;
+        }
+      }
+      if (invalidAgents > 0) {
+        checks.push({ name: "Agent frontmatter", status: "warn", message: `${invalidAgents} agent(s) missing YAML frontmatter` });
+      }
+    } else {
+      checks.push({ name: "Agents", status: "warn", message: "Agents directory empty" });
+    }
+  } else {
+    checks.push({ name: "Agents", status: "warn", message: "No agents directory \u2014 run `ai-kit init` to generate" });
+  }
+  const contextsDir = path25.join(projectDir, GENERATED_FILES.claudeContexts);
+  if (await fs14.pathExists(contextsDir)) {
+    const contextFiles = (await fs14.readdir(contextsDir)).filter((f) => f.endsWith(".md"));
+    checks.push({ name: "Contexts", status: contextFiles.length > 0 ? "pass" : "warn", message: `${contextFiles.length} context mode(s) available` });
+  } else {
+    checks.push({ name: "Contexts", status: "warn", message: "No contexts directory" });
+  }
+  const skillsDir = path25.join(projectDir, GENERATED_FILES.claudeSkills);
+  if (await fs14.pathExists(skillsDir)) {
+    const skillDirs = (await fs14.readdir(skillsDir)).filter(async (f) => {
+      try {
+        return (await fs14.stat(path25.join(skillsDir, f))).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    checks.push({ name: "Skills", status: "pass", message: `${skillDirs.length} skill(s) installed` });
+  } else {
+    checks.push({ name: "Skills", status: "warn", message: "No skills directory" });
+  }
+  const gitignorePath = path25.join(projectDir, ".gitignore");
+  const gitignore = readFileSafe(gitignorePath);
+  if (gitignore) {
+    const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
+    if (envIgnored) {
+      checks.push({ name: ".env gitignore", status: "pass", message: ".env files are gitignored" });
+    } else {
+      checks.push({ name: ".env gitignore", status: "fail", message: ".env files are NOT gitignored \u2014 add to .gitignore immediately" });
+    }
+  }
+  if (gitignore) {
+    const settingsIgnored = gitignore.includes("settings.local.json");
+    if (!settingsIgnored) {
+      checks.push({ name: "Settings gitignore", status: "warn", message: "settings.local.json not in .gitignore \u2014 may leak local config" });
+    }
+  }
+  const settingsPath = path25.join(projectDir, ".claude", "settings.json");
+  const settings = readFileSafe(settingsPath);
+  if (settings) {
+    const hasEnvVarsInSettings = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settings);
+    if (hasEnvVarsInSettings) {
+      checks.push({ name: "MCP secrets", status: "fail", message: "Potential secrets in .claude/settings.json \u2014 use environment variables instead" });
+    } else {
+      checks.push({ name: "MCP secrets", status: "pass", message: "No hardcoded secrets in settings" });
+    }
+  }
+  logSection("Audit Results");
+  const passed = checks.filter((c) => c.status === "pass");
+  const warned = checks.filter((c) => c.status === "warn");
+  const failed = checks.filter((c) => c.status === "fail");
+  for (const check of checks) {
+    const icon = check.status === "pass" ? chalk6.green("\u2713") : check.status === "warn" ? chalk6.yellow("\u26A0") : chalk6.red("\u2717");
+    console.log(`  ${icon} ${check.name}: ${check.message}`);
+  }
+  const total = checks.length;
+  const score = Math.round((passed.length + warned.length * 0.5) / total * 100);
+  const grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+  console.log("");
+  logSection("Score");
+  const gradeColor = grade <= "B" ? chalk6.green : grade <= "C" ? chalk6.yellow : chalk6.red;
+  console.log(`  ${gradeColor.bold(grade)} (${score}/100)`);
+  console.log(`  ${chalk6.green(String(passed.length))} passed \xB7 ${chalk6.yellow(String(warned.length))} warnings \xB7 ${chalk6.red(String(failed.length))} failures`);
+  if (failed.length > 0) {
+    console.log("");
+    logError("Fix the failures above before proceeding.");
+  }
+}
+
 // src/index.ts
 var program = new Command();
 program.name("ai-kit").description(
@@ -2438,5 +2824,16 @@ program.command("stats").description("Show project setup statistics and complexi
     process.exit(1);
   }
 });
+program.command("audit").description("Security and configuration audit for AI agent setup").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await auditCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map