winter-super-cli 2026.6.6 → 2026.6.8

package/src/cli/tui.js

@@ -0,0 +1,195 @@
+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}`;
+  
+  if (!summary.includes('\n')) {
+    return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${summary}${c.reset}`;
+  }
+
+  const lines = summary.split('\n');
+  const firstLine = lines.shift();
+  
+  const formattedRest = lines.map(line => {
+    if (line.startsWith('+')) return `    ${c.green}${line}${c.reset}`;
+    if (line.startsWith('-')) return `    ${c.red}${line}${c.reset}`;
+    if (line.startsWith('@@')) return `    ${c.cyan}${line}${c.reset}`;
+    return `    ${c.dim}${line}${c.reset}`;
+  }).join('\n');
+
+  return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${firstLine}${c.reset}\n${formattedRest}`;
+}

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,
         },
       };

package/src/tools/executor.js

@@ -471,7 +471,7 @@ export class ToolExecutor {
     const cwd = context.cwd || this.projectPath;
     const resolvedPath = (p) => this.resolveInputPath(p, cwd);
 
-    const preflight = this.preflightValidateToolArgs(toolName, input, { cwd });
+    const preflight = await this.preflightValidateToolArgs(toolName, input, { cwd });
     if (preflight?.success === false) {
       return preflight;
     }
@@ -568,7 +568,7 @@ export class ToolExecutor {
     }
   }
 
-  preflightValidateToolArgs(toolName, input, { cwd } = {}) {
+  async preflightValidateToolArgs(toolName, input, { cwd } = {}) {
     const args = (input && typeof input === 'object' && !Array.isArray(input)) ? input : {};
     const pick = (...keys) => {
       for (const key of keys) {
@@ -619,6 +619,16 @@ export class ToolExecutor {
       if (!cmd) {
         return { success: false, error: 'command is required', recovery: 'Example: Bash {"command":"npm test"}' };
       }
+      const missingScript = await this.findMissingNpmScript(cmd, cwd);
+      if (missingScript) {
+        return {
+          success: false,
+          error: `npm script "${missingScript.script}" does not exist in package.json`,
+          recovery: missingScript.available.length
+            ? `Use an existing script: ${missingScript.available.map(name => `npm run ${name}`).join(', ')}`
+            : 'No package scripts are defined. Inspect package.json before running npm scripts.',
+        };
+      }
       const next = { command: cmd };
       if (typeof args.timeout !== 'undefined') next.timeout = args.timeout;
       if (typeof args.shell !== 'undefined') next.shell = args.shell;
@@ -706,6 +716,21 @@ export class ToolExecutor {
     return { success: true };
   }
 
+  async findMissingNpmScript(command, cwd) {
+    const match = String(command || '').trim().match(/^(?:npm|pnpm|yarn|bun)\s+run\s+([A-Za-z0-9:_-]+)(?:\s|$)/i);
+    if (!match) return null;
+    const script = match[1];
+    try {
+      const packageJsonPath = path.join(cwd || this.projectPath, 'package.json');
+      const pkg = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+      const scripts = pkg.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+      if (Object.prototype.hasOwnProperty.call(scripts, script)) return null;
+      return { script, available: Object.keys(scripts).sort() };
+    } catch {
+      return null;
+    }
+  }
+
   redactToolInput(input) {
     if (!input || typeof input !== 'object') return input;
     const secretPattern = /(api[-_]?key|auth[-_]?token|access[-_]?token|refresh[-_]?token|secret|password)/i;
@@ -1012,10 +1037,60 @@ export class ToolExecutor {
         size: content.length
       };
     } catch (error) {
-      return { success: false, error: error.message, path: filePath };
+      if (error?.code === 'ENOENT') {
+        const suggestions = await this.findNearbyPathSuggestions(filePath);
+        return {
+          success: false,
+          error: `File not found: ${filePath}`,
+          code: 'ENOENT',
+          path: filePath,
+          suggestions,
+          recovery: [
+            'Do not retry the same missing path.',
+            'Use Glob or Grep to discover the real file path before reading again.',
+            suggestions.length ? `Nearby candidates: ${suggestions.join(', ')}` : `Search from project root: ${this.projectPath}`,
+          ].join(' '),
+        };
+      }
+      return { success: false, error: error.message, code: error?.code, path: filePath };
     }
   }
 
+  async findNearbyPathSuggestions(filePath, limit = 8) {
+    if (!filePath) return [];
+    const targetName = path.basename(filePath).toLowerCase();
+    const targetStem = targetName.replace(/\.[^.]+$/, '');
+    if (!targetName) return [];
+
+    const candidates = [];
+    const ignored = new Set(['node_modules', '.git', 'dist', 'build', '.winter', '.claude', 'VSCode-win32-x64', 'vscode-main']);
+    const walk = async (dir, depth = 0) => {
+      if (depth > 5 || candidates.length >= limit * 4) return;
+      let entries = [];
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      for (const entry of entries) {
+        if (ignored.has(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath, depth + 1);
+          continue;
+        }
+        const name = entry.name.toLowerCase();
+        if (name === targetName || name.includes(targetStem) || targetStem.includes(name.replace(/\.[^.]+$/, ''))) {
+          candidates.push(path.relative(this.projectPath, fullPath) || fullPath);
+        }
+      }
+    };
+
+    await walk(this.projectPath);
+    return [...new Set(candidates)].slice(0, limit);
+  }
+
   async backupFile(filePath) {
     try {
       const fsMod = await import('fs/promises');