winter-super-cli 2026.5.25 → 2026.5.27

package/src/cli/secret-env.js

@@ -0,0 +1,69 @@
+import { promises as fs } from 'fs';
+
+const SECRET_PATTERN = /(api[-_]?key|auth[-_]?token|access[-_]?token|refresh[-_]?token|secret|password)/i;
+
+export function providerEnvName(provider, field = 'apiKey') {
+  const normalizedProvider = String(provider || '')
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, '_');
+  const normalizedField = String(field || 'apiKey')
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, '_');
+  return `WINTER_${normalizedProvider}_${normalizedField}`;
+}
+
+export function readEnvFileText(text = '') {
+  const values = {};
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    values[key] = rawValue.replace(/^"|"$/g, '').replace(/^'|'$/g, '');
+  }
+  return values;
+}
+
+export async function loadEnvFile(filePath) {
+  try {
+    const text = await fs.readFile(filePath, 'utf8');
+    const values = readEnvFileText(text);
+    for (const [key, value] of Object.entries(values)) {
+      if (process.env[key] === undefined) {
+        process.env[key] = value;
+      }
+    }
+    return values;
+  } catch {
+    return {};
+  }
+}
+
+export function redactSecrets(value) {
+  if (Array.isArray(value)) return value.map(item => redactSecrets(item));
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+    key,
+    SECRET_PATTERN.test(key) ? '[redacted]' : redactSecrets(entry),
+  ]));
+}
+
+export function stripInlineSecrets(config = {}) {
+  const next = structuredClone(config);
+  for (const [provider, section] of Object.entries(next)) {
+    if (!section || typeof section !== 'object' || Array.isArray(section)) continue;
+    if (typeof section.apiKey === 'string' && section.apiKey) {
+      section.apiKeyEnv = section.apiKeyEnv || providerEnvName(provider, 'apiKey');
+      delete section.apiKey;
+    }
+    if (typeof section.authToken === 'string' && section.authToken) {
+      section.authTokenEnv = section.authTokenEnv || providerEnvName(provider, 'authToken');
+      delete section.authToken;
+    }
+  }
+  return next;
+}
+

package/src/cli/slash-commands.js

@@ -0,0 +1,50 @@
+export const SLASH_COMMANDS = [
+  { cmd: '/project', desc: 'Show/set current project' },
+  { cmd: '/cd', desc: 'Change directory' },
+  { cmd: '/pwd', desc: 'Show current directory' },
+  { cmd: '/session', desc: 'Session management' },
+  { cmd: '/sessions', desc: 'List all sessions' },
+  { cmd: '/clear', desc: 'Clear screen' },
+  { cmd: '/remember', desc: 'Store in memory', usage: '/remember <text>' },
+  { cmd: '/memories', desc: 'Show stored memories' },
+  { cmd: '/forget', desc: 'Clear memories', usage: '/forget [pattern]' },
+  { cmd: '/compress', desc: 'Compress old conversation context' },
+  { cmd: '/plan', desc: 'Create/view plans' },
+  { cmd: '/plans', desc: 'List active plans' },
+  { cmd: '/tasks', desc: 'List tasks' },
+  { cmd: '/task', desc: 'Create task', usage: '/task <description>' },
+  { cmd: '/agent', desc: 'Launch subagent', usage: '/agent <task>' },
+  { cmd: '/read', desc: 'Read file', usage: '/read <file>' },
+  { cmd: '/write', desc: 'Write file', usage: '/write <file> <content>' },
+  { cmd: '/glob', desc: 'Find files', usage: '/glob <pattern>' },
+  { cmd: '/grep', desc: 'Search files', usage: '/grep <pattern>' },
+  { cmd: '/bash', desc: 'Run command', usage: '/bash <command>' },
+  { cmd: '/image', desc: 'Analyze image/screenshot', usage: '/image <file> [question]' },
+  { cmd: '/design', desc: 'Design commands', sub: ['search', 'add', 'list', 'preview'] },
+  { cmd: '/designs', desc: 'List/search awesome-design-md systems', usage: '/designs [query]' },
+  { cmd: '/skill', desc: 'Skills management', sub: ['list', 'enable', 'create'] },
+  { cmd: '/skills', desc: 'List local Winter/Codex/Claude skills' },
+  { cmd: '/plugin', desc: 'Plugin management', sub: ['list', 'install', 'remove'] },
+  { cmd: '/mcp', desc: 'MCP server management', sub: ['list', 'add', 'remove', 'allow'] },
+  { cmd: '/permissions', desc: 'Permission allowlist', sub: ['list', 'allow', 'prompt'] },
+  { cmd: '/stats', desc: 'Tool usage statistics' },
+  { cmd: '/replay', desc: 'Replay recent session/tool events', usage: '/replay [count]' },
+  { cmd: '/diff', desc: 'Preview git diff', usage: '/diff [--cached|--confirm]' },
+  { cmd: '/watch', desc: 'Run a command when files change', usage: '/watch <command>|stop' },
+  { cmd: '/swe', desc: 'Run SWE-agent workflow', usage: '/swe <task>' },
+  { cmd: '/codex', desc: 'Browse ~/.codex resources', usage: '/codex [skills|plugins|models|rules|memories]' },
+  { cmd: '/claude', desc: 'Browse ~/.claude resources', usage: '/claude [skills|plugins|settings]' },
+  { cmd: '/karpathy', desc: 'Browse karpathy-tools and guidelines' },
+  { cmd: '/agents', desc: 'Read ~/agents.md' },
+  { cmd: '/resources', desc: 'Show bundled local resource manifest' },
+  { cmd: '/provider', desc: 'Show/switch AI provider', usage: '/provider <custom|claude|ollama|openai|groq>' },
+  { cmd: '/providers', desc: 'List all providers' },
+  { cmd: '/models', desc: 'List configured/cached models' },
+  { cmd: '/config', desc: 'Show configuration' },
+  { cmd: '/model', desc: 'Show/set active provider model', usage: '/model <model-id>' },
+  { cmd: '/help', desc: 'Show this help' },
+  { cmd: '/?', desc: 'Show help' },
+  { cmd: '/exit', desc: 'Exit Winter' },
+  { cmd: '/quit', desc: 'Exit Winter' },
+];
+

package/src/cli/spinner.js

@@ -0,0 +1,32 @@
+export class Spinner {
+  constructor(options = {}) {
+    const normalized = typeof options === 'string' ? { text: options } : options;
+    this.text = normalized.text || '';
+    this.colors = normalized.colors || {};
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.interval = null;
+    this.frameIndex = 0;
+  }
+
+  start() {
+    if (this.interval) return;
+    const cyan = this.colors.cyan || '';
+    const reset = this.colors.reset || '';
+    const dim = this.colors.dim || '';
+    this.interval = setInterval(() => {
+      process.stdout.write(`\r\x1b[K${cyan}${this.frames[this.frameIndex]}${reset} ${dim}${this.text}${reset}`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+
+  stop(finalText) {
+    if (!this.interval) return;
+    clearInterval(this.interval);
+    this.interval = null;
+    process.stdout.write(`\r\x1b[K${finalText ? `${finalText}\n` : ''}`);
+  }
+
+  update(text) {
+    this.text = text;
+  }
+}

package/src/cli/terminal-ui.js

@@ -1,11 +1,44 @@
 const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+const ZERO_WIDTH_PATTERN = /[\u200B-\u200D\u2060\uFE0E\uFE0F]/u;
+const WIDE_CODE_POINT_RANGES = [
+  [0x1100, 0x115f],
+  [0x2329, 0x232a],
+  [0x2e80, 0x303e],
+  [0x3040, 0xa4cf],
+  [0xac00, 0xd7a3],
+  [0xf900, 0xfaff],
+  [0xfe10, 0xfe19],
+  [0xfe30, 0xfe6f],
+  [0xff00, 0xff60],
+  [0xffe0, 0xffe6],
+  [0x1f300, 0x1f64f],
+  [0x1f680, 0x1f6ff],
+  [0x1f900, 0x1f9ff],
+  [0x1fa70, 0x1faff],
+];
 
 export function stripAnsi(text) {
   return String(text ?? '').replace(ANSI_PATTERN, '');
 }
 
 export function visibleWidth(text) {
-  return Array.from(stripAnsi(text)).length;
+  let width = 0;
+  for (const char of Array.from(stripAnsi(text))) {
+    width += charDisplayWidth(char);
+  }
+  return width;
+}
+
+export function charDisplayWidth(char) {
+  if (!char || ZERO_WIDTH_PATTERN.test(char) || /\p{Mark}/u.test(char)) return 0;
+
+  const codePoint = char.codePointAt(0);
+  if (codePoint === undefined) return 0;
+  if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) return 0;
+  if (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff) return 2;
+  if (/\p{Extended_Pictographic}/u.test(char)) return 2;
+  if (WIDE_CODE_POINT_RANGES.some(([start, end]) => codePoint >= start && codePoint <= end)) return 2;
+  return 1;
 }
 
 export function terminalWidth(min = 72, max = 120, fallback = 88) {

package/src/context/compress.js

@@ -0,0 +1,71 @@
+const DEFAULT_KEEP_RECENT = 12;
+const DEFAULT_MAX_CHARS = 14000;
+
+function normalizeContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map(part => {
+      if (!part) return '';
+      if (typeof part.text === 'string') return part.text;
+      if (part.image_url?.url) return '[image]';
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+  return '';
+}
+
+function compact(value, maxChars = 700) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}...`;
+}
+
+export function estimateConversationChars(entries = []) {
+  return entries.reduce((sum, entry) => sum + normalizeContent(entry?.content).length, 0);
+}
+
+export function buildConversationSummary(entries = [], options = {}) {
+  const maxItems = Math.max(1, Number(options.maxItems || 18));
+  const maxEntryChars = Math.max(120, Number(options.maxEntryChars || 520));
+  const selected = entries.slice(-maxItems);
+
+  if (selected.length === 0) return '';
+
+  const lines = selected.map((entry, index) => {
+    const role = entry?.role || 'unknown';
+    const text = compact(normalizeContent(entry?.content), maxEntryChars);
+    return `${index + 1}. ${role}: ${text || '[empty]'}`;
+  });
+
+  return [
+    'Conversation summary generated by Winter context compression.',
+    ...lines,
+  ].join('\n');
+}
+
+export function compressConversation(entries = [], options = {}) {
+  const keepRecent = Math.max(2, Number(options.keepRecent || DEFAULT_KEEP_RECENT));
+  const maxChars = Math.max(500, Number(options.maxChars || DEFAULT_MAX_CHARS));
+  const totalChars = estimateConversationChars(entries);
+
+  if (entries.length <= keepRecent || totalChars <= maxChars) {
+    return {
+      compressed: false,
+      summary: '',
+      recent: entries,
+      omittedCount: 0,
+      totalChars,
+    };
+  }
+
+  const older = entries.slice(0, -keepRecent);
+  const recent = entries.slice(-keepRecent);
+
+  return {
+    compressed: true,
+    summary: buildConversationSummary(older, options),
+    recent,
+    omittedCount: older.length,
+    totalChars,
+  };
+}

package/src/context/priority.js

@@ -0,0 +1,115 @@
+/**
+ * Priority Scoring - Score and rank context items by importance.
+ * Determines what to keep, summarize, or drop during context management.
+ */
+
+export const PRIORITY_LEVELS = {
+  CRITICAL: 100,
+  HIGH: 75,
+  MEDIUM: 50,
+  LOW: 25,
+  TRIVIAL: 10,
+};
+
+export class PriorityScorer {
+  constructor() {
+    this.rules = [
+      // User's direct requests are highest priority
+      { test: (item) => item.role === 'user' && item.content?.length > 20, score: PRIORITY_LEVELS.CRITICAL },
+      // System instructions
+      { test: (item) => item.role === 'system', score: PRIORITY_LEVELS.HIGH },
+      // Tool results with errors
+      { test: (item) => item.role === 'tool' && item.error, score: PRIORITY_LEVELS.HIGH },
+      // File contents (long messages)
+      { test: (item) => item.content?.length > 1000, score: PRIORITY_LEVELS.MEDIUM },
+      // Normal responses
+      { test: (item) => item.role === 'assistant' && item.content?.length > 10, score: PRIORITY_LEVELS.MEDIUM },
+      // Acknowledgments
+      { test: (item) => item.content?.length < 10, score: PRIORITY_LEVELS.LOW },
+      // Default
+      { test: () => true, score: PRIORITY_LEVELS.LOW },
+    ];
+  }
+
+  /**
+   * Score a single context item.
+   */
+  score(item) {
+    for (const rule of this.rules) {
+      if (rule.test(item)) return rule.score;
+    }
+    return PRIORITY_LEVELS.LOW;
+  }
+
+  /**
+   * Score and rank all items, returning sorted array with scores.
+   */
+  rank(items) {
+    return items
+      .map(item => ({
+        item,
+        score: this.score(item),
+        length: String(item.content || '').length,
+        timestamp: item.timestamp || 0,
+      }))
+      .sort((a, b) => b.score - a.score || b.timestamp - a.timestamp);
+  }
+
+  /**
+   * Determine which items to keep based on token budget.
+   */
+  select(items, tokenBudget = 4000) {
+    const ranked = this.rank(items);
+    const selected = [];
+    let usedTokens = 0;
+
+    for (const entry of ranked) {
+      const tokens = Math.ceil(entry.length / 4); // rough token estimate
+      if (usedTokens + tokens <= tokenBudget || entry.score >= PRIORITY_LEVELS.HIGH) {
+        selected.push(entry.item);
+        usedTokens += tokens;
+      }
+    }
+
+    return {
+      selected,
+      totalItems: items.length,
+      keptItems: selected.length,
+      usedTokens,
+      budget: tokenBudget,
+      dropped: items.length - selected.length,
+    };
+  }
+
+  /**
+   * Categorize items into what to keep verbatim vs what to summarize.
+   */
+  categorize(items) {
+    const keep = [];
+    const summarize = [];
+    const drop = [];
+
+    for (const item of items) {
+      const s = this.score(item);
+      if (s >= PRIORITY_LEVELS.HIGH) {
+        keep.push(item);
+      } else if (s >= PRIORITY_LEVELS.LOW) {
+        summarize.push(item);
+      } else {
+        drop.push(item);
+      }
+    }
+
+    return { keep, summarize, drop };
+  }
+
+  /**
+   * Add custom scoring rules.
+   */
+  addRule(test, score) {
+    this.rules.unshift({ test, score });
+    return this;
+  }
+}
+
+export default PriorityScorer;

package/src/context/router.js

@@ -0,0 +1,36 @@
+function flattenMessageText(messages) {
+  return Array.isArray(messages)
+    ? messages.map(message => {
+      if (!message) return '';
+      if (typeof message.content === 'string') return message.content;
+      if (Array.isArray(message.content)) {
+        return message.content.map(part => part?.text || part?.image_url?.url || '').join('\n');
+      }
+      return '';
+    }).join('\n').toLowerCase()
+    : String(messages || '').toLowerCase();
+}
+
+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);
+  const hasProvider = name => providerNames.includes(name);
+
+  const explicitProvider = options.provider && hasProvider(options.provider) ? options.provider : null;
+  let provider = explicitProvider || (activeProvider && hasProvider(activeProvider) ? activeProvider : providerNames[0] || null);
+
+  if (explicitProvider) {
+    provider = explicitProvider;
+  } else if (/\b(review|refactor|debug|fix|bug|error|stack trace|test|tool|patch|code)\b/.test(text) && hasProvider('claude')) {
+    provider = 'claude';
+  } else if (/\b(summary|summarize|commit message|changelog|docs|explain|rewrite)\b/.test(text) && hasProvider('openai')) {
+    provider = 'openai';
+  } else if (/\b(local|offline|privacy|private|on-device)\b/.test(text) && hasProvider('ollama')) {
+    provider = 'ollama';
+  } else if (/\b(quick|brief|short|fast)\b/.test(text) && hasProvider('groq')) {
+    provider = 'groq';
+  }
+
+  const model = options.model || providers[provider]?.model || providers[activeProvider]?.model || null;
+  return { provider, model };
+}

package/src/context/selector.js

@@ -0,0 +1,145 @@
+/**
+ * Context Selector - Selects the optimal subset of context for each request.
+ * Maximizes relevant information within the context window limit.
+ */
+
+import { PriorityScorer, PRIORITY_LEVELS } from './priority.js';
+import { ContextSummarizer } from './summarizer.js';
+
+export class ContextSelector {
+  constructor(options = {}) {
+    this.scorer = new PriorityScorer();
+    this.summarizer = new ContextSummarizer();
+    this.maxTokens = options.maxTokens || 128000;
+    this.reservedTokens = options.reservedTokens || 4000; // Reserve for response
+  }
+
+  /**
+   * Select optimal context for a given request.
+   */
+  select(contexts, query, options = {}) {
+    const budget = (options.maxTokens || this.maxTokens) - this.reservedTokens;
+
+    // 1. Score all contexts
+    const ranked = this.scorer.rank(contexts);
+
+    // 2. Categorize
+    const { keep, summarize, drop } = this.scorer.categorize(ranked.map(r => r.item));
+
+    // 3. Calculate token usage
+    const keepTokens = this._estimateTokens(keep);
+    const remaining = budget - keepTokens;
+
+    if (remaining <= 0) {
+      // Keep only critical items
+      return {
+        contexts: keep.slice(0, this._fitToBudget(keep, budget)),
+        summary: null,
+        dropped: contexts.length - keep.slice(0, this._fitToBudget(keep, budget)).length,
+        strategy: 'critical-only',
+      };
+    }
+
+    // 4. Summarize medium-priority items
+    const summary = this.summarizer.summarize(summarize, {
+      maxItems: options.maxSummaryItems || 10,
+    });
+
+    const summaryTokens = this._estimateTokens([{ content: summary }]);
+
+    if (keepTokens + summaryTokens <= budget) {
+      return {
+        contexts: [...keep, { role: 'system', content: `[Summary of previous context]\n${summary}` }],
+        summary,
+        dropped: drop.length,
+        strategy: 'keep-critical-summarize-medium',
+      };
+    }
+
+    // 5. Budget exceeded - trim further
+    const trimmedKeep = this._fitToBudget(keep, budget - summaryTokens);
+    return {
+      contexts: [...trimmedKeep, { role: 'system', content: `[Summary of previous context]\n${summary}` }],
+      summary,
+      dropped: drop.length + (keep.length - trimmedKeep.length),
+      strategy: 'trimmed-keep-summarize',
+    };
+  }
+
+  /**
+   * Smart context window management - decide if compression is needed.
+   */
+  needsCompression(contexts) {
+    const totalTokens = this._estimateTokens(contexts);
+    const threshold = this.maxTokens * 0.7; // Compress at 70% capacity
+    return {
+      needsCompression: totalTokens > threshold,
+      currentTokens: totalTokens,
+      maxTokens: this.maxTokens,
+      usagePercent: ((totalTokens / this.maxTokens) * 100).toFixed(1),
+    };
+  }
+
+  /**
+   * Get priority-ordered context items for a request.
+   */
+  prioritizeForRequest(contexts, query) {
+    const queryWords = new Set(query.toLowerCase().split(/\s+/));
+    const results = [];
+
+    for (const ctx of contexts) {
+      const content = String(ctx.content || '');
+      const baseScore = this.scorer.score(ctx);
+
+      // Boost score for items relevant to the query
+      let relevanceBoost = 0;
+      for (const word of queryWords) {
+        if (word.length > 2 && content.toLowerCase().includes(word)) {
+          relevanceBoost += 5;
+        }
+      }
+
+      results.push({
+        item: ctx,
+        score: Math.min(baseScore + relevanceBoost, 100),
+        relevance: relevanceBoost > 0 ? 'high' : 'normal',
+      });
+    }
+
+    return results.sort((a, b) => b.score - a.score);
+  }
+
+  /**
+   * Estimate how many contexts will fit in a token budget.
+   */
+  _fitToBudget(items, budget) {
+    const result = [];
+    let used = 0;
+    for (const item of items) {
+      const tokens = this._estimateTokens([item]);
+      if (used + tokens <= budget) {
+        result.push(item);
+        used += tokens;
+      } else {
+        break;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Rough token estimation (4 chars per token).
+   */
+  _estimateTokens(items) {
+    let total = 0;
+    for (const item of items) {
+      const content = String(item.content || '');
+      total += Math.ceil(content.length / 4);
+      // Add overhead for role and metadata
+      total += 4;
+    }
+    return total;
+  }
+}
+
+export default ContextSelector;