winter-super-cli 2026.6.5 → 2026.6.6

package/src/codebase-index/codegraph-adapter.js

@@ -0,0 +1,154 @@
+import path from 'path';
+
+async function importCodeGraphModule() {
+  return quietCodeGraph(() => import('@colbymchenry/codegraph'));
+}
+
+async function quietCodeGraph(fn) {
+  if (process.env.WINTER_CODEGRAPH_DEBUG === '1') {
+    return fn();
+  }
+
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  try {
+    console.log = () => {};
+    console.info = () => {};
+    console.warn = () => {};
+    console.error = () => {};
+    return await fn();
+  } finally {
+    console.log = originalLog;
+    console.info = originalInfo;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export class CodeGraphAdapter {
+  constructor(options = {}) {
+    this.projectPath = path.resolve(options.projectPath || process.cwd());
+    this.enabled = options.enabled !== false;
+    this.instance = options.instance || null;
+    this.module = options.module || null;
+    this.available = Boolean(this.instance);
+    this.lastError = null;
+  }
+
+  async init() {
+    if (!this.enabled) return false;
+    if (this.instance) {
+      this.available = true;
+      return true;
+    }
+
+    try {
+      const mod = this.module || await importCodeGraphModule();
+      const CodeGraph = mod.CodeGraph || mod.default;
+      if (!CodeGraph) throw new Error('CodeGraph export not found');
+
+      this.instance = await quietCodeGraph(() => CodeGraph.isInitialized?.(this.projectPath)
+        ? CodeGraph.open(this.projectPath, { sync: false })
+        : CodeGraph.init(this.projectPath, {
+          index: false,
+          config: {
+            exclude: [
+              'node_modules/**',
+              '.git/**',
+              '.winter/**',
+              'dist/**',
+              'build/**',
+              'resources/local/**',
+              'VSCode-win32-x64/**',
+              'vscode-main/**',
+            ],
+          },
+        }));
+      this.available = true;
+      return true;
+    } catch (error) {
+      this.available = false;
+      this.lastError = error;
+      return false;
+    }
+  }
+
+  async ensureIndexed() {
+    if (!await this.init()) return null;
+    const stats = this.safeStats();
+    if (!stats || stats.nodeCount === 0 || stats.fileCount === 0) {
+      await quietCodeGraph(() => this.instance.indexAll());
+    } else {
+      await quietCodeGraph(() => this.instance.sync?.());
+    }
+    return this.safeStats();
+  }
+
+  safeStats() {
+    try {
+      return this.instance?.getStats?.() || null;
+    } catch (error) {
+      this.lastError = error;
+      return null;
+    }
+  }
+
+  async search(query, options = {}) {
+    await this.ensureIndexed();
+    if (!this.instance) return [];
+    try {
+      return await quietCodeGraph(() => this.instance.searchNodes(String(query || ''), {
+        limit: options.limit || 20,
+      }));
+    } catch (error) {
+      this.lastError = error;
+      return [];
+    }
+  }
+
+  async buildContext(task, options = {}) {
+    await this.ensureIndexed();
+    if (!this.instance) return '';
+    try {
+      const result = await quietCodeGraph(() => this.instance.buildContext(String(task || ''), {
+        maxNodes: options.maxNodes || 24,
+        maxCodeBlocks: options.maxCodeBlocks || 8,
+        maxCodeBlockSize: options.maxCodeBlockSize || 1800,
+        includeCode: options.includeCode !== false,
+        format: 'markdown',
+      }));
+      return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    } catch (error) {
+      this.lastError = error;
+      return '';
+    }
+  }
+
+  async findSymbol(name, options = {}) {
+    const results = await this.search(name, options);
+    return results.map(result => {
+      const node = result.node || result;
+      return {
+        name: node.name,
+        type: node.kind || 'symbol',
+        filePath: node.filePath,
+        line: node.startLine || 1,
+        endLine: node.endLine || node.startLine || 1,
+        qualifiedName: node.qualifiedName,
+        score: result.score,
+        content: node.signature || node.docstring || '',
+        node,
+      };
+    });
+  }
+
+  close() {
+    try {
+      this.instance?.close?.();
+    } catch {}
+  }
+}
+
+export default CodeGraphAdapter;

package/src/codebase-index/indexer.js

@@ -8,7 +8,7 @@ import path from 'path';
 import crypto from 'crypto';
 
 const DEFAULT_IGNORE = new Set([
-  'node_modules', '.git', 'dist', 'build', '.winter', '.claude',
+  'node_modules', '.git', 'dist', 'build', '.winter', '.codegraph', '.claude',
   '.next', '.cache', 'coverage', '.nyc_output',
   '__pycache__', '.venv', 'venv', 'env', '.env',
   'VSCode-win32-x64', 'vscode-main',

package/src/codebase-index/search.js

@@ -7,20 +7,26 @@
  * - Combined search
  */
 import { CodebaseIndexer } from './indexer.js';
+import { CodeGraphAdapter } from './codegraph-adapter.js';
 import path from 'path';
 
 export class CodebaseSearch {
   constructor(options = {}) {
     this.indexer = options.indexer || new CodebaseIndexer(options);
     this.projectPath = options.projectPath || this.indexer.projectPath;
+    this.codeGraph = options.codeGraphAdapter || (
+      options.enableCodeGraph ? new CodeGraphAdapter({ projectPath: this.projectPath }) : null
+    );
   }
 
   async init() {
     await this.indexer.init();
+    await this.codeGraph?.init?.();
   }
 
   async ensureIndexed() {
     const stats = this.indexer.getStats();
+    await this.codeGraph?.ensureIndexed?.();
     if (stats.totalChunks === 0) {
       return await this.indexer.indexAll();
     }
@@ -34,6 +40,9 @@ export class CodebaseSearch {
   async query(query, options = {}) {
     await this.ensureIndexed();
     const results = this.indexer.search(query, options);
+    const graphResults = this.codeGraph
+      ? await this.codeGraph.search(query, { limit: Math.min(options.limit || 20, 12) })
+      : [];
 
     // Group by file for display
     const byFile = new Map();
@@ -46,9 +55,10 @@ export class CodebaseSearch {
 
     return {
       query,
-      totalResults: results.length,
+      totalResults: results.length + graphResults.length,
       totalFiles: byFile.size,
       results,
+      graphResults,
       byFile: [...byFile.entries()].map(([filePath, chunks]) => ({
         filePath,
         score: Math.max(...chunks.map(c => c.score)),
@@ -63,6 +73,9 @@ export class CodebaseSearch {
    */
   async findSymbol(name, options = {}) {
     await this.ensureIndexed();
+    const graphMatches = this.codeGraph
+      ? await this.codeGraph.findSymbol(name, options)
+      : [];
     const nameLower = name.toLowerCase();
     const matches = [];
 
@@ -79,7 +92,12 @@ export class CodebaseSearch {
       }
     }
 
-    return matches.slice(0, options.limit || 20);
+    return [...graphMatches, ...matches].slice(0, options.limit || 20);
+  }
+
+  async buildGraphContext(task, options = {}) {
+    if (!this.codeGraph) return '';
+    return await this.codeGraph.buildContext(task, options);
   }
 
   /**
@@ -148,6 +166,13 @@ export class CodebaseSearch {
 
     return {
       ...stats,
+      codeGraph: this.codeGraph
+        ? {
+          available: this.codeGraph.available,
+          stats: this.codeGraph.safeStats?.() || null,
+          error: this.codeGraph.lastError?.message || null,
+        }
+        : null,
       languages: [...languages.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10),
       topSymbols,
     };
@@ -161,6 +186,10 @@ export class CodebaseSearch {
     return await this.indexer.clear();
   }
 
+  close() {
+    this.codeGraph?.close?.();
+  }
+
   // ── Private ────────────────────────────────────────
 
   _extractRelevantLine(content, lineNumber) {

package/src/context/router.js

@@ -12,19 +12,8 @@ function flattenMessageText(messages) {
 }
 
 import { ReasoningConfig, REASONING_LEVELS } from '../ai/reasoning.js';
-import { classifyModelTier, isSmallModel, getReasoningBump, MODEL_TIERS } from '../ai/model-capabilities.js';
+import { classifyModelTier } from '../ai/model-capabilities.js';
 
-/**
- * Bump reasoning level by N steps.
- */
-function bumpReasoningLevel(level, steps) {
-  const order = [REASONING_LEVELS.NONE, REASONING_LEVELS.LOW, REASONING_LEVELS.MEDIUM, REASONING_LEVELS.HIGH, REASONING_LEVELS.MAX];
-  const idx = order.indexOf(level);
-  if (idx === -1) return level;
-  const newIdx = Math.min(idx + steps, order.length - 1);
-  return order[newIdx];
-}
-
 export function selectExecutionProfile({ messages = [], activeProvider = null, providers = {}, options = {} } = {}) {
   const text = flattenMessageText(messages);
   const providerNames = Object.keys(providers).filter(name => providers[name]?.ready || providers[name]?.model);
@@ -50,35 +39,9 @@ export function selectExecutionProfile({ messages = [], activeProvider = null, p
   const providerConfig = providers[provider] || providers[activeProvider] || {};
   const model = options.model || providerConfig.model || providers[activeProvider]?.model || null;
 	
-	  // Detect model capability tier
-	  const modelTier = classifyModelTier(model, provider);
-	  const isSmall = isSmallModel(modelTier);
-	  const reasoningBump = getReasoningBump(modelTier);
-	
-	  // Determine reasoning level based on task complexity signals
-	  // Default: HIGH for coding — all models must think deeply
-	  let reasoningLevel = options.reasoningLevel || REASONING_LEVELS.HIGH;
-	  if (!options.reasoningLevel) {
-	    const hasDeepSignals = /\b(refactor|architecture|redesign|migrate|complex|full stack|e2e|end to end|security|optimize|performance|implement|build|create)\b/.test(text);
-	    const hasComplexSignals = /\b(debug|fix|test|multiple|integrate|design|plan|review|analyze)\b/.test(text);
-	
-	    if (hasDeepSignals && text.length > 30) {
-	      reasoningLevel = REASONING_LEVELS.MAX;
-	    } else if (hasComplexSignals && text.length > 20) {
-	      reasoningLevel = REASONING_LEVELS.MAX;
-	    } else if (text.split(/\s+/).length > 10) {
-	      reasoningLevel = REASONING_LEVELS.HIGH;
-	    } else if (text.split(/\s+/).length < 3) {
-	      reasoningLevel = REASONING_LEVELS.MEDIUM;
-	    } else {
-	      reasoningLevel = REASONING_LEVELS.HIGH;
-	    }
-	
-	    // If small model, bump reasoning level even more to compensate
-	    if (isSmall && reasoningBump > 0) {
-	      reasoningLevel = bumpReasoningLevel(reasoningLevel, reasoningBump);
-	    }
-	  }
+  // Keep the real tier for diagnostics, but Winter always pushes max reasoning.
+  const modelTier = classifyModelTier(model, provider);
+  const reasoningLevel = options.reasoningLevel || REASONING_LEVELS.MAX;
 
   const reasoning = new ReasoningConfig({
     level: reasoningLevel,