@anatolykoptev/krolik-cli 0.1.0

package/dist/chunk-DTDOBWO6.js

@@ -0,0 +1,2061 @@
+import * as fs6 from 'fs';
+import * as path12 from 'path';
+import 'os';
+import { SyntaxKind } from 'ts-morph';
+import { execSync, spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { cosmiconfig } from 'cosmiconfig';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/config/defaults.ts
+var DEFAULT_PATHS = {
+  web: "src",
+  api: "src/api",
+  db: "prisma",
+  shared: "src/shared",
+  components: "src/components",
+  hooks: "src/hooks",
+  lib: "src/lib"
+};
+var DEFAULT_FEATURES = {
+  prisma: false,
+  trpc: false,
+  nextjs: false,
+  react: true,
+  monorepo: false,
+  typescript: true
+};
+var DEFAULT_PRISMA = {
+  schemaDir: "prisma",
+  migrationsDir: "prisma/migrations"
+};
+var DEFAULT_TRPC = {
+  routersDir: "src/server/routers",
+  appRouter: "src/server/routers/index.ts"
+};
+var DEFAULT_TEMPLATES = {
+  hook: "",
+  component: "",
+  test: "",
+  schema: ""
+};
+var DEFAULT_EXCLUDE = [
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  ".git",
+  ".turbo",
+  "coverage",
+  ".cache"
+];
+var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function createDefaultConfig(projectRoot) {
+  return {
+    name: "project",
+    projectRoot,
+    paths: { ...DEFAULT_PATHS },
+    features: { ...DEFAULT_FEATURES },
+    prisma: { ...DEFAULT_PRISMA },
+    trpc: { ...DEFAULT_TRPC },
+    templates: { ...DEFAULT_TEMPLATES },
+    exclude: [...DEFAULT_EXCLUDE],
+    extensions: [...DEFAULT_EXTENSIONS]
+  };
+}
+var FileCache = class {
+  cache = /* @__PURE__ */ new Map();
+  stats = { hits: 0, misses: 0 };
+  options;
+  constructor(options = {}) {
+    this.options = {
+      trackMtime: options.trackMtime ?? true,
+      collectStats: options.collectStats ?? true
+    };
+  }
+  /**
+   * Get file content, reading from disk if not cached
+   *
+   * Automatically invalidates cache if file modification time changed.
+   *
+   * @param filepath - Absolute or relative file path
+   * @returns File content
+   * @throws Error if file cannot be read
+   */
+  get(filepath) {
+    const absolute = path12.resolve(filepath);
+    const cached = this.cache.get(absolute);
+    if (cached) {
+      if (this.options.trackMtime) {
+        try {
+          const stat = fs6.statSync(absolute);
+          const currentMtime = stat.mtime.getTime();
+          if (currentMtime === cached.mtime) {
+            if (this.options.collectStats) {
+              this.stats.hits++;
+            }
+            return cached.content;
+          }
+          this.cache.delete(absolute);
+        } catch {
+          this.cache.delete(absolute);
+        }
+      } else {
+        if (this.options.collectStats) {
+          this.stats.hits++;
+        }
+        return cached.content;
+      }
+    }
+    if (this.options.collectStats) {
+      this.stats.misses++;
+    }
+    const content = fs6.readFileSync(absolute, "utf-8");
+    if (this.options.trackMtime) {
+      try {
+        const stat = fs6.statSync(absolute);
+        this.cache.set(absolute, {
+          content,
+          mtime: stat.mtime.getTime()
+        });
+      } catch {
+        this.cache.set(absolute, {
+          content,
+          mtime: 0
+        });
+      }
+    } else {
+      this.cache.set(absolute, {
+        content,
+        mtime: 0
+      });
+    }
+    return content;
+  }
+  /**
+   * Update cached content (e.g., after fix applied)
+   *
+   * This keeps the cache consistent with disk state when you
+   * write to a file and want to avoid re-reading it.
+   *
+   * @param filepath - Absolute or relative file path
+   * @param content - New file content
+   */
+  set(filepath, content) {
+    const absolute = path12.resolve(filepath);
+    if (this.options.trackMtime) {
+      try {
+        const stat = fs6.statSync(absolute);
+        this.cache.set(absolute, {
+          content,
+          mtime: stat.mtime.getTime()
+        });
+      } catch {
+        this.cache.set(absolute, {
+          content,
+          mtime: 0
+        });
+      }
+    } else {
+      this.cache.set(absolute, {
+        content,
+        mtime: 0
+      });
+    }
+  }
+  /**
+   * Check if file is cached (and valid if mtime tracking enabled)
+   *
+   * @param filepath - Absolute or relative file path
+   * @returns true if file is cached and valid
+   */
+  has(filepath) {
+    const absolute = path12.resolve(filepath);
+    const cached = this.cache.has(absolute);
+    if (!cached || !this.options.trackMtime) {
+      return cached;
+    }
+    const entry = this.cache.get(absolute);
+    if (!entry) return false;
+    try {
+      const stat = fs6.statSync(absolute);
+      if (stat.mtime.getTime() !== entry.mtime) {
+        this.cache.delete(absolute);
+        return false;
+      }
+      return true;
+    } catch {
+      this.cache.delete(absolute);
+      return false;
+    }
+  }
+  /**
+   * Invalidate cache for a specific file
+   *
+   * Use when file is modified externally and you want to force
+   * a fresh read on next get().
+   *
+   * @param filepath - Absolute or relative file path
+   */
+  invalidate(filepath) {
+    const absolute = path12.resolve(filepath);
+    this.cache.delete(absolute);
+  }
+  /**
+   * Clear entire cache and reset statistics
+   *
+   * Call at end of command execution to free memory.
+   */
+  clear() {
+    this.cache.clear();
+    this.stats = { hits: 0, misses: 0 };
+  }
+  /**
+   * Get cache statistics
+   *
+   * @returns Statistics object with hits, misses, size, and memory usage
+   */
+  getStats() {
+    let memoryBytes = 0;
+    for (const entry of this.cache.values()) {
+      memoryBytes += entry.content.length * 2;
+      memoryBytes += 8;
+    }
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      size: this.cache.size,
+      memoryBytes
+    };
+  }
+  /**
+   * Pre-warm cache with multiple files
+   *
+   * Useful when you know which files will be accessed and want to
+   * batch-load them for better performance.
+   *
+   * @param filepaths - Array of file paths to pre-load
+   */
+  warmup(filepaths) {
+    for (const filepath of filepaths) {
+      try {
+        this.get(filepath);
+      } catch {
+      }
+    }
+  }
+};
+new FileCache();
+var SKIP_FOLDERS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".krolik",
+  ".claude"
+]);
+function isProject(dir) {
+  const hasPackageJson = fs6.existsSync(path12.join(dir, "package.json"));
+  const hasGit = fs6.existsSync(path12.join(dir, ".git"));
+  const hasTsConfig = fs6.existsSync(path12.join(dir, "tsconfig.json"));
+  if (!hasPackageJson && !hasGit) {
+    return null;
+  }
+  let description;
+  if (hasPackageJson) {
+    try {
+      const pkg = JSON.parse(fs6.readFileSync(path12.join(dir, "package.json"), "utf-8"));
+      description = pkg.description || pkg.name;
+    } catch {
+    }
+  }
+  return {
+    name: path12.basename(dir),
+    path: dir,
+    hasPackageJson,
+    hasGit,
+    hasTsConfig,
+    ...description ? { description } : {}
+  };
+}
+function scanForProjects(workspaceRoot) {
+  const projects = [];
+  try {
+    const entries = fs6.readdirSync(workspaceRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_FOLDERS.has(entry.name) || entry.name.startsWith(".")) {
+        continue;
+      }
+      const projectPath = path12.join(workspaceRoot, entry.name);
+      const project = isProject(projectPath);
+      if (project) {
+        projects.push(project);
+      }
+    }
+  } catch {
+  }
+  return projects;
+}
+function detectProjects(workspaceRoot, requestedProject) {
+  const rootProject = isProject(workspaceRoot);
+  if (requestedProject) {
+    const projectPath = path12.join(workspaceRoot, requestedProject);
+    if (fs6.existsSync(projectPath)) {
+      const project = isProject(projectPath);
+      if (project) {
+        return { status: "single", project };
+      }
+    }
+    if (requestedProject === path12.basename(workspaceRoot) && rootProject) {
+      return { status: "single", project: rootProject };
+    }
+    return {
+      status: "none",
+      message: `Project "${requestedProject}" not found. Use the tool without project parameter to see available projects.`
+    };
+  }
+  if (rootProject) {
+    return { status: "single", project: rootProject };
+  }
+  const projects = scanForProjects(workspaceRoot);
+  if (projects.length === 0) {
+    return {
+      status: "none",
+      message: "No projects found. Make sure you are in a directory with package.json or subdirectories containing projects."
+    };
+  }
+  if (projects.length === 1 && projects[0]) {
+    return { status: "single", project: projects[0] };
+  }
+  return {
+    status: "multiple",
+    projects,
+    message: "Multiple projects found. Please specify which project to analyze."
+  };
+}
+function formatProjectList(projects) {
+  const lines = [
+    "<available-projects>",
+    '  <instruction>Multiple projects detected. Please call the tool again with the "project" parameter set to one of these:</instruction>',
+    ""
+  ];
+  for (const p of projects) {
+    lines.push(`  <project name="${p.name}">`);
+    if (p.description) {
+      lines.push(`    <description>${p.description}</description>`);
+    }
+    lines.push(`    <path>${p.path}</path>`);
+    const features = [];
+    if (p.hasPackageJson) features.push("npm");
+    if (p.hasGit) features.push("git");
+    if (p.hasTsConfig) features.push("typescript");
+    lines.push(`    <features>${features.join(", ")}</features>`);
+    lines.push("  </project>");
+  }
+  lines.push("</available-projects>");
+  return lines.join("\n");
+}
+function resolveProjectPath(workspaceRoot, requestedProject) {
+  const result = detectProjects(workspaceRoot, requestedProject);
+  switch (result.status) {
+    case "single":
+      if (!result.project) {
+        return { error: "Project not found" };
+      }
+      return { path: result.project.path };
+    case "multiple":
+      if (!result.projects) {
+        return { error: "No projects found" };
+      }
+      return { error: formatProjectList(result.projects) };
+    case "none":
+      return { error: result.message || "No projects found" };
+  }
+}
+function withProjectDetection(args, workspaceRoot, handler) {
+  const projectArg = typeof args.project === "string" ? args.project : void 0;
+  const resolved = resolveProjectPath(workspaceRoot, projectArg);
+  if ("error" in resolved) {
+    return resolved.error;
+  }
+  return handler(resolved.path);
+}
+
+// src/mcp/tools/core/registry.ts
+var toolRegistry = [];
+function registerTool(tool) {
+  if (toolRegistry.some((t) => t.name === tool.name)) {
+    throw new Error(`Tool "${tool.name}" is already registered`);
+  }
+  toolRegistry.push(tool);
+}
+
+// src/mcp/tools/core/shared.ts
+var PROJECT_PROPERTY = {
+  project: {
+    type: "string",
+    description: 'Project folder name to analyze (e.g., "my-app", "my-project"). If not specified, auto-detects or returns list of available projects.'
+  }
+};
+var FIX_CATEGORIES = ["lint", "type-safety", "complexity", "hardcoded", "srp"];
+var COMMON_FLAGS = {
+  path: { flag: "--path", sanitize: "feature" },
+  feature: { flag: "--feature", sanitize: "feature" },
+  issue: { flag: "--issue", sanitize: "issue" },
+  pr: { flag: "--pr", sanitize: "issue" },
+  staged: { flag: "--staged" },
+  dryRun: { flag: "--dry-run" },
+  json: { flag: "--json" },
+  apply: { flag: "--apply" },
+  safe: { flag: "--safe" }
+};
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path12.dirname(__filename2);
+var CLI_PATH = path12.resolve(__dirname2, "cli.js");
+var TIMEOUT_60S = 6e4;
+var TIMEOUT_120S = 12e4;
+function sanitizeFeatureName(input) {
+  if (typeof input !== "string") return null;
+  const sanitized = input.trim();
+  if (sanitized.length === 0 || sanitized.length > 100) return null;
+  if (!/^[a-zA-Z0-9_\-.\s]+$/.test(sanitized)) return null;
+  return sanitized;
+}
+function sanitizeIssueNumber(input) {
+  if (typeof input === "number") {
+    if (Number.isInteger(input) && input > 0 && input < 1e6) return input;
+    return null;
+  }
+  if (typeof input === "string") {
+    const num = parseInt(input, 10);
+    if (Number.isNaN(num) || num <= 0 || num >= 1e6) return null;
+    if (!/^\d+$/.test(input.trim())) return null;
+    return num;
+  }
+  return null;
+}
+function escapeShellArg(arg) {
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function parseCommandArgs(command) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    const nextChar = command[i + 1];
+    if (char === "\\" && nextChar) {
+      current += nextChar;
+      i++;
+    } else if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current.length > 0) {
+    args.push(current);
+  }
+  return args;
+}
+function runKrolik(args, projectRoot, timeout = 3e4) {
+  const argArray = parseCommandArgs(args);
+  const result = spawnSync("node", [CLI_PATH, ...argArray], {
+    cwd: projectRoot,
+    encoding: "utf-8",
+    timeout,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.error) {
+    return `Error: ${result.error.message}`;
+  }
+  if (result.signal === "SIGTERM") {
+    return `Error: Command timed out after ${timeout}ms`;
+  }
+  if (result.status !== 0) {
+    const errorOutput = result.stderr || result.stdout || `Exit code: ${result.status}`;
+    return errorOutput;
+  }
+  return result.stdout || "";
+}
+
+// src/mcp/tools/agent/index.ts
+var inputSchema = {
+  ...PROJECT_PROPERTY,
+  name: {
+    type: "string",
+    description: 'Agent name to run (e.g., "security-auditor", "backend-architect") or category name (e.g., "security", "quality")'
+  },
+  orchestrate: {
+    type: "boolean",
+    description: 'Enable orchestration mode. Analyzes the task and coordinates multiple specialized agents. Use when user says "use multi-agents" or "\u043C\u0443\u043B\u044C\u0442\u0438\u0430\u0433\u0435\u043D\u0442\u044B".'
+  },
+  task: {
+    type: "string",
+    description: 'Task description for orchestration mode (e.g., "analyze security and performance", "review code quality")'
+  },
+  category: {
+    type: "string",
+    description: "Filter agents by category: security, performance, architecture, quality, debugging, docs, etc."
+  },
+  file: {
+    type: "string",
+    description: "Target file for agent analysis"
+  },
+  feature: {
+    type: "string",
+    description: 'Feature or domain to focus on (e.g., "booking", "auth", "CRM")'
+  },
+  list: {
+    type: "boolean",
+    description: "List all available agents"
+  },
+  maxAgents: {
+    type: "number",
+    description: "Maximum number of agents to run in orchestration mode (default: 5)"
+  },
+  parallel: {
+    type: "boolean",
+    description: "Prefer parallel execution of agents in orchestration mode"
+  },
+  dryRun: {
+    type: "boolean",
+    description: "Show orchestration plan without executing agents"
+  }
+};
+function buildAgentCommand(args) {
+  const parts = ["agent"];
+  if (args.name && !args.orchestrate) {
+    const name = String(args.name).replace(/[^a-zA-Z0-9_-]/g, "");
+    parts.push(name);
+  }
+  if (args.orchestrate) {
+    parts.push("--orchestrate");
+    if (args.task) {
+      const task = String(args.task).replace(/"/g, '\\"');
+      parts.push(`--task "${task}"`);
+    }
+    if (args.maxAgents) {
+      parts.push(`--max-agents ${Number(args.maxAgents)}`);
+    }
+    if (args.parallel) {
+      parts.push("--parallel");
+    }
+  }
+  if (args.category) {
+    const category = String(args.category).replace(/[^a-zA-Z0-9_-]/g, "");
+    parts.push(`--category ${category}`);
+  }
+  if (args.file) {
+    const file = String(args.file).replace(/[^a-zA-Z0-9_./-]/g, "");
+    parts.push(`--file ${file}`);
+  }
+  if (args.feature) {
+    const feature = String(args.feature).replace(/[^a-zA-Z0-9_-]/g, "");
+    parts.push(`--feature ${feature}`);
+  }
+  if (args.list) {
+    parts.push("--list");
+  }
+  if (args.dryRun) {
+    parts.push("--dry-run");
+  }
+  return parts.join(" ");
+}
+var agentTool = {
+  name: "krolik_agent",
+  description: `Run specialized AI agents with project context. Supports orchestration mode for multi-agent coordination.
+
+ORCHESTRATION MODE (orchestrate=true):
+When user says "use multi-agents", "\u043C\u0443\u043B\u044C\u0442\u0438\u0430\u0433\u0435\u043D\u0442\u044B", or needs multiple expert analyses:
+1. Set orchestrate=true and provide task description
+2. The orchestrator analyzes the task and identifies needed agents
+3. Creates execution plan (parallel/sequential)
+4. Returns XML for Claude to execute with Task tool
+
+DIRECT MODE (default):
+Run a specific agent by name or category.
+
+Examples:
+- { "name": "security-auditor" } \u2192 Run security agent
+- { "category": "quality" } \u2192 Run all quality agents
+- { "orchestrate": true, "task": "analyze security and performance" } \u2192 Multi-agent orchestration
+- { "list": true } \u2192 List all available agents`,
+  inputSchema: {
+    type: "object",
+    properties: inputSchema
+  },
+  template: { when: "Multi-agent orchestration", params: '`orchestrate: true, task: "..."`' },
+  category: "advanced",
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const command = buildAgentCommand(args);
+      const timeout = args.orchestrate ? TIMEOUT_120S : TIMEOUT_60S;
+      return runKrolik(command, projectPath, timeout);
+    });
+  }
+};
+registerTool(agentTool);
+
+// src/mcp/tools/core/flag-builder.ts
+function buildFlags(args, schema) {
+  const parts = [];
+  for (const [key, def] of Object.entries(schema)) {
+    const val = args[key];
+    if (val === void 0 || val === null || val === false) {
+      if (def.required) {
+        return { ok: false, error: `Missing required argument: ${key}` };
+      }
+      continue;
+    }
+    if (val === true) {
+      parts.push(def.flag);
+      continue;
+    }
+    let strVal = String(val);
+    if (def.sanitize === "feature") {
+      const sanitized = sanitizeFeatureName(val);
+      if (!sanitized) {
+        return {
+          ok: false,
+          error: `Invalid ${key}: Only alphanumeric, hyphens, underscores, dots allowed.`
+        };
+      }
+      strVal = sanitized;
+    } else if (def.sanitize === "issue") {
+      const sanitized = sanitizeIssueNumber(val);
+      if (!sanitized) {
+        return { ok: false, error: `Invalid ${key}: Must be a positive number.` };
+      }
+      strVal = String(sanitized);
+    }
+    if (def.transform) {
+      const transformed = def.transform(val);
+      if (transformed === null) {
+        return { ok: false, error: `Invalid ${key}` };
+      }
+      strVal = transformed;
+    }
+    if (def.validate && !def.validate(val)) {
+      return { ok: false, error: `Invalid ${key}` };
+    }
+    if (def.flag === "") {
+      parts.push(escapeShellArg(strVal));
+    } else {
+      parts.push(`${def.flag}=${escapeShellArg(strVal)}`);
+    }
+  }
+  return { ok: true, flags: parts.join(" ") };
+}
+
+// src/mcp/tools/audit/index.ts
+var auditSchema = {
+  path: COMMON_FLAGS.path
+};
+var auditTool = {
+  name: "krolik_audit",
+  description: "Audit code quality. Analyzes codebase for issues: console.log, any types, complexity, magic numbers, etc. Returns AI-friendly report.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      path: {
+        type: "string",
+        description: "Specific subdirectory within project to audit (optional)"
+      }
+    }
+  },
+  template: { when: "Code quality audit", params: "\u2014" },
+  workflow: { trigger: "on_refactor", order: 2 },
+  category: "code",
+  handler: (args, workspaceRoot) => {
+    const result = buildFlags(args, auditSchema);
+    if (!result.ok) return result.error;
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      return runKrolik(`audit ${result.flags}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(auditTool);
+
+// src/mcp/tools/context/index.ts
+var contextSchema = {
+  feature: COMMON_FLAGS.feature,
+  issue: COMMON_FLAGS.issue,
+  quick: { flag: "--quick" },
+  deep: { flag: "--deep" },
+  full: { flag: "--full" }
+};
+var contextTool = {
+  name: "krolik_context",
+  description: "Generate AI-friendly context for a specific task or feature. Returns structured XML with schema, routes, git info, and approach steps.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      feature: {
+        type: "string",
+        description: 'The feature or task to analyze (e.g., "booking", "auth", "CRM")'
+      },
+      issue: {
+        type: "string",
+        description: "GitHub issue number to get context for"
+      },
+      quick: {
+        type: "boolean",
+        description: "Quick mode: architecture, git, tree, schema, routes only (faster)"
+      },
+      deep: {
+        type: "boolean",
+        description: "Deep mode: imports, types, env, contracts (complements quick)"
+      },
+      full: {
+        type: "boolean",
+        description: "Full mode: all enrichment (--include-code --domain-history --show-deps --with-audit)"
+      }
+    }
+  },
+  template: { when: "Before feature/issue work", params: '`feature: "..."` or `issue: "123"`' },
+  workflow: { trigger: "before_task", order: 1 },
+  category: "context",
+  handler: (args, workspaceRoot) => {
+    const result = buildFlags(args, contextSchema);
+    if (!result.ok) return result.error;
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      return runKrolik(`context ${result.flags}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(contextTool);
+
+// src/mcp/tools/docs/index.ts
+var docsSchema = {
+  library: { flag: "--library", sanitize: "none" },
+  topic: { flag: "--topic", sanitize: "none" },
+  limit: { flag: "--limit", sanitize: "none" },
+  force: { flag: "--force" },
+  expired: { flag: "--expired" }
+};
+var docsTool = {
+  name: "krolik_docs",
+  description: `Query and manage cached library documentation.
+
+Actions:
+- search: Full-text search across cached docs (FTS5)
+- list: List all cached libraries with expiry status
+- fetch: Fetch/refresh docs for a library from Context7
+- detect: Auto-detect libraries from package.json
+- clear: Clear cache (all or specific library)
+
+Use this tool to:
+- Find code examples and API documentation
+- Check which libraries are cached
+- Refresh outdated documentation
+- Discover project dependencies that have docs available
+
+Examples:
+- Search: { action: "search", query: "app router server components" }
+- List: { action: "list" }
+- Fetch: { action: "fetch", library: "next.js", topic: "app-router" }
+- Detect: { action: "detect" }`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      action: {
+        type: "string",
+        enum: ["search", "list", "fetch", "detect", "clear"],
+        description: "Action to perform"
+      },
+      query: {
+        type: "string",
+        description: "Search query (for action: search)"
+      },
+      library: {
+        type: "string",
+        description: 'Library name (e.g., "next.js", "prisma", "trpc")'
+      },
+      topic: {
+        type: "string",
+        description: 'Topic to focus on (e.g., "app-router", "transactions")'
+      },
+      limit: {
+        type: "number",
+        description: "Max results for search (default: 10)"
+      },
+      force: {
+        type: "boolean",
+        description: "Force refresh even if cache is valid"
+      },
+      expired: {
+        type: "boolean",
+        description: "For list/clear: only show/clear expired entries"
+      }
+    },
+    required: ["action"]
+  },
+  template: { when: "Need library API docs", params: '`action: "search", query: "..."`' },
+  category: "context",
+  handler: (args, workspaceRoot) => {
+    const action = args.action;
+    if (action === "search" && !args.query) {
+      return "Error: query is required for search action";
+    }
+    if (action === "fetch" && !args.library) {
+      return "Error: library is required for fetch action";
+    }
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      switch (action) {
+        case "search": {
+          const query = args.query;
+          const result = buildFlags(args, {
+            library: docsSchema.library,
+            topic: docsSchema.topic,
+            limit: docsSchema.limit
+          });
+          if (!result.ok) return result.error;
+          return runKrolik(`docs search "${query}" ${result.flags}`, projectPath, TIMEOUT_120S);
+        }
+        case "list": {
+          const result = buildFlags(args, {
+            expired: docsSchema.expired
+          });
+          if (!result.ok) return result.error;
+          return runKrolik(`docs list ${result.flags}`, projectPath, TIMEOUT_120S);
+        }
+        case "fetch": {
+          const library = args.library;
+          const result = buildFlags(args, {
+            topic: docsSchema.topic,
+            force: docsSchema.force
+          });
+          if (!result.ok) return result.error;
+          return runKrolik(`docs fetch "${library}" ${result.flags}`, projectPath, TIMEOUT_120S);
+        }
+        case "detect": {
+          return runKrolik("docs detect", projectPath, TIMEOUT_120S);
+        }
+        case "clear": {
+          const result = buildFlags(args, {
+            library: docsSchema.library,
+            expired: docsSchema.expired
+          });
+          if (!result.ok) return result.error;
+          return runKrolik(`docs clear ${result.flags}`, projectPath, TIMEOUT_120S);
+        }
+        default:
+          return `Error: Unknown action: ${action}. Valid actions: search, list, fetch, detect, clear`;
+      }
+    });
+  }
+};
+registerTool(docsTool);
+
+// src/mcp/tools/fix/index.ts
+var fixSchema = {
+  dryRun: COMMON_FLAGS.dryRun,
+  safe: COMMON_FLAGS.safe,
+  path: COMMON_FLAGS.path,
+  category: {
+    flag: "--category",
+    validate: (val) => typeof val === "string" && FIX_CATEGORIES.includes(val)
+  }
+};
+var fixTool = {
+  name: "krolik_fix",
+  description: "Auto-fix code quality issues. Removes console.log, debugger, replaces any with unknown, etc. Use --dry-run to preview.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      dryRun: {
+        type: "boolean",
+        description: "Preview changes without applying (recommended first)"
+      },
+      path: {
+        type: "string",
+        description: "Specific directory to fix (optional)"
+      },
+      category: {
+        type: "string",
+        description: "Fix category: lint, type-safety, complexity, hardcoded, srp",
+        enum: [...FIX_CATEGORIES]
+      },
+      safe: {
+        type: "boolean",
+        description: "Only apply safe fixes (no risky changes)"
+      }
+    }
+  },
+  template: { when: "Quality issues found", params: "`dryRun: true` first" },
+  workflow: { trigger: "after_code", order: 1 },
+  category: "code",
+  handler: (args, workspaceRoot) => {
+    const result = buildFlags(args, fixSchema);
+    if (!result.ok) {
+      if (args.category && !FIX_CATEGORIES.includes(args.category)) {
+        return `Error: Invalid category. Must be one of: ${FIX_CATEGORIES.join(", ")}`;
+      }
+      return result.error;
+    }
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      return runKrolik(`fix ${result.flags}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(fixTool);
+
+// src/mcp/tools/issue/index.ts
+var issueSchema = {
+  number: { flag: "", sanitize: "issue", required: true }
+};
+var issueTool = {
+  name: "krolik_issue",
+  description: "Parse a GitHub issue and extract context: checklist, mentioned files, priority.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      number: {
+        type: "string",
+        description: "GitHub issue number"
+      }
+    },
+    required: ["number"]
+  },
+  template: { when: "Parse GitHub issue details", params: '`number: "123"`' },
+  workflow: { trigger: "before_task", order: 2 },
+  category: "context",
+  handler: (args, projectRoot) => {
+    const result = buildFlags(args, issueSchema);
+    if (!result.ok) return result.error;
+    return runKrolik(`issue ${result.flags}`, projectRoot);
+  }
+};
+registerTool(issueTool);
+
+// src/mcp/tools/memory/index.ts
+var memSaveTool = {
+  name: "krolik_mem_save",
+  description: `Save memory: observation, decision, pattern, bugfix, or feature.
+
+Examples:
+- "Decided to use tRPC for type safety" (decision)
+- "Fixed race condition with mutex" (bugfix)
+- "All routes use validate -> execute -> audit pattern" (pattern)
+- "Users prefer dark mode toggle in header" (observation)
+- "Implemented real-time notifications with WebSockets" (feature)`,
+  template: { when: "Save decision/pattern/bugfix", params: '`type: "decision", title: "..."`' },
+  workflow: { trigger: "on_decision", order: 1 },
+  category: "memory",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      type: {
+        type: "string",
+        enum: ["observation", "decision", "pattern", "bugfix", "feature"],
+        description: "Type of memory entry"
+      },
+      title: {
+        type: "string",
+        description: 'Short summary (e.g., "Use tRPC for type safety")'
+      },
+      description: {
+        type: "string",
+        description: "Detailed description of the memory entry"
+      },
+      importance: {
+        type: "string",
+        enum: ["low", "medium", "high", "critical"],
+        description: "Importance level (default: medium)"
+      },
+      tags: {
+        type: "string",
+        description: 'Comma-separated tags (e.g., "api, typescript, performance")'
+      },
+      files: {
+        type: "string",
+        description: "Comma-separated file paths related to this memory"
+      },
+      features: {
+        type: "string",
+        description: 'Comma-separated features/domains (e.g., "booking, auth")'
+      }
+    },
+    required: ["type", "title", "description"]
+  },
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const flags = [];
+      if (args.type) flags.push(`--type "${args.type}"`);
+      if (args.title) flags.push(`--title "${String(args.title).replace(/"/g, '\\"')}"`);
+      if (args.description)
+        flags.push(`--description "${String(args.description).replace(/"/g, '\\"')}"`);
+      if (args.importance) flags.push(`--importance "${args.importance}"`);
+      if (args.tags) flags.push(`--tags "${args.tags}"`);
+      if (args.files) flags.push(`--files "${args.files}"`);
+      if (args.features) flags.push(`--features "${args.features}"`);
+      return runKrolik(`mem save ${flags.join(" ")}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+var memSearchTool = {
+  name: "krolik_mem_search",
+  description: `Search memory entries by query, type, tags, or feature.
+
+Examples:
+- Search for "tRPC" decisions
+- Find all "performance" related entries
+- Search patterns for "authentication"`,
+  template: { when: "Search memories by query", params: '`query: "authentication"`' },
+  category: "memory",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      query: {
+        type: "string",
+        description: "Search query (searches in title and description)"
+      },
+      type: {
+        type: "string",
+        enum: ["observation", "decision", "pattern", "bugfix", "feature"],
+        description: "Filter by memory type"
+      },
+      tags: {
+        type: "string",
+        description: "Filter by tags (comma-separated)"
+      },
+      features: {
+        type: "string",
+        description: "Filter by feature/domain (comma-separated)"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results (default: 10)"
+      }
+    }
+  },
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const flags = [];
+      if (args.query) flags.push(`--query "${String(args.query).replace(/"/g, '\\"')}"`);
+      if (args.type) flags.push(`--type "${args.type}"`);
+      if (args.tags) flags.push(`--tags "${args.tags}"`);
+      if (args.features) flags.push(`--features "${args.features}"`);
+      if (args.limit) flags.push(`--limit ${args.limit}`);
+      return runKrolik(`mem search ${flags.join(" ")}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+var memRecentTool = {
+  name: "krolik_mem_recent",
+  description: `Get recent memory entries, optionally filtered by type.
+
+Useful for:
+- Reviewing recent decisions
+- Checking latest bugfixes
+- Seeing recent patterns added`,
+  template: { when: "Get recent memories", params: "`limit: 5`" },
+  workflow: { trigger: "session_start", order: 2 },
+  category: "memory",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      limit: {
+        type: "number",
+        description: "Maximum number of entries to return (default: 10)"
+      },
+      type: {
+        type: "string",
+        enum: ["observation", "decision", "pattern", "bugfix", "feature"],
+        description: "Filter by memory type"
+      }
+    }
+  },
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const flags = [];
+      if (args.limit) flags.push(`--limit ${args.limit}`);
+      if (args.type) flags.push(`--type "${args.type}"`);
+      return runKrolik(`mem recent ${flags.join(" ")}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(memSaveTool);
+registerTool(memSearchTool);
+registerTool(memRecentTool);
+
+// src/mcp/tools/refactor/index.ts
+var refactorSchema = {
+  path: COMMON_FLAGS.path,
+  package: { flag: "--package", sanitize: "feature" },
+  allPackages: { flag: "--all-packages" },
+  duplicatesOnly: { flag: "--duplicates-only" },
+  typesOnly: { flag: "--types-only" },
+  includeTypes: { flag: "--include-types" },
+  structureOnly: { flag: "--structure-only" },
+  dryRun: COMMON_FLAGS.dryRun,
+  apply: COMMON_FLAGS.apply,
+  fixTypes: { flag: "--fix-types" }
+};
+var refactorTool = {
+  name: "krolik_refactor",
+  description: "Analyze and refactor module structure. Finds duplicate functions/types, analyzes structure, suggests migrations.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      path: {
+        type: "string",
+        description: "Path to analyze (default: auto-detect for monorepo)"
+      },
+      package: {
+        type: "string",
+        description: "Monorepo package to analyze (e.g., web, api)"
+      },
+      allPackages: {
+        type: "boolean",
+        description: "Analyze all packages in monorepo"
+      },
+      duplicatesOnly: {
+        type: "boolean",
+        description: "Only analyze duplicate functions"
+      },
+      typesOnly: {
+        type: "boolean",
+        description: "Only analyze duplicate types/interfaces"
+      },
+      includeTypes: {
+        type: "boolean",
+        description: "Include type/interface duplicate detection"
+      },
+      structureOnly: {
+        type: "boolean",
+        description: "Only analyze module structure"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Show migration plan without applying"
+      },
+      apply: {
+        type: "boolean",
+        description: "Apply migrations (move files, update imports)"
+      },
+      fixTypes: {
+        type: "boolean",
+        description: "Auto-fix type duplicates (merge identical types)"
+      }
+    }
+  },
+  template: { when: "Find duplicates/structure", params: "`dryRun: true`" },
+  workflow: { trigger: "on_refactor", order: 1 },
+  category: "code",
+  handler: (args, workspaceRoot) => {
+    const result = buildFlags(args, refactorSchema);
+    if (!result.ok) {
+      if (args.package && result.error.includes("package")) {
+        return "Error: Invalid package name.";
+      }
+      return result.error;
+    }
+    const flags = result.flags ? `${result.flags} --ai` : "--ai";
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      return runKrolik(`refactor ${flags}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(refactorTool);
+
+// src/mcp/tools/review/index.ts
+var reviewSchema = {
+  staged: COMMON_FLAGS.staged,
+  pr: COMMON_FLAGS.pr
+};
+var reviewTool = {
+  name: "krolik_review",
+  description: "Review code changes. Analyzes git diff for security issues, performance problems, and risks.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      staged: {
+        type: "boolean",
+        description: "Review only staged changes"
+      },
+      pr: {
+        type: "string",
+        description: "Review specific PR number"
+      }
+    }
+  },
+  template: { when: "After code changes", params: "`staged: true`" },
+  workflow: { trigger: "before_commit", order: 1 },
+  category: "code",
+  handler: (args, workspaceRoot) => {
+    const result = buildFlags(args, reviewSchema);
+    if (!result.ok) return result.error;
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      return runKrolik(`review ${result.flags}`, projectPath, TIMEOUT_60S);
+    });
+  }
+};
+registerTool(reviewTool);
+
+// src/mcp/tools/routes/index.ts
+var routesFlagSchema = {
+  json: COMMON_FLAGS.json
+};
+var routesTool = {
+  name: "krolik_routes",
+  description: "Analyze tRPC API routes. Returns all procedures with types, inputs, and protection status.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      json: {
+        type: "boolean",
+        description: "Return JSON format instead of markdown"
+      }
+    }
+  },
+  template: { when: "API routes questions", params: "\u2014" },
+  category: "context",
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const result = buildFlags(args, routesFlagSchema);
+      if (!result.ok) return result.error;
+      return runKrolik(`routes ${result.flags}`, projectPath);
+    });
+  }
+};
+registerTool(routesTool);
+
+// src/mcp/tools/schema/index.ts
+var schemaFlagSchema = {
+  json: COMMON_FLAGS.json
+};
+var schemaTool = {
+  name: "krolik_schema",
+  description: "Analyze Prisma database schema. Returns all models, fields, relations, and enums.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      json: {
+        type: "boolean",
+        description: "Return JSON format instead of markdown"
+      }
+    }
+  },
+  template: { when: "DB schema questions", params: "\u2014" },
+  category: "context",
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const result = buildFlags(args, schemaFlagSchema);
+      if (!result.ok) return result.error;
+      return runKrolik(`schema ${result.flags}`, projectPath);
+    });
+  }
+};
+registerTool(schemaTool);
+
+// src/mcp/tools/status/index.ts
+var statusTool = {
+  name: "krolik_status",
+  description: "Get project diagnostics: git status, typecheck, lint, TODOs. Use this to understand the current state of the project.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...PROJECT_PROPERTY,
+      fast: {
+        type: "boolean",
+        description: "Skip slow checks (typecheck, lint) for faster response"
+      }
+    }
+  },
+  template: { when: "Session start", params: "`fast: true`" },
+  workflow: { trigger: "session_start", order: 1 },
+  category: "start",
+  handler: (args, workspaceRoot) => {
+    return withProjectDetection(args, workspaceRoot, (projectPath) => {
+      const flags = args.fast ? "--fast" : "";
+      return runKrolik(`status ${flags}`, projectPath);
+    });
+  }
+};
+registerTool(statusTool);
+var DEFAULT_SKIP_DIRS = ["node_modules", ".next", "dist", ".git", ".turbo", "coverage", ".cache"];
+function exists(filePath) {
+  return fs6.existsSync(filePath);
+}
+function isDirectory(filePath) {
+  try {
+    return fs6.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readFile(filePath) {
+  try {
+    return fs6.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function writeFile(filePath, content) {
+  try {
+    const dir = path12.dirname(filePath);
+    if (!exists(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
+    }
+    fs6.writeFileSync(filePath, content, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJson(filePath) {
+  const content = readFile(filePath);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findFiles(dir, options = {}) {
+  const { extensions = [], skipDirs = DEFAULT_SKIP_DIRS, maxDepth = Infinity } = options;
+  const files = [];
+  function walk(currentDir, depth) {
+    if (depth > maxDepth || !exists(currentDir)) {
+      return;
+    }
+    let entries;
+    try {
+      entries = fs6.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path12.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!skipDirs.includes(entry.name)) {
+          walk(fullPath, depth + 1);
+        }
+      } else if (entry.isFile()) {
+        const ext = path12.extname(entry.name);
+        if (extensions.length === 0 || extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  walk(dir, 0);
+  return files;
+}
+function exec(command, options = {}) {
+  const { cwd, silent = true, timeout = 3e4, env } = options;
+  const execOptions = {
+    cwd,
+    encoding: "utf-8",
+    stdio: silent ? ["pipe", "pipe", "pipe"] : "inherit",
+    timeout,
+    env: env ? { ...process.env, ...env } : void 0
+  };
+  return execSync(command, execOptions).toString().trim();
+}
+function tryExec(command, options = {}) {
+  try {
+    const output = exec(command, options);
+    return { success: true, output };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      output: err.stdout?.toString() ?? "",
+      error: err.stderr?.toString() ?? err.message ?? "Unknown error"
+    };
+  }
+}
+function execLines(command, options = {}) {
+  const result = tryExec(command, options);
+  if (!result.success || !result.output) {
+    return [];
+  }
+  return result.output.split("\n").filter(Boolean);
+}
+function shellOpts(cwd) {
+  const opts = { silent: true };
+  if (cwd) opts.cwd = cwd;
+  return opts;
+}
+
+// src/lib/@git/local.ts
+var MAGIC_3_VALUE = 3;
+var MAGIC_3 = MAGIC_3_VALUE;
+function isGitRepo(cwd) {
+  const result = tryExec("git rev-parse --is-inside-work-tree", shellOpts(cwd));
+  return result.success && result.output === "true";
+}
+function getCurrentBranch(cwd) {
+  const result = tryExec("git branch --show-current", shellOpts(cwd));
+  return result.success ? result.output : null;
+}
+function getStatus(cwd) {
+  const result = tryExec("git status --porcelain", shellOpts(cwd));
+  const lines = result.success ? result.output.split("\n").filter(Boolean) : [];
+  const modified = [];
+  const untracked = [];
+  const staged = [];
+  for (const line of lines) {
+    const status = line.slice(0, 2);
+    const file = line.slice(MAGIC_3);
+    if (status.startsWith("?")) {
+      untracked.push(file);
+    } else if (status[0] !== " ") {
+      staged.push(file);
+    }
+    if (status[1] === "M" || status[0] === "M") {
+      modified.push(file);
+    }
+  }
+  return {
+    modified,
+    untracked,
+    staged,
+    hasChanges: lines.length > 0
+  };
+}
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+function createLogger(options = {}) {
+  const { level = "info", colors = true, write = console.log } = options;
+  const shouldLog = (msgLevel) => {
+    return LOG_LEVELS[msgLevel] >= LOG_LEVELS[level];
+  };
+  const format = colors ? {
+    debug: (msg) => chalk.dim(msg),
+    info: (msg) => chalk.cyan(msg),
+    warn: (msg) => chalk.yellow(msg),
+    error: (msg) => chalk.red(msg),
+    success: (msg) => chalk.green(msg),
+    header: (msg) => chalk.bold.blue(msg)
+  } : {
+    debug: (msg) => msg,
+    info: (msg) => msg,
+    warn: (msg) => `[WARN] ${msg}`,
+    error: (msg) => `[ERROR] ${msg}`,
+    success: (msg) => msg,
+    header: (msg) => msg
+  };
+  return {
+    debug(message) {
+      if (shouldLog("debug")) {
+        write(format.debug(message));
+      }
+    },
+    info(message) {
+      if (shouldLog("info")) {
+        write(format.info(message));
+      }
+    },
+    warn(message) {
+      if (shouldLog("warn")) {
+        write(format.warn(message));
+      }
+    },
+    error(message) {
+      if (shouldLog("error")) {
+        write(format.error(message));
+      }
+    },
+    success(message) {
+      if (shouldLog("info")) {
+        write(format.success(message));
+      }
+    },
+    section(title) {
+      if (shouldLog("info")) {
+        write("");
+        write(format.header("\u2550".repeat(60)));
+        write(format.header(`  ${title}`));
+        write(format.header("\u2550".repeat(60)));
+        write("");
+      }
+    },
+    box(lines, type = "info") {
+      if (!shouldLog("info")) return;
+      const maxLen = Math.max(...lines.map((l) => l.length));
+      const border = "\u2500".repeat(maxLen + 2);
+      const colorFn = type === "success" ? format.success : type === "warning" ? format.warn : type === "error" ? format.error : format.info;
+      write(colorFn(`\u250C${border}\u2510`));
+      for (const line of lines) {
+        write(colorFn(`\u2502 ${line.padEnd(maxLen)} \u2502`));
+      }
+      write(colorFn(`\u2514${border}\u2518`));
+    }
+  };
+}
+createLogger();
+/* @__PURE__ */ new Set([
+  SyntaxKind.IfStatement,
+  SyntaxKind.ForStatement,
+  SyntaxKind.ForInStatement,
+  SyntaxKind.ForOfStatement,
+  SyntaxKind.WhileStatement,
+  SyntaxKind.DoStatement,
+  SyntaxKind.CaseClause,
+  SyntaxKind.CatchClause,
+  SyntaxKind.ConditionalExpression
+]);
+/* @__PURE__ */ new Set([
+  SyntaxKind.AmpersandAmpersandToken,
+  // &&
+  SyntaxKind.BarBarToken,
+  // ||
+  SyntaxKind.QuestionQuestionToken
+  // ??
+]);
+
+// src/config/detect.ts
+function detectFeatures(projectRoot) {
+  const pkgPath = path12.join(projectRoot, "package.json");
+  const pkg = readJson(pkgPath);
+  if (!pkg) {
+    return {};
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const hasWorkspaces = Boolean(pkg.workspaces);
+  return {
+    prisma: "@prisma/client" in allDeps || "prisma" in allDeps,
+    trpc: "@trpc/server" in allDeps || "@trpc/client" in allDeps,
+    nextjs: "next" in allDeps,
+    react: "react" in allDeps,
+    monorepo: hasWorkspaces || exists(path12.join(projectRoot, "pnpm-workspace.yaml")),
+    typescript: "typescript" in allDeps || exists(path12.join(projectRoot, "tsconfig.json"))
+  };
+}
+function detectPaths(projectRoot, isMonorepo) {
+  const detected = {};
+  if (isMonorepo) {
+    const monorepoPatterns = [
+      { web: "apps/web", api: "packages/api", db: "packages/db", shared: "packages/shared" },
+      { web: "packages/web", api: "packages/api", db: "packages/db", shared: "packages/shared" },
+      {
+        web: "apps/frontend",
+        api: "apps/backend",
+        db: "packages/database",
+        shared: "packages/common"
+      }
+    ];
+    for (const pattern of monorepoPatterns) {
+      if (exists(path12.join(projectRoot, pattern.web))) {
+        detected.web = pattern.web;
+        detected.api = pattern.api;
+        detected.db = pattern.db;
+        detected.shared = pattern.shared;
+        break;
+      }
+    }
+  } else {
+    if (exists(path12.join(projectRoot, "src"))) {
+      detected.web = "src";
+      detected.lib = "src/lib";
+      detected.components = "src/components";
+      detected.hooks = "src/hooks";
+    }
+    if (exists(path12.join(projectRoot, "app"))) {
+      detected.web = "app";
+    }
+  }
+  return detected;
+}
+function detectPrisma(projectRoot, _webPath) {
+  const detected = {};
+  const multiSchemaPath = path12.join(projectRoot, "prisma/schema");
+  if (isDirectory(multiSchemaPath)) {
+    detected.schemaDir = "prisma/schema";
+    return detected;
+  }
+  const singleSchemaPath = path12.join(projectRoot, "prisma/schema.prisma");
+  if (exists(singleSchemaPath)) {
+    detected.schemaDir = "prisma/schema.prisma";
+    return detected;
+  }
+  const pkgDbSchema = path12.join(projectRoot, "packages/db/prisma/schema");
+  if (isDirectory(pkgDbSchema)) {
+    detected.schemaDir = "packages/db/prisma/schema";
+    return detected;
+  }
+  const pkgDbSingleSchema = path12.join(projectRoot, "packages/db/prisma/schema.prisma");
+  if (exists(pkgDbSingleSchema)) {
+    detected.schemaDir = "packages/db/prisma/schema.prisma";
+    return detected;
+  }
+  return detected;
+}
+function detectTrpc(projectRoot, _apiPath) {
+  const detected = {};
+  const routerPatterns = [
+    "src/server/routers",
+    "src/trpc/routers",
+    "server/routers",
+    "packages/api/src/routers",
+    "apps/api/src/routers"
+  ];
+  for (const pattern of routerPatterns) {
+    const fullPath = path12.join(projectRoot, pattern);
+    if (isDirectory(fullPath)) {
+      detected.routersDir = pattern;
+      const indexPath = path12.join(fullPath, "index.ts");
+      if (exists(indexPath)) {
+        detected.appRouter = `${pattern}/index.ts`;
+      }
+      break;
+    }
+  }
+  return detected;
+}
+function detectProjectName(projectRoot) {
+  const pkgPath = path12.join(projectRoot, "package.json");
+  const pkg = readJson(pkgPath);
+  return pkg?.name;
+}
+function detectMonorepoPackages(projectRoot) {
+  const packages = [];
+  const libPatterns = ["lib", "src/lib"];
+  const appsDir = path12.join(projectRoot, "apps");
+  if (isDirectory(appsDir)) {
+    const apps = fs6.readdirSync(appsDir).filter((name) => {
+      const fullPath = path12.join(appsDir, name);
+      return isDirectory(fullPath) && !name.startsWith(".");
+    });
+    for (const app of apps) {
+      const appPath = path12.join("apps", app);
+      for (const libPattern of libPatterns) {
+        const libPath = path12.join(appPath, libPattern);
+        const fullLibPath = path12.join(projectRoot, libPath);
+        if (isDirectory(fullLibPath)) {
+          let tsconfigPath = path12.join(appPath, "tsconfig.json");
+          if (!exists(path12.join(projectRoot, tsconfigPath))) {
+            tsconfigPath = "tsconfig.base.json";
+          }
+          packages.push({
+            name: app,
+            path: appPath,
+            libPath,
+            tsconfigPath,
+            type: "app"
+          });
+          break;
+        }
+      }
+    }
+  }
+  const packagesDir = path12.join(projectRoot, "packages");
+  if (isDirectory(packagesDir)) {
+    const pkgs = fs6.readdirSync(packagesDir).filter((name) => {
+      const fullPath = path12.join(packagesDir, name);
+      return isDirectory(fullPath) && !name.startsWith(".");
+    });
+    for (const pkg of pkgs) {
+      const pkgPath = path12.join("packages", pkg);
+      for (const libPattern of libPatterns) {
+        const libPath = path12.join(pkgPath, libPattern);
+        const fullLibPath = path12.join(projectRoot, libPath);
+        if (isDirectory(fullLibPath)) {
+          let tsconfigPath = path12.join(pkgPath, "tsconfig.json");
+          if (!exists(path12.join(projectRoot, tsconfigPath))) {
+            tsconfigPath = "tsconfig.base.json";
+          }
+          packages.push({
+            name: pkg,
+            path: pkgPath,
+            libPath,
+            tsconfigPath,
+            type: "package"
+          });
+          break;
+        }
+      }
+    }
+  }
+  return packages;
+}
+function detectAll(projectRoot) {
+  const features = detectFeatures(projectRoot);
+  const paths = detectPaths(projectRoot, features.monorepo ?? false);
+  const prisma = features.prisma ? detectPrisma(projectRoot, paths.web) : {};
+  const trpc = features.trpc ? detectTrpc(projectRoot, paths.api) : {};
+  const name = detectProjectName(projectRoot);
+  return {
+    name,
+    features,
+    paths,
+    prisma,
+    trpc
+  };
+}
+
+// src/config/domains.ts
+var DOMAIN_KEYWORDS = {
+  booking: [
+    "booking",
+    "slot",
+    "availability",
+    "schedule",
+    "appointment",
+    "reservation",
+    "calendar",
+    "time slot",
+    "bookingSettings",
+    "busySlot"
+  ],
+  events: ["events", "event", "ticket", "ticketing", "venue", "concert", "festival"],
+  places: ["places", "place", "business", "location", "restaurant", "cafe", "bar", "club"],
+  users: ["users", "user", "profile", "account", "auth", "login", "registration"],
+  crm: ["crm", "customer", "client", "lead", "contact", "interaction", "customerNote"],
+  gamification: [
+    "gamification",
+    "reward",
+    "points",
+    "achievement",
+    "badge",
+    "level",
+    "leaderboard",
+    "streak"
+  ],
+  payments: [
+    "payment",
+    "subscription",
+    "invoice",
+    "billing",
+    "transaction",
+    "refund",
+    "payout",
+    "stripe"
+  ],
+  notifications: [
+    "notification",
+    "email",
+    "sms",
+    "push",
+    "reminder",
+    "alert",
+    "message",
+    "template"
+  ],
+  admin: [
+    "admin",
+    "dashboard",
+    "analytics",
+    "moderation",
+    "report",
+    "stats",
+    "metrics",
+    "management"
+  ],
+  mobile: ["mobile", "expo", "react native", "app", "ios", "android", "push notification"]
+};
+var DOMAIN_FILES = {
+  booking: [
+    "packages/api/src/routers/booking*.ts",
+    "packages/api/src/routers/business/booking*.ts",
+    "apps/web/components/Business/Booking/**/*.tsx",
+    "apps/web/components/booking/**/*.tsx",
+    "packages/db/prisma/models/booking*.prisma",
+    "packages/shared/src/schemas/booking*.ts"
+  ],
+  events: [
+    "packages/api/src/routers/events*.ts",
+    "packages/api/src/routers/business/ticketing*.ts",
+    "apps/web/components/Business/Ticketing/**/*.tsx",
+    "apps/web/components/events/**/*.tsx",
+    "packages/db/prisma/models/event*.prisma",
+    "packages/db/prisma/models/ticket*.prisma",
+    "packages/shared/src/schemas/event*.ts"
+  ],
+  places: [
+    "packages/api/src/routers/places*.ts",
+    "packages/api/src/routers/business*.ts",
+    "apps/web/components/Business/**/*.tsx",
+    "apps/web/components/places/**/*.tsx",
+    "packages/db/prisma/models/place*.prisma",
+    "packages/db/prisma/models/business*.prisma",
+    "packages/shared/src/schemas/place*.ts"
+  ],
+  users: [
+    "packages/api/src/routers/user*.ts",
+    "packages/api/src/routers/auth*.ts",
+    "apps/web/components/auth/**/*.tsx",
+    "apps/web/components/profile/**/*.tsx",
+    "packages/db/prisma/models/user*.prisma",
+    "packages/shared/src/schemas/user*.ts"
+  ],
+  crm: [
+    "packages/api/src/routers/business/crm*.ts",
+    "packages/api/src/routers/customer*.ts",
+    "apps/web/components/Business/CRM/**/*.tsx",
+    "packages/db/prisma/models/customer*.prisma",
+    "packages/shared/src/schemas/customer*.ts"
+  ],
+  gamification: [
+    "packages/api/src/routers/gamification*.ts",
+    "apps/web/components/gamification/**/*.tsx",
+    "packages/db/prisma/models/gamification*.prisma",
+    "packages/shared/src/schemas/gamification*.ts"
+  ],
+  payments: [
+    "packages/api/src/routers/payment*.ts",
+    "packages/api/src/routers/subscription*.ts",
+    "apps/web/components/payments/**/*.tsx",
+    "packages/db/prisma/models/payment*.prisma",
+    "packages/db/prisma/models/subscription*.prisma"
+  ],
+  notifications: [
+    "packages/api/src/routers/notification*.ts",
+    "apps/web/components/notifications/**/*.tsx",
+    "packages/db/prisma/models/notification*.prisma"
+  ],
+  admin: [
+    "packages/api/src/routers/admin*.ts",
+    "apps/web/components/admin/**/*.tsx",
+    "apps/web/app/admin/**/*.tsx"
+  ],
+  mobile: ["apps/mobile/**/*.tsx", "apps/mobile/**/*.ts", "packages/shared/src/mobile/**/*.ts"]
+};
+var DOMAIN_APPROACHES = {
+  booking: [
+    "Check existing Booking schema in packages/db/prisma/models/",
+    "Review tRPC router at packages/api/src/routers/",
+    "Update Zod schemas in packages/shared/",
+    "Create/update React components in apps/web/components/Business/Booking/",
+    "Add tests for new booking logic"
+  ],
+  events: [
+    "Check Event/Ticket schemas in packages/db/prisma/models/",
+    "Review tRPC router for events/ticketing",
+    "Update Zod schemas in packages/shared/",
+    "Create/update React components in apps/web/components/Business/Ticketing/",
+    "Consider event occurrence patterns"
+  ],
+  places: [
+    "Check Place/Business schemas in packages/db/prisma/models/",
+    "Review tRPC router for places/business",
+    "Update Zod schemas in packages/shared/",
+    "Consider business hours and availability"
+  ],
+  users: [
+    "Check User schema in packages/db/prisma/models/",
+    "Review auth router in packages/api/",
+    "Update authentication middleware if needed",
+    "Consider email verification flow"
+  ],
+  crm: [
+    "Check Customer schema in packages/db/prisma/models/",
+    "Review CRM router in packages/api/src/routers/business/",
+    "Update customer interaction tracking",
+    "Consider segmentation logic"
+  ],
+  gamification: [
+    "Check Gamification schema in packages/db/prisma/models/",
+    "Review points calculation logic",
+    "Update achievement triggers",
+    "Consider leaderboard queries performance"
+  ],
+  payments: [
+    "Check Payment/Subscription schemas",
+    "Review Stripe integration",
+    "Update webhook handlers",
+    "Consider refund flow"
+  ],
+  notifications: [
+    "Check Notification schema",
+    "Review email/SMS templates",
+    "Update notification triggers",
+    "Consider push notification setup"
+  ],
+  admin: [
+    "Check admin permissions",
+    "Review dashboard queries for performance",
+    "Update analytics aggregations",
+    "Consider data export functionality"
+  ],
+  mobile: [
+    "Check Expo setup in apps/mobile/",
+    "Review shared components from packages/shared/",
+    "Update navigation structure",
+    "Consider offline support"
+  ]
+};
+function detectDomains(text) {
+  const lowerText = text.toLowerCase();
+  const detected = [];
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+    for (const keyword of keywords) {
+      if (lowerText.includes(keyword.toLowerCase())) {
+        if (!detected.includes(domain)) {
+          detected.push(domain);
+        }
+        break;
+      }
+    }
+  }
+  return detected;
+}
+function getRelatedFiles(domains) {
+  const files = [];
+  for (const domain of domains) {
+    const patterns = DOMAIN_FILES[domain];
+    if (patterns) {
+      files.push(...patterns);
+    }
+  }
+  return [...new Set(files)];
+}
+function getApproaches(domains) {
+  const approaches = [];
+  for (const domain of domains) {
+    const steps = DOMAIN_APPROACHES[domain];
+    if (steps) {
+      approaches.push(...steps);
+    }
+  }
+  return [...new Set(approaches)];
+}
+var CONFIG_MODULE_NAME = "krolik";
+var cachedConfig = null;
+var cachedProjectRoot = null;
+function findProjectRoot2(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== path12.dirname(currentDir)) {
+    const pkgPath = path12.join(currentDir, "package.json");
+    try {
+      const fs11 = __require("fs");
+      if (fs11.existsSync(pkgPath)) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = path12.dirname(currentDir);
+  }
+  return startDir;
+}
+async function loadConfigFile(projectRoot) {
+  const explorer = cosmiconfig(CONFIG_MODULE_NAME, {
+    searchPlaces: [
+      "krolik.config.ts",
+      "krolik.config.js",
+      "krolik.config.mjs",
+      "krolik.config.json",
+      "krolik.config.yaml",
+      "krolik.config.yml",
+      "krolik.yaml",
+      "krolik.yml",
+      ".krolikrc",
+      ".krolikrc.json",
+      ".krolikrc.yaml",
+      ".krolikrc.yml",
+      ".krolikrc.js",
+      ".krolikrc.ts"
+    ]
+  });
+  try {
+    const result = await explorer.search(projectRoot);
+    return result?.config ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveConfig(userConfig, detected, projectRoot) {
+  const base = createDefaultConfig(projectRoot);
+  const resolvedPaths = {
+    ...base.paths,
+    ...detected.paths,
+    ...userConfig?.paths
+  };
+  const resolvedFeatures = {
+    ...base.features,
+    ...detected.features,
+    ...userConfig?.features
+  };
+  const resolvedPrisma = {
+    ...base.prisma,
+    ...detected.prisma,
+    ...userConfig?.prisma
+  };
+  const resolvedTrpc = {
+    ...base.trpc,
+    ...detected.trpc,
+    ...userConfig?.trpc
+  };
+  return {
+    name: userConfig?.name ?? detected.name ?? base.name,
+    projectRoot: userConfig?.projectRoot ?? projectRoot,
+    paths: resolvedPaths,
+    features: resolvedFeatures,
+    prisma: resolvedPrisma,
+    trpc: resolvedTrpc,
+    templates: { ...base.templates, ...userConfig?.templates },
+    exclude: userConfig?.exclude ?? base.exclude,
+    extensions: userConfig?.extensions ?? base.extensions
+  };
+}
+async function loadConfig(options = {}) {
+  const { projectRoot: explicitRoot, noCache = false } = options;
+  const projectRoot = explicitRoot ?? findProjectRoot2();
+  if (!noCache && cachedConfig && cachedProjectRoot === projectRoot) {
+    return cachedConfig;
+  }
+  const userConfig = await loadConfigFile(projectRoot);
+  const detected = detectAll(projectRoot);
+  const resolved = resolveConfig(userConfig, detected, projectRoot);
+  cachedConfig = resolved;
+  cachedProjectRoot = projectRoot;
+  return resolved;
+}
+function getConfig() {
+  if (!cachedConfig) {
+    const projectRoot = findProjectRoot2();
+    const detected = detectAll(projectRoot);
+    return resolveConfig(null, detected, projectRoot);
+  }
+  return cachedConfig;
+}
+function clearConfigCache() {
+  cachedConfig = null;
+  cachedProjectRoot = null;
+}
+function defineConfig(config) {
+  return config;
+}
+
+export { DEFAULT_EXCLUDE, DEFAULT_EXTENSIONS, DEFAULT_FEATURES, DEFAULT_PATHS, DOMAIN_APPROACHES, DOMAIN_FILES, DOMAIN_KEYWORDS, clearConfigCache, createDefaultConfig, createLogger, defineConfig, detectAll, detectDomains, detectFeatures, detectMonorepoPackages, detectPaths, detectPrisma, detectProjectName, detectTrpc, exec, execLines, findFiles, findProjectRoot2 as findProjectRoot, getApproaches, getConfig, getCurrentBranch, getRelatedFiles, getStatus, isGitRepo, loadConfig, readFile, tryExec, writeFile };
+//# sourceMappingURL=chunk-DTDOBWO6.js.map
+//# sourceMappingURL=chunk-DTDOBWO6.js.map