@klitchevo/code-council 0.0.15 → 0.0.16

package/dist/chunk-W4MFXWTT.js

@@ -0,0 +1,310 @@
+// src/prompts/tps-audit.ts
+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
+
+### 1. FLOW (Nagare)
+Analyze how data and control flow through the system:
+- Identify entry points and exit points
+- Map the critical paths
+- Look for smooth, uninterrupted flow
+- Identify where flow is blocked or redirected
+- Check for single-piece flow vs batch processing
+
+### 2. WASTE (Muda) - The 7 Wastes in Software
+Identify instances of each waste type:
+
+**Defects**: Bugs, error-prone code, missing validation
+**Overproduction**: Features nobody uses, over-engineered solutions
+**Waiting**: Blocking I/O, synchronous when async would work, slow tests
+**Non-utilized Talent**: Manual tasks that could be automated, repetitive code
+**Transportation**: Unnecessary data transformation, excessive API calls
+**Inventory**: Dead code, unused imports/exports, stale dependencies
+**Motion**: Complex navigation, scattered related code, poor organization
+**Extra-processing**: Premature optimization, unnecessary abstraction layers
+
+### 3. BOTTLENECKS
+Identify constraints that limit throughput:
+- Synchronous operations that block
+- Single points of failure
+- Resource contention
+- N+1 queries or API calls
+- Sequential operations that could be parallel
+
+### 4. PULL vs PUSH
+Evaluate if work is demand-driven:
+- Lazy evaluation vs eager computation
+- On-demand loading vs preloading everything
+- Event-driven vs polling
+- Streaming vs buffering all data
+
+### 5. JIDOKA (Built-in Quality)
+Assess quality mechanisms:
+- Error handling and recovery
+- Validation at boundaries
+- Fail-fast patterns
+- Type safety usage
+- Test coverage signals
+
+### 6. STANDARDIZATION
+Look for consistency:
+- Code style consistency
+- Pattern usage consistency
+- Error handling patterns
+- Naming conventions
+- File organization
+
+## Scoring Guidelines
+
+**Overall Score (0-100)**:
+- 90-100: Exceptional flow, minimal waste, excellent quality
+- 70-89: Good practices, some waste, room for improvement
+- 50-69: Average, significant waste or flow issues
+- 30-49: Poor flow, excessive waste, quality concerns
+- 0-29: Critical issues, major redesign needed
+
+**Flow Score**: How smoothly does data/control move through the system?
+**Waste Score**: Higher = less waste (100 = no waste identified)
+**Quality Score**: Built-in quality mechanisms, error handling, type safety
+
+## Output Requirements
+
+You MUST respond with valid JSON matching the TpsAnalysis interface. Do not include any text before or after the JSON.
+
+Focus on:
+1. Actionable findings with specific file/line references
+2. Prioritized recommendations (quick wins first)
+3. Concrete suggestions, not vague advice
+4. Balanced assessment - acknowledge strengths too
+5. Effort estimates for recommendations`;
+function buildUserMessage(aggregatedContent, options) {
+  const parts = [];
+  if (options?.repoName) {
+    parts.push(`## Repository: ${options.repoName}`);
+  }
+  if (options?.focusAreas && options.focusAreas.length > 0) {
+    parts.push(
+      `## Focus Areas
+Pay special attention to: ${options.focusAreas.join(", ")}`
+    );
+  }
+  if (options?.additionalContext) {
+    parts.push(`## Additional Context
+${options.additionalContext}`);
+  }
+  parts.push(`## Codebase to Audit
+
+Analyze this codebase using Toyota Production System principles. Walk the production line from entry points through to outputs. Identify waste, bottlenecks, and improvement opportunities.
+
+${aggregatedContent}
+
+## Response Format
+
+Respond with ONLY valid JSON matching the TpsAnalysis interface. Include:
+- Scores for overall, flow, waste, and quality (0-100)
+- Flow analysis with entry points and pathways
+- Specific bottlenecks with locations and suggestions
+- Waste items categorized by the 7 types
+- Jidoka (built-in quality) assessment
+- Prioritized recommendations
+- Summary with strengths, concerns, and quick wins
+
+Your JSON response:`);
+  return parts.join("\n\n");
+}
+var BATCH_SYSTEM_PROMPT = `${SYSTEM_PROMPT}
+
+IMPORTANT: You are analyzing a BATCH of files from a larger codebase. This is batch {{BATCH_INDEX}} of {{TOTAL_BATCHES}}.
+- Focus on what you can observe in this batch
+- Note any cross-cutting concerns you see
+- Your analysis will be combined with other batches for a final report
+- Score this batch independently based on what you observe`;
+function buildBatchUserMessage(aggregatedContent, batchIndex, totalBatches, options) {
+  const baseMessage = buildUserMessage(aggregatedContent, options);
+  return `[BATCH ${batchIndex + 1} of ${totalBatches}]
+
+${baseMessage}`;
+}
+var SYNTHESIS_SYSTEM_PROMPT = `You are a TPS (Toyota Production System) consultant synthesizing multiple batch analyses of a codebase into a unified report.
+
+You will receive multiple TPS analysis JSON objects, each analyzing a different portion of the codebase. Your job is to:
+
+1. **Aggregate Scores**: Calculate weighted averages based on batch sizes
+2. **Merge Findings**: Combine bottlenecks, waste items, and recommendations, removing duplicates
+3. **Identify Patterns**: Note patterns that appear across multiple batches
+4. **Prioritize**: Re-prioritize recommendations based on the full picture
+5. **Synthesize Summary**: Create a cohesive summary of the entire codebase
+
+Output a single unified TpsAnalysis JSON that represents the whole codebase.
+
+Guidelines:
+- If multiple batches mention the same issue, increase its priority
+- Cross-batch patterns are often more important than single-batch issues
+- Flow analysis should try to connect entry points across batches
+- Be concise - don't repeat the same finding multiple times
+- Final scores should reflect the overall health, not just average`;
+function buildSynthesisUserMessage(batchResults, repoName) {
+  const parts = [];
+  if (repoName) {
+    parts.push(`## Repository: ${repoName}`);
+  }
+  parts.push(`## Batch Analyses to Synthesize
+
+You have ${batchResults.length} batch analyses to combine into a final report.`);
+  for (const batch of batchResults) {
+    parts.push(
+      `### Batch ${batch.batchIndex + 1} (~${batch.tokenCount} tokens)`
+    );
+    if (batch.analysis) {
+      parts.push("```json");
+      parts.push(JSON.stringify(batch.analysis, null, 2));
+      parts.push("```");
+    } else {
+      parts.push("*Analysis failed to parse. Raw response:*");
+      parts.push(
+        batch.rawResponse.substring(0, 1e3) + (batch.rawResponse.length > 1e3 ? "..." : "")
+      );
+    }
+  }
+  parts.push(`## Response Format
+
+Synthesize all batches into a single unified TpsAnalysis JSON.
+- Combine and deduplicate findings
+- Recalculate overall scores based on all batches
+- Prioritize issues that appear in multiple batches
+- Create a cohesive summary
+
+Your unified JSON response:`);
+  return parts.join("\n\n");
+}
+function parseTpsAnalysis(response) {
+  try {
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```json")) {
+      jsonStr = jsonStr.slice(7);
+    } else if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.slice(3);
+    }
+    if (jsonStr.endsWith("```")) {
+      jsonStr = jsonStr.slice(0, -3);
+    }
+    jsonStr = jsonStr.trim();
+    const raw = JSON.parse(jsonStr);
+    const scores = normalizeScores(raw);
+    if (!scores) {
+      return null;
+    }
+    const analysis = {
+      scores,
+      flowAnalysis: normalizeFlowAnalysis(raw),
+      bottlenecks: normalizeBottlenecks(raw),
+      waste: normalizeWaste(raw),
+      jidoka: normalizeJidoka(raw),
+      recommendations: normalizeRecommendations(raw),
+      summary: normalizeSummary(raw)
+    };
+    return analysis;
+  } catch {
+    return null;
+  }
+}
+function normalizeScores(raw) {
+  if (raw.scores && typeof raw.scores === "object") {
+    const s = raw.scores;
+    return {
+      overall: toNumber(s.overall) ?? toNumber(raw.overallScore) ?? 0,
+      flow: toNumber(s.flow) ?? 0,
+      waste: toNumber(s.waste) ?? 0,
+      quality: toNumber(s.quality) ?? 0
+    };
+  }
+  if (typeof raw.overallScore === "number" || typeof raw.overall === "number") {
+    return {
+      overall: toNumber(raw.overallScore) ?? toNumber(raw.overall) ?? 0,
+      flow: toNumber(raw.flowScore) ?? toNumber(raw.flow) ?? 0,
+      waste: toNumber(raw.wasteScore) ?? toNumber(raw.waste) ?? 0,
+      quality: toNumber(raw.qualityScore) ?? toNumber(raw.quality) ?? 0
+    };
+  }
+  return null;
+}
+function toNumber(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "string") {
+    const n = parseFloat(val);
+    return isNaN(n) ? null : n;
+  }
+  return null;
+}
+function normalizeFlowAnalysis(raw) {
+  const flow = raw.flowAnalysis;
+  if (!flow) {
+    return { entryPoints: [], diagram: "", pathways: [], observations: [] };
+  }
+  return {
+    entryPoints: normalizeStringArray(flow.entryPoints),
+    diagram: typeof flow.diagram === "string" ? flow.diagram : "",
+    pathways: normalizeStringArray(flow.pathways),
+    observations: normalizeStringArray(flow.observations)
+  };
+}
+function normalizeWaste(raw) {
+  const waste = raw.waste;
+  if (!waste || typeof waste !== "object") {
+    return {};
+  }
+  return waste;
+}
+function normalizeJidoka(raw) {
+  const jidoka = raw.jidoka;
+  if (!jidoka) {
+    return { score: 0, strengths: [], weaknesses: [] };
+  }
+  return {
+    score: toNumber(jidoka.score) ?? 0,
+    strengths: normalizeStringArray(jidoka.strengths),
+    weaknesses: normalizeStringArray(jidoka.weaknesses)
+  };
+}
+function normalizeBottlenecks(raw) {
+  const bottlenecks = raw.bottlenecks;
+  if (Array.isArray(bottlenecks)) {
+    return bottlenecks;
+  }
+  return [];
+}
+function normalizeRecommendations(raw) {
+  const recs = raw.recommendations;
+  if (Array.isArray(recs)) {
+    return recs;
+  }
+  return [];
+}
+function normalizeSummary(raw) {
+  const summary = raw.summary;
+  if (!summary) {
+    return { strengths: [], concerns: [], quickWins: [] };
+  }
+  return {
+    strengths: normalizeStringArray(summary.strengths),
+    concerns: normalizeStringArray(summary.concerns),
+    quickWins: normalizeStringArray(summary.quickWins)
+  };
+}
+function normalizeStringArray(val) {
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return [];
+}
+
+export {
+  SYSTEM_PROMPT,
+  buildUserMessage,
+  BATCH_SYSTEM_PROMPT,
+  buildBatchUserMessage,
+  SYNTHESIS_SYSTEM_PROMPT,
+  buildSynthesisUserMessage,
+  parseTpsAnalysis
+};
+//# sourceMappingURL=chunk-W4MFXWTT.js.map

package/dist/index.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 import {
+  BATCH_SYSTEM_PROMPT,
+  SYNTHESIS_SYSTEM_PROMPT,
   SYSTEM_PROMPT,
+  buildBatchUserMessage,
+  buildSynthesisUserMessage,
   buildUserMessage
-} from "./chunk-Y77R7523.js";
+} from "./chunk-W4MFXWTT.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -540,6 +544,51 @@ var ReviewClient = class {
       (model) => this.chat(model, SYSTEM_PROMPT, userMessage)
     );
   }
+  /**
+   * Perform TPS audit on a single batch of content
+   * @internal Used by batch processing
+   */
+  async tpsAuditBatch(aggregatedContent, model, batchIndex, totalBatches, options) {
+    const systemPrompt = BATCH_SYSTEM_PROMPT.replace(
+      "{{BATCH_INDEX}}",
+      String(batchIndex + 1)
+    ).replace("{{TOTAL_BATCHES}}", String(totalBatches));
+    const userMessage = buildBatchUserMessage(
+      aggregatedContent,
+      batchIndex,
+      totalBatches,
+      {
+        focusAreas: options?.focusAreas,
+        repoName: options?.repoName
+      }
+    );
+    logger.debug("Processing TPS batch", {
+      batchIndex,
+      totalBatches,
+      model,
+      contentLength: aggregatedContent.length
+    });
+    return this.chat(model, systemPrompt, userMessage);
+  }
+  /**
+   * Synthesize multiple batch analyses into a unified report
+   * @internal Used by batch processing
+   */
+  async tpsAuditSynthesize(batchResults, model, repoName) {
+    const userMessage = buildSynthesisUserMessage(
+      batchResults,
+      repoName
+    );
+    logger.debug("Synthesizing TPS batch results", {
+      batchCount: batchResults.length,
+      model
+    });
+    return this.chat(
+      model,
+      SYNTHESIS_SYSTEM_PROMPT,
+      userMessage
+    );
+  }
 };
 
 // src/session/in-memory-store.ts
@@ -1446,12 +1495,14 @@ var SECRET_CONTENT_PATTERNS = [
   // Square tokens
 ];
 var DEFAULT_FILE_EXTENSIONS = [
+  // TypeScript/JavaScript
   ".ts",
   ".tsx",
   ".js",
   ".jsx",
   ".mjs",
   ".cjs",
+  // Other languages
   ".py",
   ".go",
   ".rs",
@@ -1466,9 +1517,31 @@ var DEFAULT_FILE_EXTENSIONS = [
   ".h",
   ".hpp",
   ".swift",
+  // Frontend frameworks
   ".vue",
   ".svelte",
-  ".astro"
+  ".astro",
+  // Config & docs (important for understanding project)
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md"
+];
+var PRIORITY_DIRS = [
+  ".claude",
+  // Claude Code project configuration
+  ".beads"
+  // Issue tracking
+];
+var PRIORITY_ROOT_FILES = [
+  "CLAUDE.md",
+  "README.md",
+  "package.json",
+  "tsconfig.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod"
 ];
 var EXCLUDED_DIRS = [
   "node_modules",
@@ -1638,6 +1711,9 @@ async function scanRepository(startPath, options = {}) {
         continue;
       }
       if (stats2.isDirectory()) {
+        if (depth === 0 && PRIORITY_DIRS.includes(entry)) {
+          continue;
+        }
         scanDir(fullPath, depth + 1);
       } else if (stats2.isFile()) {
         totalFilesFound++;
@@ -1697,6 +1773,56 @@ async function scanRepository(startPath, options = {}) {
       }
     }
   }
+  function scanSingleFile(fullPath, bypassTypeFilter = false) {
+    const relativePath = relative2(repoRoot, fullPath);
+    let stats2;
+    try {
+      stats2 = statSync(fullPath);
+    } catch {
+      return false;
+    }
+    if (!stats2.isFile()) return false;
+    totalFilesFound++;
+    const ext = extname(fullPath).toLowerCase();
+    if (!bypassTypeFilter && !opts.fileTypes.includes(ext)) {
+      return false;
+    }
+    if (stats2.size > opts.maxFileSize) {
+      skipped.push({
+        path: relativePath,
+        reason: `File too large (${stats2.size} bytes)`
+      });
+      return false;
+    }
+    let content;
+    try {
+      const buffer = readFileSync2(fullPath);
+      if (isBinaryContent(buffer)) {
+        return false;
+      }
+      content = buffer.toString("utf-8");
+    } catch {
+      return false;
+    }
+    files.push({ path: relativePath, content });
+    totalSize += stats2.size;
+    return true;
+  }
+  for (const filename of PRIORITY_ROOT_FILES) {
+    const fullPath = join3(repoRoot, filename);
+    scanSingleFile(fullPath, true);
+  }
+  for (const priorityDir of PRIORITY_DIRS) {
+    const dirPath = join3(repoRoot, priorityDir);
+    try {
+      const dirStats = statSync(dirPath);
+      if (dirStats.isDirectory()) {
+        logger.debug("Scanning priority directory", { dir: priorityDir });
+        scanDir(dirPath, 0);
+      }
+    } catch {
+    }
+  }
   scanDir(repoRoot);
   const stats = {
     totalFilesFound,
@@ -1726,6 +1852,84 @@ ${f.content}
 === END FILE: ${f.path} ===`
   ).join("\n\n");
 }
+var BATCH_TOKEN_BUDGET = 6e4;
+function createFileBatches(files, tokenBudget = BATCH_TOKEN_BUDGET) {
+  if (files.length === 0) {
+    return [];
+  }
+  const filesByDir = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dir = file.path.includes("/") ? file.path.substring(0, file.path.lastIndexOf("/")) : ".";
+    const dirFiles = filesByDir.get(dir) || [];
+    dirFiles.push(file);
+    filesByDir.set(dir, dirFiles);
+  }
+  const dirsWithTokens = [...filesByDir.entries()].map(([dir, dirFiles]) => ({
+    dir,
+    files: dirFiles,
+    tokens: dirFiles.reduce((sum, f) => sum + estimateTokens(f.content), 0)
+  }));
+  dirsWithTokens.sort((a, b) => a.tokens - b.tokens);
+  const batches = [];
+  let currentBatch = [];
+  let currentTokens = 0;
+  for (const { files: dirFiles, tokens: dirTokens } of dirsWithTokens) {
+    if (currentTokens + dirTokens <= tokenBudget) {
+      currentBatch.push(...dirFiles);
+      currentTokens += dirTokens;
+    } else if (dirTokens > tokenBudget) {
+      if (currentBatch.length > 0) {
+        batches.push({
+          files: currentBatch,
+          tokenEstimate: currentTokens,
+          batchIndex: batches.length
+        });
+        currentBatch = [];
+        currentTokens = 0;
+      }
+      for (const file of dirFiles) {
+        const fileTokens = estimateTokens(file.content);
+        if (currentTokens + fileTokens > tokenBudget && currentBatch.length > 0) {
+          batches.push({
+            files: currentBatch,
+            tokenEstimate: currentTokens,
+            batchIndex: batches.length
+          });
+          currentBatch = [];
+          currentTokens = 0;
+        }
+        currentBatch.push(file);
+        currentTokens += fileTokens;
+      }
+    } else {
+      if (currentBatch.length > 0) {
+        batches.push({
+          files: currentBatch,
+          tokenEstimate: currentTokens,
+          batchIndex: batches.length
+        });
+      }
+      currentBatch = [...dirFiles];
+      currentTokens = dirTokens;
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push({
+      files: currentBatch,
+      tokenEstimate: currentTokens,
+      batchIndex: batches.length
+    });
+  }
+  logger.debug("Created file batches", {
+    totalFiles: files.length,
+    batchCount: batches.length,
+    batchSizes: batches.map((b) => ({
+      files: b.files.length,
+      tokens: b.tokenEstimate
+    }))
+  });
+  return batches;
+}
 
 // src/tools/tps-audit.ts
 var tpsAuditSchemaObj = z7.object({
@@ -1741,6 +1945,7 @@ var tpsAuditSchemaObj = z7.object({
   output_format: z7.enum(["html", "markdown", "json"]).optional().describe("Output format (default: html)")
 });
 var tpsAuditSchema = tpsAuditSchemaObj.shape;
+var BATCH_TOKEN_THRESHOLD = 6e4;
 async function handleTpsAudit(client2, models, input) {
   const startPath = input.path || process.cwd();
   const outputFormat = input.output_format || "html";
@@ -1780,27 +1985,40 @@ async function handleTpsAudit(client2, models, input) {
       warnings: scanResult.warnings
     });
   }
-  const aggregatedContent = aggregateFiles(scanResult.files);
   logger.info("Repository scanned", {
     filesIncluded: scanResult.files.length,
     totalSize: scanResult.stats.totalSize,
     tokenEstimate: scanResult.stats.tokenEstimate
   });
-  if (scanResult.stats.tokenEstimate > 1e5) {
-    logger.warn("Large token count", {
-      estimate: scanResult.stats.tokenEstimate
-    });
-  }
-  const results = await client2.tpsAudit(aggregatedContent, models, {
-    focusAreas: input.focus_areas,
-    repoName: scanResult.repoRoot.split("/").pop()
-  });
+  const repoName = scanResult.repoRoot.split("/").pop();
+  const needsBatching = scanResult.stats.tokenEstimate > BATCH_TOKEN_THRESHOLD;
+  let results;
   let analysis = null;
-  for (const result of results) {
-    if (!result.error && result.review) {
-      const { parseTpsAnalysis } = await import("./tps-audit-GNK4VIKA.js");
-      analysis = parseTpsAnalysis(result.review);
-      if (analysis) break;
+  if (needsBatching) {
+    logger.info("Using batch processing", {
+      tokenEstimate: scanResult.stats.tokenEstimate,
+      threshold: BATCH_TOKEN_THRESHOLD
+    });
+    const batchResults = await handleBatchedTpsAudit(
+      client2,
+      models,
+      scanResult,
+      input.focus_areas
+    );
+    results = batchResults.results;
+    analysis = batchResults.analysis;
+  } else {
+    const aggregatedContent = aggregateFiles(scanResult.files);
+    results = await client2.tpsAudit(aggregatedContent, models, {
+      focusAreas: input.focus_areas,
+      repoName
+    });
+    for (const result of results) {
+      if (!result.error && result.review) {
+        const { parseTpsAnalysis } = await import("./tps-audit-TXNM5HYS.js");
+        analysis = parseTpsAnalysis(result.review);
+        if (analysis) break;
+      }
     }
   }
   return {
@@ -1811,6 +2029,103 @@ async function handleTpsAudit(client2, models, input) {
     outputFormat
   };
 }
+async function handleBatchedTpsAudit(client2, models, scanResult, focusAreas) {
+  const { parseTpsAnalysis } = await import("./tps-audit-TXNM5HYS.js");
+  const repoName = scanResult.repoRoot.split("/").pop() ?? "unknown";
+  const batches = createFileBatches(scanResult.files);
+  const batchContents = batches.map((batch) => ({
+    content: aggregateFiles(batch.files),
+    tokenEstimate: batch.tokenEstimate,
+    batchIndex: batch.batchIndex
+  }));
+  logger.info("Processing batches with all models", {
+    batchCount: batches.length,
+    modelCount: models.length,
+    totalApiCalls: batches.length * models.length + models.length
+    // batches + synthesis per model
+  });
+  const modelResults = await Promise.all(
+    models.map(async (model) => {
+      const batchAnalyses = await Promise.all(
+        batchContents.map(async (batch) => {
+          try {
+            const response = await client2.tpsAuditBatch(
+              batch.content,
+              model,
+              batch.batchIndex,
+              batches.length,
+              { focusAreas, repoName }
+            );
+            return {
+              batchIndex: batch.batchIndex,
+              tokenCount: batch.tokenEstimate,
+              rawResponse: response,
+              analysis: parseTpsAnalysis(response)
+            };
+          } catch (error) {
+            logger.error("Batch analysis failed", error, {
+              model,
+              batchIndex: batch.batchIndex
+            });
+            return {
+              batchIndex: batch.batchIndex,
+              tokenCount: batch.tokenEstimate,
+              rawResponse: error instanceof Error ? error.message : "Unknown error",
+              analysis: null
+            };
+          }
+        })
+      );
+      const successfulBatches = batchAnalyses.filter(
+        (b) => b.analysis !== null
+      );
+      let finalAnalysis = null;
+      let finalResponse = "";
+      if (batchAnalyses.length > 1 && successfulBatches.length > 0) {
+        try {
+          finalResponse = await client2.tpsAuditSynthesize(
+            batchAnalyses,
+            model,
+            repoName
+          );
+          finalAnalysis = parseTpsAnalysis(finalResponse);
+        } catch (error) {
+          logger.error("Synthesis failed for model", error, { model });
+          const first = successfulBatches[0];
+          finalAnalysis = first?.analysis ?? null;
+          finalResponse = first?.rawResponse ?? "";
+        }
+      } else if (successfulBatches.length === 1) {
+        const first = successfulBatches[0];
+        if (first) {
+          finalAnalysis = first.analysis;
+          finalResponse = first.rawResponse;
+        }
+      }
+      return {
+        model,
+        review: finalResponse,
+        analysis: finalAnalysis,
+        error: finalAnalysis === null ? "Failed to produce analysis" : void 0
+      };
+    })
+  );
+  const results = modelResults.map((r) => ({
+    model: r.model,
+    review: r.review,
+    error: r.error
+  }));
+  const firstSuccess = modelResults.find((r) => r.analysis !== null);
+  logger.info("Batched TPS audit complete", {
+    modelsUsed: models.length,
+    batchesPerModel: batches.length,
+    successfulModels: modelResults.filter((r) => r.analysis !== null).length
+  });
+  return {
+    results,
+    analysis: firstSuccess?.analysis ?? null
+  };
+}
 function writeReportToFolder(repoRoot, content, format) {
   try {
     const outputDir = join4(repoRoot, ".code-council");

package/dist/tps-audit-TXNM5HYS.js

@@ -0,0 +1,19 @@
+import {
+  BATCH_SYSTEM_PROMPT,
+  SYNTHESIS_SYSTEM_PROMPT,
+  SYSTEM_PROMPT,
+  buildBatchUserMessage,
+  buildSynthesisUserMessage,
+  buildUserMessage,
+  parseTpsAnalysis
+} from "./chunk-W4MFXWTT.js";
+export {
+  BATCH_SYSTEM_PROMPT,
+  SYNTHESIS_SYSTEM_PROMPT,
+  SYSTEM_PROMPT,
+  buildBatchUserMessage,
+  buildSynthesisUserMessage,
+  buildUserMessage,
+  parseTpsAnalysis
+};
+//# sourceMappingURL=tps-audit-TXNM5HYS.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@klitchevo/code-council",
-	"version": "0.0.15",
+	"version": "0.0.16",
 	"description": "Multi-model AI code review server using OpenRouter - get diverse perspectives from multiple LLMs in parallel",
 	"main": "dist/index.js",
 	"type": "module",

package/dist/chunk-Y77R7523.js

@@ -1,142 +0,0 @@
-// src/prompts/tps-audit.ts
-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
-
-### 1. FLOW (Nagare)
-Analyze how data and control flow through the system:
-- Identify entry points and exit points
-- Map the critical paths
-- Look for smooth, uninterrupted flow
-- Identify where flow is blocked or redirected
-- Check for single-piece flow vs batch processing
-
-### 2. WASTE (Muda) - The 7 Wastes in Software
-Identify instances of each waste type:
-
-**Defects**: Bugs, error-prone code, missing validation
-**Overproduction**: Features nobody uses, over-engineered solutions
-**Waiting**: Blocking I/O, synchronous when async would work, slow tests
-**Non-utilized Talent**: Manual tasks that could be automated, repetitive code
-**Transportation**: Unnecessary data transformation, excessive API calls
-**Inventory**: Dead code, unused imports/exports, stale dependencies
-**Motion**: Complex navigation, scattered related code, poor organization
-**Extra-processing**: Premature optimization, unnecessary abstraction layers
-
-### 3. BOTTLENECKS
-Identify constraints that limit throughput:
-- Synchronous operations that block
-- Single points of failure
-- Resource contention
-- N+1 queries or API calls
-- Sequential operations that could be parallel
-
-### 4. PULL vs PUSH
-Evaluate if work is demand-driven:
-- Lazy evaluation vs eager computation
-- On-demand loading vs preloading everything
-- Event-driven vs polling
-- Streaming vs buffering all data
-
-### 5. JIDOKA (Built-in Quality)
-Assess quality mechanisms:
-- Error handling and recovery
-- Validation at boundaries
-- Fail-fast patterns
-- Type safety usage
-- Test coverage signals
-
-### 6. STANDARDIZATION
-Look for consistency:
-- Code style consistency
-- Pattern usage consistency
-- Error handling patterns
-- Naming conventions
-- File organization
-
-## Scoring Guidelines
-
-**Overall Score (0-100)**:
-- 90-100: Exceptional flow, minimal waste, excellent quality
-- 70-89: Good practices, some waste, room for improvement
-- 50-69: Average, significant waste or flow issues
-- 30-49: Poor flow, excessive waste, quality concerns
-- 0-29: Critical issues, major redesign needed
-
-**Flow Score**: How smoothly does data/control move through the system?
-**Waste Score**: Higher = less waste (100 = no waste identified)
-**Quality Score**: Built-in quality mechanisms, error handling, type safety
-
-## Output Requirements
-
-You MUST respond with valid JSON matching the TpsAnalysis interface. Do not include any text before or after the JSON.
-
-Focus on:
-1. Actionable findings with specific file/line references
-2. Prioritized recommendations (quick wins first)
-3. Concrete suggestions, not vague advice
-4. Balanced assessment - acknowledge strengths too
-5. Effort estimates for recommendations`;
-function buildUserMessage(aggregatedContent, options) {
-  const parts = [];
-  if (options?.repoName) {
-    parts.push(`## Repository: ${options.repoName}`);
-  }
-  if (options?.focusAreas && options.focusAreas.length > 0) {
-    parts.push(
-      `## Focus Areas
-Pay special attention to: ${options.focusAreas.join(", ")}`
-    );
-  }
-  if (options?.additionalContext) {
-    parts.push(`## Additional Context
-${options.additionalContext}`);
-  }
-  parts.push(`## Codebase to Audit
-
-Analyze this codebase using Toyota Production System principles. Walk the production line from entry points through to outputs. Identify waste, bottlenecks, and improvement opportunities.
-
-${aggregatedContent}
-
-## Response Format
-
-Respond with ONLY valid JSON matching the TpsAnalysis interface. Include:
-- Scores for overall, flow, waste, and quality (0-100)
-- Flow analysis with entry points and pathways
-- Specific bottlenecks with locations and suggestions
-- Waste items categorized by the 7 types
-- Jidoka (built-in quality) assessment
-- Prioritized recommendations
-- Summary with strengths, concerns, and quick wins
-
-Your JSON response:`);
-  return parts.join("\n\n");
-}
-function parseTpsAnalysis(response) {
-  try {
-    let jsonStr = response.trim();
-    if (jsonStr.startsWith("```json")) {
-      jsonStr = jsonStr.slice(7);
-    } else if (jsonStr.startsWith("```")) {
-      jsonStr = jsonStr.slice(3);
-    }
-    if (jsonStr.endsWith("```")) {
-      jsonStr = jsonStr.slice(0, -3);
-    }
-    jsonStr = jsonStr.trim();
-    const parsed = JSON.parse(jsonStr);
-    if (typeof parsed.scores?.overall !== "number" || !Array.isArray(parsed.bottlenecks) || !Array.isArray(parsed.recommendations)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-export {
-  SYSTEM_PROMPT,
-  buildUserMessage,
-  parseTpsAnalysis
-};
-//# sourceMappingURL=chunk-Y77R7523.js.map

package/dist/tps-audit-GNK4VIKA.js

@@ -1,11 +0,0 @@
-import {
-  SYSTEM_PROMPT,
-  buildUserMessage,
-  parseTpsAnalysis
-} from "./chunk-Y77R7523.js";
-export {
-  SYSTEM_PROMPT,
-  buildUserMessage,
-  parseTpsAnalysis
-};
-//# sourceMappingURL=tps-audit-GNK4VIKA.js.map