@klitchevo/code-council 0.0.16 → 0.1.0

package/README.md

@@ -183,6 +183,7 @@ Review code for quality, bugs, performance, and security issues.
 - `code` (required): The code to review
 - `language` (optional): Programming language
 - `context` (optional): Additional context about the code
+- `output_format` (optional): `markdown`, `json`, or `html` (default: `markdown`)
 
 **Example usage in Claude:**
 ```
@@ -199,6 +200,7 @@ Review frontend code with focus on accessibility, performance, and UX.
 - `framework` (optional): Framework name (e.g., react, vue, svelte)
 - `review_type` (optional): `accessibility`, `performance`, `ux`, or `full` (default)
 - `context` (optional): Additional context
+- `output_format` (optional): `markdown`, `json`, or `html` (default: `markdown`)
 
 **Example usage in Claude:**
 ```
@@ -215,6 +217,7 @@ Review backend code for security, performance, and architecture.
 - `language` (optional): Language/framework (e.g., node, python, go, rust)
 - `review_type` (optional): `security`, `performance`, `architecture`, or `full` (default)
 - `context` (optional): Additional context
+- `output_format` (optional): `markdown`, `json`, or `html` (default: `markdown`)
 
 **Example usage in Claude:**
 ```
@@ -230,6 +233,7 @@ Review implementation plans BEFORE coding to catch issues early.
 - `plan` (required): The implementation plan to review
 - `review_type` (optional): `feasibility`, `completeness`, `risks`, `timeline`, or `full` (default)
 - `context` (optional): Project constraints or context
+- `output_format` (optional): `markdown`, `json`, or `html` (default: `markdown`)
 
 **Example usage in Claude:**
 ```
@@ -249,6 +253,7 @@ Review git changes directly from your repository.
   - `commit` - Review a specific commit (requires `commit_hash`)
 - `commit_hash` (optional): Commit hash to review (required when `review_type` is `commit`)
 - `context` (optional): Additional context about the changes
+- `output_format` (optional): `markdown`, `json`, or `html` (default: `markdown`)
 
 **Example usage in Claude:**
 ```
@@ -329,11 +334,146 @@ Reports are saved to `.code-council/` directory:
 
 Show which AI models are currently configured for each review type.
 
+### `init_config`
+
+Generate a Code Council configuration file with default values.
+
+**Parameters:**
+- `location` (optional): Where to create the config file
+  - `directory` (default) - Creates `.code-council/config.ts`
+  - `root` - Creates `code-council.config.ts` in project root
+- `format` (optional): Config file format
+  - `typescript` (default) - TypeScript with full type support
+  - `javascript` - Plain JavaScript
+- `include_comments` (optional): Include explanatory comments (default: `true`)
+- `force` (optional): Overwrite existing config file (default: `false`)
+
+**Example usage in Claude:**
+```
+Use init_config to generate a configuration file
+```
+
+```
+Use init_config with location=root and format=javascript
+```
+
 ## Configuration
 
-### Customizing Models
+Code Council supports two configuration methods:
+1. **Config file** (recommended) - TypeScript/JavaScript config file with full type support
+2. **Environment variables** - Quick setup via MCP client config
 
-You can customize which AI models are used for reviews by setting environment variables in your MCP client configuration. Each review type can use different models.
+### Config File (Recommended)
+
+Create a config file in your project for full type support and autocompletion:
+
+**Option 1: `.code-council/config.ts`** (recommended)
+```typescript
+import { defineConfig } from "@klitchevo/code-council/config";
+
+export default defineConfig({
+  models: {
+    codeReview: ["anthropic/claude-sonnet-4", "openai/gpt-4o"],
+    frontendReview: ["anthropic/claude-sonnet-4"],
+    backendReview: ["openai/gpt-4o", "google/gemini-2.0-flash-exp"],
+  },
+  llm: {
+    temperature: 0.3,
+    maxTokens: 16384,
+  },
+});
+```
+
+**Option 2: `code-council.config.ts`** (project root)
+```typescript
+import { defineConfig } from "@klitchevo/code-council/config";
+
+export default defineConfig({
+  // Same options as above
+});
+```
+
+**Generate a config file via CLI:**
+```bash
+npx @klitchevo/code-council init
+```
+
+**CLI Options:**
+```bash
+npx @klitchevo/code-council init [options]
+
+Options:
+  --ts, --typescript   Generate TypeScript config (default)
+  --js, --javascript   Generate JavaScript config
+  --root               Create config in project root (code-council.config.ts)
+  --dir, --directory   Create config in .code-council/ directory (default)
+  --no-comments        Generate config without explanatory comments
+  --force, -f          Overwrite existing config file
+
+Examples:
+  npx @klitchevo/code-council init              # Creates .code-council/config.ts
+  npx @klitchevo/code-council init --js --root  # Creates code-council.config.js
+  npx @klitchevo/code-council init --force      # Overwrite existing config
+```
+
+**Or use the MCP tool:**
+```
+Use init_config to generate a configuration file
+```
+
+#### Complete Config Options
+
+```typescript
+import { defineConfig } from "@klitchevo/code-council/config";
+
+export default defineConfig({
+  // Models for each review type
+  models: {
+    defaultModels: ["model1", "model2"],    // Fallback for all types
+    codeReview: ["model1", "model2"],       // General code reviews
+    frontendReview: ["model1"],             // Frontend reviews
+    backendReview: ["model1", "model2"],    // Backend reviews
+    planReview: ["model1"],                 // Plan reviews
+    discussion: ["model1", "model2"],       // Council discussions
+    tpsAudit: ["model1", "model2"],         // TPS audits
+  },
+
+  // Consensus analysis settings (all reviews use consensus by default)
+  consensus: {
+    modelWeights: {                         // Weight models differently
+      "anthropic/claude-sonnet-4": 1.2,     // Higher = more influence
+      "openai/gpt-4o": 1.0,
+    },
+    highConfidenceThreshold: 0.8,           // Threshold for high confidence
+    moderateConfidenceThreshold: 0.5,       // Threshold for moderate confidence
+  },
+
+  // LLM behavior
+  llm: {
+    temperature: 0.3,                       // 0.0-2.0, lower = more focused
+    maxTokens: 16384,                       // Max response length
+  },
+
+  // Session settings for council discussions
+  session: {
+    maxSessions: 100,                       // Max concurrent sessions
+    maxMessagesPerModel: 20,                // Messages before context windowing
+    ttlMs: 1800000,                         // Session timeout (30 min default)
+    rateLimitPerMinute: 10,                 // Rate limit per session
+  },
+
+  // Input limits
+  inputLimits: {
+    maxCodeLength: 100000,                  // Max code input length
+    maxContextLength: 50000,                // Max context length
+    maxModels: 10,                          // Max models per review
+  },
+});
+```
+
+### Environment Variables
+
+For quick setup without a config file, use environment variables in your MCP client configuration.
 
 **Available Environment Variables:**
 - `CODE_REVIEW_MODELS` - Models for general code reviews
@@ -367,14 +507,23 @@ You can customize which AI models are used for reviews by setting environment va
 }
 ```
 
-**Default Models:**
+### Configuration Priority
+
+Config file settings take priority over environment variables:
+1. Config file value (if set)
+2. Environment variable (if set)
+3. Default value
+
+### Default Models
+
 If you don't specify models, the server uses these defaults:
 - `minimax/minimax-m2.1` - Fast, cost-effective reasoning
 - `z-ai/glm-4.7` - Strong multilingual capabilities
 - `moonshotai/kimi-k2-thinking` - Advanced reasoning with thinking
 - `deepseek/deepseek-v3.2` - State-of-the-art open model
 
-**Finding Models:**
+### Finding Models
+
 Browse all available models at [OpenRouter Models](https://openrouter.ai/models). Popular choices include:
 - `anthropic/claude-sonnet-4.5` - Latest Sonnet, excellent for code review
 - `anthropic/claude-opus-4.5` - Frontier reasoning model for complex tasks

package/dist/chunk-JAGOVGRD.js

@@ -0,0 +1,393 @@
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-W4FYPS5Z.js";
+
+// src/consensus/formatter.ts
+function formatReport(report, format = "markdown") {
+  switch (format) {
+    case "json":
+      return formatJson(report);
+    case "html":
+      return formatHtml(report);
+    case "markdown":
+    default:
+      return formatMarkdown(report);
+  }
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function severityEmoji(severity) {
+  switch (severity) {
+    case "critical":
+      return "\u{1F534}";
+    case "high":
+      return "\u{1F7E0}";
+    case "medium":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F535}";
+    case "info":
+      return "\u26AA";
+    default:
+      return "\u26AA";
+  }
+}
+function consensusBadge(consensusType) {
+  switch (consensusType) {
+    case "unanimous":
+      return "\u2705 Unanimous";
+    case "majority":
+      return "\u{1F465} Majority";
+    case "minority":
+      return "\u26A0\uFE0F Minority";
+    case "single":
+      return "\u{1F464} Single";
+    default:
+      return consensusType;
+  }
+}
+function formatClusterMarkdown(cluster, index) {
+  const lines = [];
+  lines.push(
+    `### ${index + 1}. ${severityEmoji(cluster.severity)} ${cluster.title}`
+  );
+  lines.push("");
+  lines.push(`**Category:** ${cluster.category}`);
+  lines.push(`**Severity:** ${cluster.severity}`);
+  lines.push(`**Confidence:** ${(cluster.confidence * 100).toFixed(0)}%`);
+  lines.push(`**Consensus:** ${consensusBadge(cluster.consensusType)}`);
+  if (cluster.canonicalLocation) {
+    const loc = cluster.canonicalLocation;
+    const lineInfo = loc.line ? loc.endLine ? `:${loc.line}-${loc.endLine}` : `:${loc.line}` : "";
+    lines.push(`**Location:** \`${loc.file}${lineInfo}\``);
+  }
+  lines.push("");
+  if (cluster.agreeingModels.length > 0) {
+    lines.push(
+      `**Reported by:** ${cluster.agreeingModels.map((m) => `\`${m}\``).join(", ")}`
+    );
+  }
+  if (cluster.silentModels.length > 0) {
+    lines.push(
+      `**Not mentioned by:** ${cluster.silentModels.map((m) => `\`${m}\``).join(", ")}`
+    );
+  }
+  lines.push("");
+  if (cluster.findings.length > 0) {
+    lines.push("**Details from each model:**");
+    lines.push("");
+    for (const finding of cluster.findings) {
+      lines.push(`- **${finding.sourceModel}**: ${finding.description}`);
+      if (finding.suggestion) {
+        lines.push(`  - *Suggestion:* ${finding.suggestion}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+}
+function formatDisagreementMarkdown(disagreement, index) {
+  const lines = [];
+  lines.push(`### \u2694\uFE0F Disagreement ${index + 1}: ${disagreement.topic}`);
+  lines.push("");
+  lines.push(`**Category:** ${disagreement.category}`);
+  if (disagreement.location) {
+    const loc = disagreement.location;
+    const lineInfo = loc.line ? `:${loc.line}` : "";
+    lines.push(`**Location:** \`${loc.file}${lineInfo}\``);
+  }
+  lines.push("");
+  lines.push("**Positions:**");
+  lines.push("");
+  for (const pos of disagreement.positions) {
+    lines.push(`- **${pos.model}**: ${pos.stance}`);
+    if (pos.reasoning) {
+      lines.push(`  - *Reasoning:* ${pos.reasoning.substring(0, 200)}...`);
+    }
+  }
+  lines.push("");
+  lines.push(`**Action Required:** ${disagreement.humanActionRequired}`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+}
+function formatMarkdown(report) {
+  const lines = [];
+  lines.push("# Consensus Code Review Report");
+  lines.push("");
+  lines.push(`*Generated: ${report.generatedAt}*`);
+  lines.push(`*Execution time: ${report.executionTimeMs}ms*`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(
+    `- **Participating Models:** ${report.participatingModels.length}`
+  );
+  lines.push(`- **Total Findings:** ${report.totalFindings}`);
+  lines.push(`- **High Confidence Issues:** ${report.highConfidence.length}`);
+  lines.push(
+    `- **Moderate Confidence Issues:** ${report.moderateConfidence.length}`
+  );
+  lines.push(`- **Low Confidence Issues:** ${report.lowConfidence.length}`);
+  lines.push(
+    `- **Disagreements Requiring Review:** ${report.disagreements.length}`
+  );
+  lines.push("");
+  lines.push("### Consensus Distribution");
+  lines.push("");
+  lines.push(`| Type | Count |`);
+  lines.push(`|------|-------|`);
+  lines.push(`| \u2705 Unanimous | ${report.stats.unanimous} |`);
+  lines.push(`| \u{1F465} Majority | ${report.stats.majority} |`);
+  lines.push(`| \u26A0\uFE0F Minority | ${report.stats.minority} |`);
+  lines.push(`| \u{1F464} Single | ${report.stats.single} |`);
+  lines.push(`| \u2694\uFE0F Disagreements | ${report.stats.disagreements} |`);
+  lines.push("");
+  lines.push("### Participating Models");
+  lines.push("");
+  for (const model of report.participatingModels) {
+    const weight = report.modelWeights[model] ?? 1;
+    lines.push(`- \`${model}\` (weight: ${weight})`);
+  }
+  lines.push("");
+  if (report.highConfidence.length > 0) {
+    lines.push("## \u{1F525} High Confidence Findings");
+    lines.push("");
+    lines.push(
+      `*These findings have ${report.thresholds.high * 100}%+ model agreement*`
+    );
+    lines.push("");
+    report.highConfidence.forEach((cluster, i) => {
+      lines.push(formatClusterMarkdown(cluster, i));
+    });
+  }
+  if (report.moderateConfidence.length > 0) {
+    lines.push("## \u26A1 Moderate Confidence Findings");
+    lines.push("");
+    lines.push(
+      `*These findings have ${report.thresholds.moderate * 100}%-${report.thresholds.high * 100}% model agreement*`
+    );
+    lines.push("");
+    report.moderateConfidence.forEach((cluster, i) => {
+      lines.push(formatClusterMarkdown(cluster, i));
+    });
+  }
+  if (report.lowConfidence.length > 0) {
+    lines.push("## \u{1F4AD} Low Confidence Findings");
+    lines.push("");
+    lines.push(
+      `*These findings have less than ${report.thresholds.moderate * 100}% model agreement*`
+    );
+    lines.push("");
+    report.lowConfidence.forEach((cluster, i) => {
+      lines.push(formatClusterMarkdown(cluster, i));
+    });
+  }
+  if (report.disagreements.length > 0) {
+    lines.push("## \u2694\uFE0F Disagreements Requiring Human Review");
+    lines.push("");
+    lines.push(
+      "*These issues have conflicting opinions from different models and need human decision*"
+    );
+    lines.push("");
+    report.disagreements.forEach((disagreement, i) => {
+      lines.push(formatDisagreementMarkdown(disagreement, i));
+    });
+  }
+  if (report.metadata) {
+    lines.push("## Metadata");
+    lines.push("");
+    lines.push(
+      `- **Extraction Model:** \`${report.metadata.extractionModel}\``
+    );
+    lines.push(`- **Extraction Errors:** ${report.metadata.extractionErrors}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("*Report generated by code-council consensus analysis*");
+  return lines.join("\n");
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function formatClusterHtml(cluster) {
+  const severityClass = `severity-${cluster.severity}`;
+  const location = cluster.canonicalLocation ? `<code>${escapeHtml(cluster.canonicalLocation.file)}${cluster.canonicalLocation.line ? `:${cluster.canonicalLocation.line}` : ""}</code>` : "N/A";
+  return `
+    <div class="finding-cluster ${severityClass}">
+      <h3>${severityEmoji(cluster.severity)} ${escapeHtml(cluster.title)}</h3>
+      <div class="metadata">
+        <span class="badge category">${escapeHtml(cluster.category)}</span>
+        <span class="badge severity">${escapeHtml(cluster.severity)}</span>
+        <span class="badge confidence">${(cluster.confidence * 100).toFixed(0)}%</span>
+        <span class="badge consensus">${consensusBadge(cluster.consensusType)}</span>
+      </div>
+      <p><strong>Location:</strong> ${location}</p>
+      <p><strong>Reported by:</strong> ${cluster.agreeingModels.map((m) => `<code>${escapeHtml(m)}</code>`).join(", ")}</p>
+      ${cluster.silentModels.length > 0 ? `<p><strong>Not mentioned by:</strong> ${cluster.silentModels.map((m) => `<code>${escapeHtml(m)}</code>`).join(", ")}</p>` : ""}
+      <div class="findings">
+        ${cluster.findings.map(
+    (f) => `
+          <div class="finding">
+            <strong>${escapeHtml(f.sourceModel)}:</strong> ${escapeHtml(f.description)}
+            ${f.suggestion ? `<br><em>Suggestion: ${escapeHtml(f.suggestion)}</em>` : ""}
+          </div>
+        `
+  ).join("")}
+      </div>
+    </div>
+  `;
+}
+function formatDisagreementHtml(disagreement) {
+  return `
+    <div class="disagreement">
+      <h3>\u2694\uFE0F ${escapeHtml(disagreement.topic)}</h3>
+      <p><strong>Category:</strong> ${escapeHtml(disagreement.category)}</p>
+      ${disagreement.location ? `<p><strong>Location:</strong> <code>${escapeHtml(disagreement.location.file)}${disagreement.location.line ? `:${disagreement.location.line}` : ""}</code></p>` : ""}
+      <div class="positions">
+        <h4>Positions:</h4>
+        <ul>
+          ${disagreement.positions.map(
+    (p) => `
+            <li>
+              <strong>${escapeHtml(p.model)}:</strong> ${escapeHtml(p.stance)}
+              ${p.reasoning ? `<br><em>${escapeHtml(p.reasoning.substring(0, 200))}...</em>` : ""}
+            </li>
+          `
+  ).join("")}
+        </ul>
+      </div>
+      <p class="action-required"><strong>Action Required:</strong> ${escapeHtml(disagreement.humanActionRequired)}</p>
+    </div>
+  `;
+}
+function formatHtml(report) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Consensus Code Review Report</title>
+  <style>
+    :root {
+      --critical: #dc2626;
+      --high: #f97316;
+      --medium: #eab308;
+      --low: #3b82f6;
+      --info: #6b7280;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #f9fafb;
+      color: #1f2937;
+    }
+    h1 { color: #111827; border-bottom: 2px solid #e5e7eb; padding-bottom: 0.5rem; }
+    h2 { color: #374151; margin-top: 2rem; }
+    .summary { background: white; padding: 1.5rem; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+    .stats-table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
+    .stats-table th, .stats-table td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #e5e7eb; }
+    .stats-table th { background: #f3f4f6; }
+    .finding-cluster, .disagreement {
+      background: white;
+      padding: 1.5rem;
+      border-radius: 8px;
+      margin: 1rem 0;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+      border-left: 4px solid var(--info);
+    }
+    .severity-critical { border-left-color: var(--critical); }
+    .severity-high { border-left-color: var(--high); }
+    .severity-medium { border-left-color: var(--medium); }
+    .severity-low { border-left-color: var(--low); }
+    .badge {
+      display: inline-block;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+      font-size: 0.875rem;
+      margin-right: 0.5rem;
+      background: #e5e7eb;
+    }
+    .badge.category { background: #dbeafe; color: #1e40af; }
+    .badge.severity { background: #fef3c7; color: #92400e; }
+    .badge.confidence { background: #d1fae5; color: #065f46; }
+    .badge.consensus { background: #f3e8ff; color: #6b21a8; }
+    code { background: #f3f4f6; padding: 0.125rem 0.375rem; border-radius: 4px; font-size: 0.875rem; }
+    .findings { margin-top: 1rem; padding-top: 1rem; border-top: 1px solid #e5e7eb; }
+    .finding { margin: 0.5rem 0; }
+    .disagreement { border-left-color: #ef4444; }
+    .action-required { background: #fef2f2; padding: 1rem; border-radius: 4px; margin-top: 1rem; }
+    .metadata { margin: 0.5rem 0; }
+    footer { margin-top: 2rem; color: #6b7280; font-size: 0.875rem; text-align: center; }
+  </style>
+</head>
+<body>
+  <h1>\u{1F3AF} Consensus Code Review Report</h1>
+
+  <div class="summary">
+    <h2>Summary</h2>
+    <p><strong>Generated:</strong> ${escapeHtml(report.generatedAt)}</p>
+    <p><strong>Execution Time:</strong> ${report.executionTimeMs}ms</p>
+    <p><strong>Participating Models:</strong> ${report.participatingModels.map((m) => `<code>${escapeHtml(m)}</code>`).join(", ")}</p>
+    <p><strong>Total Findings:</strong> ${report.totalFindings}</p>
+
+    <table class="stats-table">
+      <tr><th>Consensus Type</th><th>Count</th></tr>
+      <tr><td>\u2705 Unanimous</td><td>${report.stats.unanimous}</td></tr>
+      <tr><td>\u{1F465} Majority</td><td>${report.stats.majority}</td></tr>
+      <tr><td>\u26A0\uFE0F Minority</td><td>${report.stats.minority}</td></tr>
+      <tr><td>\u{1F464} Single</td><td>${report.stats.single}</td></tr>
+      <tr><td>\u2694\uFE0F Disagreements</td><td>${report.stats.disagreements}</td></tr>
+    </table>
+  </div>
+
+  ${report.highConfidence.length > 0 ? `
+    <h2>\u{1F525} High Confidence Findings (${report.thresholds.high * 100}%+ agreement)</h2>
+    ${report.highConfidence.map(formatClusterHtml).join("")}
+  ` : ""}
+
+  ${report.moderateConfidence.length > 0 ? `
+    <h2>\u26A1 Moderate Confidence Findings (${report.thresholds.moderate * 100}%-${report.thresholds.high * 100}% agreement)</h2>
+    ${report.moderateConfidence.map(formatClusterHtml).join("")}
+  ` : ""}
+
+  ${report.lowConfidence.length > 0 ? `
+    <h2>\u{1F4AD} Low Confidence Findings (&lt;${report.thresholds.moderate * 100}% agreement)</h2>
+    ${report.lowConfidence.map(formatClusterHtml).join("")}
+  ` : ""}
+
+  ${report.disagreements.length > 0 ? `
+    <h2>\u2694\uFE0F Disagreements Requiring Human Review</h2>
+    ${report.disagreements.map(formatDisagreementHtml).join("")}
+  ` : ""}
+
+  ${report.metadata ? `
+    <h2>Metadata</h2>
+    <p><strong>Extraction Model:</strong> <code>${escapeHtml(report.metadata.extractionModel)}</code></p>
+    <p><strong>Extraction Errors:</strong> ${report.metadata.extractionErrors}</p>
+  ` : ""}
+
+  <footer>
+    Report generated by code-council consensus analysis
+  </footer>
+</body>
+</html>`;
+}
+var init_formatter = __esm({
+  "src/consensus/formatter.ts"() {
+    init_esm_shims();
+  }
+});
+
+export {
+  formatReport,
+  init_formatter
+};
+//# sourceMappingURL=chunk-JAGOVGRD.js.map

package/dist/{chunk-W4MFXWTT.js → chunk-RIJGRVVH.js}

@@ -1,4 +1,9 @@
+import {
+  init_esm_shims
+} from "./chunk-W4FYPS5Z.js";
+
 // src/prompts/tps-audit.ts
+init_esm_shims();
 var SYSTEM_PROMPT = `You are an expert Toyota Production System (TPS) consultant analyzing software codebases. Your role is to "walk the production line" - examining how code flows from input to output, identifying waste (muda), spotting bottlenecks, and suggesting continuous improvement (kaizen).
 
 ## TPS Principles for Software
@@ -307,4 +312,4 @@ export {
   buildSynthesisUserMessage,
   parseTpsAnalysis
 };
-//# sourceMappingURL=chunk-W4MFXWTT.js.map
+//# sourceMappingURL=chunk-RIJGRVVH.js.map

package/dist/chunk-W4FYPS5Z.js

@@ -0,0 +1,19 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __esm,
+  init_esm_shims
+};
+//# sourceMappingURL=chunk-W4FYPS5Z.js.map