winter-super-cli 2026.6.5 → 2026.6.7

package/src/cli/tui.js

@@ -0,0 +1,181 @@
+import { terminalWidth, visibleWidth, wrapText } from './terminal-ui.js';
+
+const WINTER_LOGO = [
+  ' __        __ _____ _   _ _______ ______ _____  ',
+  ' \\ \\      / /|_   _| \\ | |__   __|  ____|  __ \\ ',
+  '  \\ \\ /\\ / /   | | |  \\| |  | |  | |__  | |__) |',
+  '   \\ V  V /    | | | .  |  | |  |  __| |  _  / ',
+  '    \\_/\\_/    _| |_| |\\  |  | |  | |____| | \\ \\ ',
+  '              |_____|_| \\_|  |_|  |______|_|  \\_\\',
+];
+
+function basenameFromPath(filePath, fallback = 'project') {
+  const parts = String(filePath || '').split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] || fallback;
+}
+
+export function buildTuiSnapshot(repl = {}) {
+  const provider = repl.ai?.getActiveProvider?.() || 'provider';
+  const model = repl.ai?.providers?.[provider]?.model || 'model';
+  return {
+    provider,
+    model,
+    projectPath: repl.projectPath || process.cwd(),
+    sessionShort: String(repl.session?.getSessionId?.() || 'session').slice(0, 8),
+    projectName: basenameFromPath(repl.projectPath || process.cwd()),
+  };
+}
+
+export function renderInputPanel(snapshot, {
+  colors,
+  width = terminalWidth(66, 124),
+} = {}) {
+  const c = colors || {};
+  const panelWidth = Math.max(64, width - 2);
+  const innerWidth = Math.max(20, panelWidth - 4);
+  
+  return {
+    top: `${c.dim}┌${'─'.repeat(innerWidth + 2)}┐${c.reset}`,
+    status: '',
+    hint: '',
+    prompt: `${c.bright}${c.green}│${c.reset} `,
+    bottom: `${c.dim}└${'─'.repeat(innerWidth + 2)}┘${c.reset}`,
+  };
+}
+
+export function renderLandingTui(snapshot, { colors } = {}) {
+  const c = colors || {};
+  const W = Math.max(60, Math.min(process.stdout.columns || 80, 140));
+  
+  const bright = c.bright || '\x1b[1m';
+  const green = c.brightGreen || c.green || '\x1b[92m';
+  const white = c.white || '\x1b[37m';
+  const dim = c.dim || '\x1b[2m';
+  const reset = c.reset || '\x1b[0m';
+  const bgBlue = '\x1b[48;5;236m'; 
+
+  const logoLines = WINTER_LOGO.map(line => `${bright}${green}${line}${reset}`);
+  
+  const leftStatus = ` ${snapshot.provider} · ${snapshot.model} `;
+  const rightStatus = ` ESC×2 exit · /help `;
+  const padding = Math.max(0, W - leftStatus.length - rightStatus.length);
+  const statusBar = `${bgBlue}${white}${leftStatus}${' '.repeat(padding)}${rightStatus}${reset}`;
+
+  const dock = renderInputPanel(snapshot, { colors });
+
+  return [
+    ...logoLines,
+    '',
+    `${white}Winter will run commands on your behalf to help you build.${reset}`,
+    '',
+    `${white}Directory${reset} ${dim}${snapshot.projectPath}${reset}`,
+    '',
+    statusBar,
+    dock.top
+  ].join('\n');
+}
+
+export function renderStatusPanel(snapshot, { colors, title = 'Status' } = {}) {
+  const c = colors || {};
+  const bgBlue = '\x1b[48;5;236m';
+  const header = `${bgBlue}${c.white} ${title.toUpperCase()} ${c.reset}`;
+  
+  return [
+    '',
+    header,
+    `${c.dim}Project :${c.reset} ${snapshot.projectName} (${snapshot.projectPath})`,
+    `${c.dim}Model   :${c.reset} ${snapshot.provider}/${snapshot.model} (${snapshot.modelTier})`,
+    `${c.dim}Session :${c.reset} ${snapshot.sessionShort} | State: ${snapshot.statusText}`,
+    `${c.dim}Codebase:${c.reset} ${snapshot.codebaseFiles} files, ${snapshot.codebaseChunks} chunks`,
+    `${c.dim}Activity:${c.reset} ${snapshot.toolSummary || 'idle'}`,
+    ''
+  ].join('\n');
+}
+
+export function renderStartupTui(snapshot, opts) { return renderLandingTui(snapshot, opts); }
+export function renderConversationStartup(snapshot, opts) { return renderLandingTui(snapshot, opts); }
+export function renderShellTui(snapshot, opts) { return renderLandingTui(snapshot, opts); }
+
+export function renderCommandCenter({ colors, width = 80 } = {}) {
+  const c = colors || {};
+  const bgBlue = '\x1b[48;5;236m';
+  const header = `${bgBlue}${c.white} COMMAND CENTER ${c.reset}`;
+  
+  return [
+    '',
+    header,
+    `${c.brightGreen}B${c.reset} ${c.bright}${c.cyan}Build  ${c.reset} ${c.dim}/auto /debug /tdd /swe /composer${c.reset}`,
+    `${c.brightGreen}I${c.reset} ${c.bright}${c.cyan}Inspect${c.reset} ${c.dim}/read /grep /glob /search /context${c.reset}`,
+    `${c.brightGreen}M${c.reset} ${c.bright}${c.cyan}Model  ${c.reset} ${c.dim}/provider /providers /model /models /scorecard${c.reset}`,
+    `${c.brightGreen}K${c.reset} ${c.bright}${c.cyan}Memory ${c.reset} ${c.dim}/remember /memories /memory-vault /compress${c.reset}`,
+    `${c.brightGreen}V${c.reset} ${c.bright}${c.cyan}Visual ${c.reset} ${c.dim}/image /paste ^V img /designs /page-agent${c.reset}`,
+    `${c.brightGreen}S${c.reset} ${c.bright}${c.cyan}System ${c.reset} ${c.dim}/doctor full /stats /permissions /mcp /help${c.reset}`,
+    ''
+  ].join('\n');
+}
+
+export function renderSplitPanel({ title, left = [], right = [], colors, width = 80 } = {}) {
+  const c = colors || {};
+  const bgBlue = '\x1b[48;5;236m';
+  const header = `${bgBlue}${c.white} ${(title || 'Info').toUpperCase()} ${c.reset}`;
+  
+  const innerWidth = Math.max(56, width - 4);
+  const leftWidth = Math.floor(innerWidth * 0.5);
+  
+  const rows = [];
+  const count = Math.max(left.length, right.length);
+  for (let i = 0; i < count; i++) {
+    const lText = String(left[i] || '');
+    const rText = String(right[i] || '');
+    const lPlain = lText.replace(/\x1b\[[0-9;]*m/g, '');
+    const lPad = Math.max(0, leftWidth - lPlain.length);
+    rows.push(`${lText}${' '.repeat(lPad)}   ${rText}`);
+  }
+
+  return [
+    '',
+    header,
+    ...rows,
+    ''
+  ].join('\n');
+}
+
+export function renderHistoryPanel(entries = [], { colors, title = 'Recent Session' } = {}) {
+  const c = colors || {};
+  const bgBlue = '\x1b[48;5;236m';
+  const header = `${bgBlue}${c.white} ${title.toUpperCase()} ${c.reset}`;
+  
+  const body = entries.length > 0
+    ? entries.map(entry => {
+      const role = entry.role === 'assistant' ? 'Winter' : entry.role === 'user' ? 'You' : entry.role || 'event';
+      const roleColor = entry.role === 'assistant' ? c.cyan : c.green;
+      return `${c.bright}${roleColor}${role}${c.reset}: ${entry.content || entry.text || ''}`;
+    })
+    : [`${c.dim}No previous messages.${c.reset}`];
+
+  return [
+    '',
+    header,
+    ...body,
+    ''
+  ].join('\n');
+}
+
+export function renderAssistantPanel({ content = '', footer = '', colors, title = 'Assistant' } = {}) {
+  const c = colors || {};
+  const bgBlue = '\x1b[48;5;236m';
+  const header = `${bgBlue}${c.white} ${title.toUpperCase()} ${c.reset}`;
+  
+  const parts = [];
+  if (title) parts.push('', header);
+  if (content) parts.push(content);
+  if (footer) parts.push(`${c.dim}${footer}${c.reset}`);
+  return parts.join('\n') + '\n';
+}
+
+export function renderToolPanel({ toolName = 'Tool', summary = '', success = true, colors } = {}) {
+  const c = colors || {};
+  const status = success ? `${c.brightGreen}✓${c.reset}` : `${c.red}✖${c.reset}`;
+  const plainSummary = String(summary || '').replace(/\n/g, ' ');
+  return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${plainSummary}${c.reset}`;
+}

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,

package/src/context/token-juice.js

@@ -63,26 +63,52 @@ export function serializeToolResultToMarkdown(toolName, result = {}) {
 export function extractKeyLines(text = '', limit = 18) {
   const patterns = /(error|failed|exception|warning|todo|fixme|export |import |class |function |const |let |var |def |interface |type |=>)/i;
   const selected = [];
-  for (const line of String(text).split(/\r?\n/)) {
-    if (patterns.test(line)) selected.push(line.trim());
+  const lines = String(text).split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (patterns.test(line)) selected.push(`L${index + 1}: ${line.trim()}`);
     if (selected.length >= limit) break;
   }
   return selected;
 }
 
-export function buildCompressedPreview(toolName, result, markdown, links = []) {
+function buildExcerpts(text = '', maxChars = 700) {
+  const value = String(text || '').trim();
+  if (!value) return [];
+  if (value.length <= maxChars) return [value];
+  const head = value.slice(0, Math.floor(maxChars * 0.58)).trimEnd();
+  const tail = value.slice(-Math.floor(maxChars * 0.32)).trimStart();
+  return [
+    `${head}\n[TokenJuice middle omitted from inline preview; full text is in memory]\n${tail}`,
+  ];
+}
+
+function buildChunkMap(saved) {
+  if (!saved?.files?.length) return [];
+  return saved.files.map(file => {
+    const label = `part ${file.part}/${saved.parts}`;
+    return `- ${label}: ${file.wikiLink} (~${file.tokensEst} tokens)`;
+  });
+}
+
+export function buildCompressedPreview(toolName, result, markdown, savedOrLinks = []) {
+  const links = Array.isArray(savedOrLinks) ? savedOrLinks : (savedOrLinks?.links || []);
   const source = [result?.error, result?.content, result?.stdout, result?.stderr, result?.diff, result?.message]
     .filter(Boolean)
     .join('\n');
   const keyLines = extractKeyLines(source);
-  const preview = compactText(source || markdown, 1800);
+  const excerpts = buildExcerpts(source || markdown);
+  const chunkMap = Array.isArray(savedOrLinks) ? [] : buildChunkMap(savedOrLinks);
   const lines = [
-    `TokenJuice compressed a large ${toolName || 'tool'} result before model context.`,
-    links.length ? `Full markdown chunks: ${links.join(', ')}` : '',
-    keyLines.length ? 'Key lines:' : '',
+    `TokenJuice losslessly stored a large ${toolName || 'tool'} result before model context.`,
+    links.length ? `Full detail chunks: ${links.join(', ')}` : '',
+    chunkMap.length ? 'Chunk map for exact detail retrieval:' : '',
+    ...chunkMap,
+    'Instruction: use Read on the memory file behind a chunk link when exact omitted lines are needed.',
+    keyLines.length ? 'Key lines with original line numbers:' : '',
     ...keyLines.map(line => `- ${line}`),
-    keyLines.length ? '' : 'Preview:',
-    keyLines.length ? compactText(preview, 900) : preview,
+    excerpts.length ? 'Representative excerpts:' : '',
+    ...excerpts.map(excerpt => compactText(excerpt, 900)),
   ].filter(Boolean);
   return lines.join('\n');
 }
@@ -129,7 +155,7 @@ export class TokenJuice {
           source: result.path || result.url || result.command || '',
         },
       });
-      const preview = buildCompressedPreview(toolName, result, markdown, saved.links);
+      const preview = buildCompressedPreview(toolName, result, markdown, saved);
       const compressed = {
         ...basePromptResult,
         content: preview,
@@ -143,6 +169,7 @@ export class TokenJuice {
           memoryRoot: saved.rootDir,
           memoryLinks: saved.links,
           memoryFiles: saved.files.map(file => file.relativePath),
+          detailRetrieval: 'Read the listed memoryFiles for exact omitted content.',
           parts: saved.parts,
         },
       };