@klitchevo/code-council 0.0.8 → 0.0.13

package/README.md

@@ -18,6 +18,8 @@ An MCP (Model Context Protocol) server that provides AI-powered code review usin
 - 🔒 **Backend Review** - Security, architecture, and performance analysis
 - 📋 **Plan Review** - Review implementation plans before writing code
 - 📝 **Git Changes Review** - Review staged, unstaged, branch diffs, or specific commits
+- 💬 **Council Discussions** - Multi-turn conversations with the AI council for deeper exploration
+- 🏭 **TPS Audit** - Toyota Production System analysis for flow, waste, bottlenecks, and quality
 - ⚡ **Parallel Execution** - All models run concurrently for fast results
 
 ## Quick Start
@@ -257,6 +259,72 @@ Use review_git_changes to review my staged changes
 Use review_git_changes with review_type=commit and commit_hash=abc123 to review that commit
 ```
 
+### `discuss_with_council`
+
+Have multi-turn conversations with the AI council. Start a discussion, get feedback from all models, then ask follow-up questions while maintaining context.
+
+**Parameters:**
+- `message` (required): Your message or question for the council
+- `session_id` (optional): Session ID to continue an existing discussion (omit to start new)
+- `discussion_type` (optional): `code_review`, `plan_review`, or `general` (default: `general`)
+- `context` (optional): Additional context (code snippets, plan details, etc.)
+
+**Example usage in Claude:**
+```
+Use discuss_with_council to ask: What's the best way to implement error handling in a Node.js API?
+```
+
+**Continuing a discussion:**
+```
+Use discuss_with_council with session_id=<id-from-previous-response> to ask: Can you elaborate on the circuit breaker pattern you mentioned?
+```
+
+**Key features:**
+- Each model maintains its own conversation history for authentic diverse perspectives
+- Sessions persist for 30 minutes of inactivity
+- Rate limited to 10 requests per minute per session
+- Context windowing keeps conversations efficient
+
+### `tps_audit`
+
+Analyze any codebase using Toyota Production System (TPS) principles. Generates beautiful HTML reports with scores for flow, waste, bottlenecks, and quality.
+
+**Parameters:**
+- `path` (optional): Path to repository root (auto-detects git root if not provided)
+- `focus_areas` (optional): Specific areas to focus on (e.g., `["flow", "security", "performance"]`)
+- `max_files` (optional): Maximum files to analyze (default: 50, max: 100)
+- `file_types` (optional): File extensions to include (default: common source files)
+- `include_sensitive` (optional): Include potentially sensitive files (default: false)
+- `output_format` (optional): `html`, `markdown`, or `json` (default: `html`)
+
+**Example usage in Claude:**
+```
+Use tps_audit to analyze this repository
+```
+
+```
+Use tps_audit with output_format=markdown and focus_areas=["security", "performance"]
+```
+
+**What it analyzes:**
+- **Flow**: How data and control flow through the system, entry points, pathways
+- **Muda (Waste)**: The 7 wastes - defects, overproduction, waiting, transportation, inventory, motion, extra-processing
+- **Bottlenecks**: Where flow is constrained, severity and impact
+- **Jidoka**: Built-in quality, fail-fast patterns, error handling
+- **Recommendations**: Prioritized improvements with effort/impact ratings
+
+**Security features:**
+- Automatically skips sensitive files (`.env`, credentials, keys, tokens)
+- Scans file contents for embedded secrets (AWS keys, GitHub PATs, etc.)
+- Validates paths to prevent directory traversal attacks
+- Enforces size limits to prevent resource exhaustion
+
+**Output:**
+Reports are saved to `.code-council/` directory:
+- `tps-audit.html` - Interactive styled report with glass-morphism dark theme
+- `tps-audit.md` - Markdown version
+- `tps-audit.json` - Raw JSON data
+
 ### `list_review_config`
 
 Show which AI models are currently configured for each review type.
@@ -272,6 +340,8 @@ You can customize which AI models are used for reviews by setting environment va
 - `FRONTEND_REVIEW_MODELS` - Models for frontend reviews
 - `BACKEND_REVIEW_MODELS` - Models for backend reviews
 - `PLAN_REVIEW_MODELS` - Models for plan reviews
+- `DISCUSSION_MODELS` - Models for council discussions
+- `TPS_AUDIT_MODELS` - Models for TPS codebase audits
 - `TEMPERATURE` - Control response randomness (0.0-2.0, default: 0.3)
 - `MAX_TOKENS` - Maximum response tokens (default: 16384)
 
@@ -299,9 +369,10 @@ You can customize which AI models are used for reviews by setting environment va
 
 **Default Models:**
 If you don't specify models, the server uses these defaults:
-- `minimax/minimax-m2.1`
-- `z-ai/glm-4.7`
-- `x-ai/grok-code-fast-1`
+- `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:**
 Browse all available models at [OpenRouter Models](https://openrouter.ai/models). Popular choices include:

package/dist/chunk-Y77R7523.js

@@ -0,0 +1,142 @@
+// 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