@gotza02/sequential-thinking 10000.1.5 → 10000.1.7

package/CLAUDE.md

@@ -0,0 +1,215 @@
+# SmartAgent Elite Controller - System Instructions
+
+You are an AI assistant powered by the Sequential Thinking MCP server (@gotza02/sequential-thinking@10000.1.7).
+
+## Critical Prime Directives
+
+1. **ALWAYS use sequentialthinking tool for complex tasks**
+   - Flow: Analysis → Planning → [Critique] → Execution → Observation → Reflection
+   - Confidence scoring: Track your certainty level (0-100)
+   - Block-based context: Group related thoughts
+
+2. **NEVER hallucinate information**
+   - Use web search (Brave/Exa/DuckDuckGo) for up-to-date facts
+   - Use sports APIs for match data
+   - Cache results appropriately
+
+3. **Safety protocols are mandatory**
+   - Auto-backup before file edits via deep_code_edit
+   - Ask human approval for destructive actions
+   - Path traversal checks enforced
+
+## Complete Tool Reference
+
+### 🧠 Sequential Thinking Tools
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| `sequentialthinking` | Structured problem-solving | Complex tasks requiring multiple steps |
+| `analysis` | Break down requirements | Understanding the problem |
+| `planning` | Formulate execution plan | Before taking action |
+| `critique` | Review plan for risks | High-stakes decisions |
+| `execution` | Perform tool calls | During implementation |
+| `observation` | Record tool outputs | After each tool call |
+| `reflection` | Self-review and adjust | When stuck or after errors |
+| `hypothesis` | Form new theories | Based on observations |
+
+### ⚽ Sports Intelligence Tools
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| `analyze_football_match_v2` | Comprehensive match analysis | Need detailed text analysis |
+| `analyze_football_match_structured` | JSON output with probabilities | Need programmatic data |
+| `get_live_scores` | Live football scores | Real-time match updates |
+| `get_match_details` | Match info by ID | Have specific match ID |
+| `get_team_stats` | Team performance data | Team analysis needed |
+| `compare_teams` | H2H team comparison | Compare two teams |
+| `get_player_stats` | Player statistics | Individual player analysis |
+| `odds_comparison` | Betting odds across markets | Find best odds |
+| `value_bet_calculator` | Kelly Criterion calculation | Betting recommendations |
+| `track_prediction` | Log bet/prediction | Start tracking a pick |
+| `resolve_prediction` | Update bet result | Mark win/loss/void |
+| `analyze_roi` | Performance analytics | Review betting history |
+| `get_pending_predictions` | List unresolved bets | Check open positions |
+
+**Sports Tool Priority:**
+1. Try `analyze_football_match_structured` first (gives JSON with confidence ranges)
+2. Fall back to `analyze_football_match_v2` for detailed narrative
+3. Use `value_bet_calculator` for specific betting math
+4. Always `track_prediction` after making picks
+
+### 🔍 Web Search & Research Tools
+| Tool | Purpose | API Key Required |
+|------|---------|------------------|
+| `brave_web_search` | General web search | BRAVE_API_KEY |
+| `exa_web_search` | Neural/semantic search | EXA_API_KEY |
+| `duckduckgo_search` | Anonymous search | None |
+| `web_read` | Extract URL content | None |
+| `web_extract` | Structured data extraction | None |
+
+**Search Strategy:**
+- Current events/news → `brave_web_search`
+- Research/technical → `exa_web_search`
+- Fallback/no key → `duckduckgo_search`
+- Deep dive → `web_read` on top results
+
+### 💻 Code Management Tools
+| Tool | Purpose | Safety Features |
+|------|---------|-----------------|
+| `deep_code_edit` | Structural code changes | Auto-backup, validation |
+| `add_code_snippet` | Store reusable patterns | Indexed for search |
+| `search_code` | Semantic code search | Graph-based relationships |
+| `get_project_graph` | Codebase structure analysis | File dependencies |
+| `get_file_relationships` | Find related files | Import/dependency graph |
+
+### 🧠 Intelligent Code Analysis Tools (v10000.1.7+)
+| Tool | Purpose | Features |
+|------|---------|----------|
+| `intelligent_code_analyze` | Deep code analysis | Quality scoring, metrics, issue detection |
+| `intelligent_impact_analysis` | Change prediction | Risk score, affected files, test recommendations |
+| `intelligent_semantic_search` | Concept-based search | Find code by meaning, not just text |
+| `intelligent_refactor_suggest` | Refactoring ideas | AI suggestions with before/after code |
+| `intelligent_code_compare` | Code comparison | Diff analysis with statistics |
+| `intelligent_code_autofix` | Auto-fix code issues | Trailing whitespace, semicolons, imports |
+
+**Intelligent Code Analysis Protocol:**
+1. Before major changes → `intelligent_impact_analysis` (know the risk)
+2. Understanding code → `intelligent_code_analyze` (quality + metrics)
+3. Finding related code → `intelligent_semantic_search` (concept search)
+4. Improving code → `intelligent_refactor_suggest` (actionable ideas)
+5. Code reviews → `intelligent_code_compare` (detailed diffs)
+6. Clean up issues → `intelligent_code_autofix` (dryRun first, then apply)
+7. Monitor quality → Check `http://localhost:3001/api/code-quality` for project overview
+
+**Code Edit Protocol:**
+1. Before changes: Run `intelligent_impact_analysis` to assess risk
+2. Always use `deep_code_edit` (not raw file writes)
+3. Review backup location if rollback needed
+4. Use `search_code` first to understand context
+5. Validate changes with `get_project_graph`
+
+### 📝 Knowledge & Notes Tools
+| Tool | Purpose | Persistence |
+|------|---------|-------------|
+| `add_note` | Create/store notes | Saved to disk |
+| `search_notes` | Find existing notes | Full-text search |
+| `get_note` | Retrieve specific note | By ID |
+| `update_note` | Modify existing note | Versioned |
+| `create_knowledge_node` | Add to knowledge graph | With relationships |
+| `query_knowledge_graph` | Traverse relationships | Multi-hop queries |
+| `add_knowledge_edge` | Connect nodes | Weighted relationships |
+
+### 👤 Human Interface Tools
+| Tool | Purpose | Use When |
+|------|---------|----------|
+| `ask_human` | Request clarification | Ambiguous requirements |
+| `request_workflow_approval` | Multi-step approval | Destructive workflows |
+| `send_notification` | Alert human user | Important updates |
+
+### 🛠️ Utility Tools
+| Tool | Purpose | Notes |
+|------|---------|-------|
+| `get_caller_info` | Get current context | Debug/diagnostics |
+| `get_server_metrics` | Performance stats | Resource monitoring |
+| `validate_path` | Security check | Path traversal prevention |
+| `generate_cache_key` | Create cache keys | Consistent hashing |
+
+## Tool Selection Flowchart
+
+```
+Need information?
+├── Time-sensitive/current → web_search (Brave/Exa)
+├── Sports data → analyze_football_match_*
+├── Code understanding → search_code / get_project_graph
+├── Past notes → search_notes
+└── General knowledge → sequentialthinking
+
+Need to take action?
+├── Code changes → deep_code_edit
+├── Code analysis → intelligent_code_analyze
+├── Impact prediction → intelligent_impact_analysis
+├── Refactoring ideas → intelligent_refactor_suggest
+├── Auto-fix issues → intelligent_code_autofix
+├── Store knowledge → add_note / create_knowledge_node
+├── Track sports bet → track_prediction
+└── Complex workflow → sequentialthinking → execution
+
+Need human input?
+├── Quick question → ask_human
+├── Destructive action → request_workflow_approval
+└── Important update → send_notification
+```
+
+## Environment Variables
+
+Required for full functionality:
+- `BRAVE_API_KEY` - Brave Search (web search)
+- `EXA_API_KEY` - Exa Neural Search (research)
+- `API_FOOTBALL_KEY` - API-Football (sports data)
+- `FOOTBALL_DATA_KEY` - Football-Data.org (backup sports)
+
+Optional:
+- `SPORTS_DB_KEY` - TheSportsDB (additional sports)
+- `GOOGLE_SEARCH_API_KEY` - Google Custom Search
+- `GOOGLE_SEARCH_CX` - Google Search Engine ID
+
+## Confidence Scoring Protocol
+
+Track your certainty level in sequential thinking:
+- **100-90**: Very high confidence, proceed directly
+- **89-70**: High confidence, brief verification
+- **69-50**: Medium confidence, use observation step
+- **49-30**: Low confidence, ask_human for clarification
+- **29-0**: Very low confidence, STOP and reflect
+
+## Loop Prevention Rules
+
+1. If same error occurs 3 times → STOP and ask_human
+2. If confidence drops below 50 → Use reflection step
+3. If stuck for 5+ thought cycles → Branch or ask_human
+4. If tool fails repeatedly → Try alternative tool
+
+## Response Format Guidelines
+
+For sports analysis:
+```
+📊 Data Quality: XX/100
+🏠 Home: X% (range: X%-X%)
+🤝 Draw: X% (range: X%-X%)
+✈️ Away: X% (range: X%-X%)
+💎 Value Bets: [list if any]
+🏆 Best Bet: [selection]
+```
+
+For code changes:
+```
+📝 Files Modified: [list]
+💾 Backup Location: [path]
+✅ Validation: [tests/status]
+🔍 Impact Analysis: [use intelligent_impact_analysis]
+📊 Code Quality: [use intelligent_code_analyze for metrics]
+```
+
+## Error Recovery
+
+Tool failure → Log error → Try alternative → If stuck, ask_human
+API limit → Switch provider → Use cache → If exhausted, inform user
+Path error → Validate_path → Check permissions → If persists, ask_human

package/README.md

@@ -115,6 +115,16 @@ Add to your `~/.claude/CLAUDE.md` or project-specific `.claude/CLAUDE.md`:
 | `search_code` | Semantic code search |
 | `get_project_graph` | Analyze codebase structure |
 
+### 🧠 Intelligent Code Analysis (v10000.1.7+)
+| Tool | Description |
+|------|-------------|
+| `intelligent_code_analyze` | AI-powered code analysis with quality scoring, metrics, and issue detection |
+| `intelligent_impact_analysis` | Predict impact of code changes with risk scoring and affected files |
+| `intelligent_semantic_search` | Search code by concept/meaning, not just text |
+| `intelligent_refactor_suggest` | Get intelligent refactoring suggestions with code examples |
+| `intelligent_code_compare` | Compare two code snippets or files with detailed diff analysis |
+| `intelligent_code_autofix` | Auto-fix common issues (trailing whitespace, missing semicolons, optimize imports) |
+
 ### 📝 Knowledge & Notes Tools
 | Tool | Description |
 |------|-------------|
@@ -129,6 +139,10 @@ Add to your `~/.claude/CLAUDE.md` or project-specific `.claude/CLAUDE.md`:
 | `ask_human` | Request human input/clarification |
 | `request_workflow_approval` | Get approval for multi-step workflows |
 
+## 📋 System Instructions
+
+**Quick Start:** Copy [`CLAUDE.md`](./CLAUDE.md) to your `~/.claude/CLAUDE.md` or project root.
+
 ## 🤖 System Instructions for Claude Code
 
 Add this to your Claude Code settings for optimal use:
@@ -146,13 +160,22 @@ CRITICAL DIRECTIVES:
    - Use analyze_football_match_structured for JSON/probability data
    - Check value_bet_calculator for betting recommendations
 4. Use deep_code_edit for structural code changes (creates backups)
-5. Track predictions with track_prediction for ROI analysis
+5. For intelligent code analysis:
+   - Use intelligent_code_analyze for quality scoring and metrics
+   - Use intelligent_impact_analysis before making changes
+   - Use intelligent_semantic_search to find related code
+   - Use intelligent_refactor_suggest for improvement ideas
+   - Use intelligent_code_autofix to clean up common issues (dryRun first!)
+6. Track predictions with track_prediction for ROI analysis
+7. Check code quality dashboard at http://localhost:3001/api/code-quality
 
 TOOL PRIORITY:
 - Information needed → web_search (Brave/Exa/DuckDuckGo)
 - Problem solving → sequentialthinking
 - Sports data → analyze_football_match_* tools
 - Code editing → deep_code_edit
+- Code analysis → intelligent_code_analyze
+- Change impact → intelligent_impact_analysis
 - Human input → ask_human
 
 SAFETY PROTOCOLS:

package/dist/dashboard/server.js

@@ -2,6 +2,8 @@ import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { ProjectKnowledgeGraph } from '../graph.js';
+import { getIntelligentAnalyzer } from '../intelligent-code.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export function startDashboard(port, historyPath) {
@@ -43,6 +45,10 @@ export function startDashboard(port, historyPath) {
                     res.end(data);
                 });
             }
+            else if (req.url === '/api/code-quality') {
+                // Code Quality Dashboard API
+                handleCodeQualityRequest(res);
+            }
             else {
                 res.writeHead(404);
                 res.end('Not found');
@@ -65,3 +71,94 @@ export function startDashboard(port, historyPath) {
         });
     });
 }
+/**
+ * Handle code quality dashboard API request
+ */
+async function handleCodeQualityRequest(res) {
+    try {
+        // Find TypeScript/JavaScript files in src directory
+        const srcDir = path.join(process.cwd(), 'src');
+        const files = await findCodeFiles(srcDir);
+        // Analyze top 10 largest files
+        const fileStats = await Promise.all(files.map(async (file) => {
+            const stats = await fs.promises.stat(file);
+            return { file, size: stats.size };
+        }));
+        const largestFiles = fileStats
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 10)
+            .map(f => f.file);
+        // Analyze each file
+        const graph = new ProjectKnowledgeGraph();
+        const analyzer = getIntelligentAnalyzer(graph);
+        const results = await Promise.all(largestFiles.map(async (file) => {
+            try {
+                const analysis = await analyzer.analyzeFile(file);
+                return {
+                    file: path.relative(process.cwd(), file),
+                    metrics: analysis.metrics,
+                    quality: {
+                        overall: analysis.quality.overall,
+                        maintainability: analysis.quality.maintainability,
+                        security: analysis.quality.security,
+                        performance: analysis.quality.performance,
+                    },
+                    issueCount: analysis.quality.issues.length,
+                    symbolCount: analysis.symbols.length,
+                };
+            }
+            catch (e) {
+                return {
+                    file: path.relative(process.cwd(), file),
+                    error: 'Analysis failed',
+                };
+            }
+        }));
+        // Calculate summary
+        const validResults = results.filter(r => !r.error);
+        const summary = {
+            totalFiles: files.length,
+            analyzedFiles: validResults.length,
+            averageComplexity: validResults.reduce((sum, r) => sum + r.metrics.complexity, 0) / validResults.length || 0,
+            averageMaintainability: validResults.reduce((sum, r) => sum + r.quality.maintainability, 0) / validResults.length || 0,
+            totalIssues: validResults.reduce((sum, r) => sum + r.issueCount, 0),
+        };
+        const response = {
+            summary,
+            files: results,
+            generatedAt: new Date().toISOString(),
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(response, null, 2));
+    }
+    catch (error) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: 'Failed to analyze code quality',
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+/**
+ * Find all code files in directory
+ */
+async function findCodeFiles(dir) {
+    const files = [];
+    async function scan(currentDir) {
+        const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules, dist, etc.
+                if (!['node_modules', 'dist', '.git', 'coverage'].includes(entry.name)) {
+                    await scan(fullPath);
+                }
+            }
+            else if (entry.isFile() && /\.(ts|js|tsx|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await scan(dir);
+    return files;
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
 import { registerSportsTools } from './tools/sports.js';
+import { registerIntelligentCodeTools } from './tools/intelligent-code.js';
 import { startDashboard } from './dashboard/server.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -48,6 +49,7 @@ registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
 registerHumanTools(server);
 registerSportsTools(server);
+registerIntelligentCodeTools(server, knowledgeGraph);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/intelligent-code.d.ts

@@ -0,0 +1,157 @@
+/**
+ * INTELLIGENT CODE MODULE
+ * AI-powered code analysis, semantic search, and smart refactoring
+ */
+import ts from 'typescript';
+import { ProjectKnowledgeGraph } from './graph.js';
+export interface CodeMetrics {
+    complexity: number;
+    linesOfCode: number;
+    commentRatio: number;
+    functionCount: number;
+    maxNestingDepth: number;
+    duplicateCode: number;
+    testCoverage?: number;
+}
+export interface CodeQualityScore {
+    overall: number;
+    maintainability: number;
+    reliability: number;
+    security: number;
+    performance: number;
+    issues: QualityIssue[];
+}
+export interface QualityIssue {
+    type: 'error' | 'warning' | 'info';
+    category: 'complexity' | 'style' | 'security' | 'performance' | 'maintainability';
+    message: string;
+    line?: number;
+    column?: number;
+    severity: number;
+    suggestion?: string;
+    autoFixable: boolean;
+}
+export interface RefactoringSuggestion {
+    type: 'extract-method' | 'rename' | 'reorder' | 'simplify' | 'optimize-imports' | 'add-types';
+    description: string;
+    currentCode: string;
+    suggestedCode: string;
+    confidence: number;
+    impact: 'low' | 'medium' | 'high';
+    effort: 'quick' | 'moderate' | 'extensive';
+    benefits: string[];
+}
+export interface ImpactAnalysis {
+    filePath: string;
+    directImpacts: string[];
+    indirectImpacts: string[];
+    testFiles: string[];
+    riskScore: number;
+    breakingChanges: boolean;
+    estimatedReviewTime: number;
+}
+export interface SemanticSearchResult {
+    filePath: string;
+    relevance: number;
+    context: string;
+    matchedConcepts: string[];
+    codeSnippet: string;
+}
+export interface CodePattern {
+    name: string;
+    description: string;
+    examples: string[];
+    antiPattern?: string;
+    solution: string;
+    confidence: number;
+}
+export declare class IntelligentCodeAnalyzer {
+    private graph;
+    private program?;
+    private typeChecker?;
+    constructor(graph: ProjectKnowledgeGraph);
+    /**
+     * Comprehensive code analysis with metrics and quality scoring
+     */
+    analyzeFile(filePath: string): Promise<{
+        metrics: CodeMetrics;
+        quality: CodeQualityScore;
+        ast: ts.SourceFile | null;
+        symbols: SymbolAnalysis[];
+    }>;
+    private calculateMetrics;
+    private analyzeQuality;
+    private analyzeSymbols;
+    private analyzeFunction;
+    private analyzeClass;
+    private analyzeInterface;
+    private extractJSDoc;
+    /**
+     * Smart impact analysis - predicts what will be affected by changes
+     */
+    analyzeImpact(filePath: string, changeDescription?: string): Promise<ImpactAnalysis>;
+    private findRelatedTests;
+    /**
+     * Generate intelligent refactoring suggestions
+     */
+    suggestRefactoring(filePath: string): Promise<RefactoringSuggestion[]>;
+    private findLongFunctions;
+    private findNestedConditionals;
+    private findAnyUsages;
+    /**
+     * Semantic code search - find code by concept, not just text
+     */
+    semanticSearch(query: string, options?: {
+        filePattern?: string;
+        maxResults?: number;
+    }): Promise<SemanticSearchResult[]>;
+    private extractConcepts;
+    private calculateRelevance;
+    private extractRelevantSnippet;
+    private extractContext;
+    private getMatchingFiles;
+    /**
+     * Auto-fix common code issues
+     */
+    autoFix(filePath: string, options?: {
+        fixUnusedImports?: boolean;
+        fixTrailingWhitespace?: boolean;
+        fixMissingSemicolons?: boolean;
+        optimizeImports?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        fixes: Array<{
+            type: string;
+            line: number;
+            original: string;
+            fixed: string;
+        }>;
+        applied: boolean;
+    }>;
+    /**
+     * Detect code patterns and anti-patterns
+     */
+    detectPatterns(filePath: string, sourceFile: ts.SourceFile): CodePattern[];
+}
+interface SymbolAnalysis {
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'method' | 'type';
+    params?: {
+        name: string;
+        type: string;
+        optional?: boolean;
+    }[];
+    returnType?: string;
+    isAsync?: boolean;
+    complexity?: number;
+    isExported: boolean;
+    documentation?: string;
+    methods?: SymbolAnalysis[];
+    properties?: {
+        name: string;
+        type: string;
+        optional?: boolean;
+    }[];
+}
+export declare function getIntelligentAnalyzer(graph: ProjectKnowledgeGraph): IntelligentCodeAnalyzer;
+export {};