winter-super-cli 2026.6.21 → 2026.6.23

package/extensions/vscode/src/extension.js

@@ -0,0 +1,382 @@
+/**
+ * ❄️ Winter CLI VS Code Extension ❄️
+ * Connects VS Code to Winter CLI's MCP server for inline AI features:
+ * - Inline completions
+ * - Code chat
+ * - Code review/refactor/fix
+ * - Test generation
+ */
+
+const vscode = require('vscode');
+
+const SERVER_PORT = 4157;
+const SERVER_HOST = '127.0.0.1';
+
+let outputChannel = null;
+let statusBarItem = null;
+
+/**
+ * Activate the extension.
+ * @param {vscode.ExtensionContext} context
+ */
+function activate(context) {
+  outputChannel = vscode.window.createOutputChannel('Winter CLI');
+  outputChannel.appendLine('❄️ Winter CLI extension activated');
+
+  // Status bar
+  statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+  statusBarItem.text = '❄️ Winter';
+  statusBarItem.command = 'winter.startChat';
+  statusBarItem.tooltip = 'Winter AI — Click to chat';
+  statusBarItem.show();
+  context.subscriptions.push(statusBarItem);
+
+  // Register all commands
+  const commands = [
+    vscode.commands.registerCommand('winter.startChat', () => startChat()),
+    vscode.commands.registerCommand('winter.inlineCompletion', () => triggerInlineCompletion()),
+    vscode.commands.registerCommand('winter.explainCode', () => performAction('explain')),
+    vscode.commands.registerCommand('winter.refactorCode', () => performAction('refactor')),
+    vscode.commands.registerCommand('winter.fixCode', () => performAction('fix')),
+    vscode.commands.registerCommand('winter.generateTests', () => generateTests()),
+    vscode.commands.registerCommand('winter.openTerminal', () => openTerminal()),
+    vscode.commands.registerCommand('winter.codeReview', () => codeReview()),
+  ];
+
+  commands.forEach(cmd => context.subscriptions.push(cmd));
+
+  // Check if Winter CLI is running
+  checkWinterRunning();
+}
+
+/**
+ * Deactivate the extension.
+ */
+function deactivate() {
+  if (outputChannel) {
+    outputChannel.appendLine('❄️ Winter CLI extension deactivated');
+  }
+}
+
+/**
+ * Check if the Winter CLI MCP server is running.
+ */
+async function checkWinterRunning() {
+  try {
+    const connected = await sendMessage({ type: 'ping' });
+    if (connected) {
+      statusBarItem.text = '❄️ Winter';
+      statusBarItem.backgroundColor = undefined;
+    } else {
+      statusBarItem.text = '❄️ Winter (offline)';
+      statusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+    }
+  } catch {
+    statusBarItem.text = '❄️ Winter (offline)';
+    statusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+  }
+}
+
+/**
+ * Start a chat session.
+ * Opens a webview panel or uses the integrated terminal.
+ */
+async function startChat() {
+  const terminal = vscode.window.createTerminal('Winter CLI');
+  terminal.show();
+  terminal.sendText('winter');
+}
+
+/**
+ * Trigger inline completion at cursor position.
+ */
+async function triggerInlineCompletion() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showInformationMessage('No active editor');
+    return;
+  }
+
+  const document = editor.document;
+  const filePath = document.uri.fsPath;
+  const position = editor.selection.active;
+  const line = position.line + 1; // 1-based
+  const column = position.character;
+
+  vscode.window.withProgress(
+    { location: vscode.ProgressLocation.Window, title: 'Winter: Generating completions...' },
+    async () => {
+      try {
+        const result = await sendMessage({
+          type: 'inline:complete',
+          path: filePath,
+          line,
+          column,
+        });
+
+        if (result && result.completions && result.completions.length > 0) {
+          const best = result.completions[0];
+          editor.edit(editBuilder => {
+            editBuilder.insert(position, best.text);
+          });
+          vscode.window.setStatusBarMessage(`❄️ Inserted: ${best.text.substring(0, 30)}...`, 3000);
+        } else {
+          vscode.window.showInformationMessage('No completions available');
+        }
+      } catch (err) {
+        vscode.window.showErrorMessage(`Winter: ${err.message}`);
+      }
+    }
+  );
+}
+
+/**
+ * Perform an AI action on selected code (explain/refactor/fix).
+ */
+async function performAction(action) {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showInformationMessage('No active editor');
+    return;
+  }
+
+  const selection = editor.selection;
+  const selectedText = editor.document.getText(selection);
+
+  if (!selectedText) {
+    vscode.window.showInformationMessage('No code selected');
+    return;
+  }
+
+  const actions = {
+    explain: { title: 'Explain Code', prompt: `Explain this code:\n\n${selectedText}` },
+    refactor: { title: 'Refactor Code', prompt: `Refactor this code:\n\n${selectedText}` },
+    fix: { title: 'Fix Code', prompt: `Find and fix bugs in this code:\n\n${selectedText}` },
+  };
+
+  const actionConfig = actions[action];
+  if (!actionConfig) return;
+
+  vscode.window.withProgress(
+    { location: vscode.ProgressLocation.Window, title: `Winter: ${actionConfig.title}...` },
+    async () => {
+      try {
+        const result = await sendMessage({
+          type: 'ai:action',
+          action,
+          code: selectedText,
+          filePath: editor.document.uri.fsPath,
+        });
+
+        if (result && result.response) {
+          // Show result in output channel
+          outputChannel.clear();
+          outputChannel.appendLine(`❄️ ${actionConfig.title}`);
+          outputChannel.appendLine('─'.repeat(50));
+          outputChannel.appendLine(result.response);
+          outputChannel.show();
+
+          // If it's a refactor/fix, offer to apply changes
+          if ((action === 'refactor' || action === 'fix') && result.editedContent) {
+            const apply = await vscode.window.showInformationMessage(
+              'Winter has suggestions. Apply changes?',
+              'Yes', 'No', 'Preview'
+            );
+            if (apply === 'Yes') {
+              await editor.edit(editBuilder => {
+                editBuilder.replace(selection, result.editedContent);
+              });
+              vscode.window.showInformationMessage('Applied!');
+            } else if (apply === 'Preview') {
+              // Show diff
+              vscode.commands.executeCommand('vscode.diff',
+                editor.document.uri,
+                vscode.Uri.parse(`untitled:${editor.document.fileName}.winter`),
+                'Original ↔ Winter'
+              );
+            }
+          }
+        } else {
+          vscode.window.showInformationMessage('No response from Winter');
+        }
+      } catch (err) {
+        vscode.window.showErrorMessage(`Winter: ${err.message}`);
+      }
+    }
+  );
+}
+
+/**
+ * Generate tests for the current file.
+ */
+async function generateTests() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showInformationMessage('No active editor');
+    return;
+  }
+
+  const filePath = editor.document.uri.fsPath;
+  const content = editor.document.getText();
+
+  vscode.window.withProgress(
+    { location: vscode.ProgressLocation.Window, title: 'Winter: Generating tests...' },
+    async () => {
+      try {
+        const result = await sendMessage({
+          type: 'ai:action',
+          action: 'generate-tests',
+          code: content,
+          filePath,
+        });
+
+        if (result && result.response) {
+          outputChannel.clear();
+          outputChannel.appendLine('❄️ Generated Tests');
+          outputChannel.appendLine('─'.repeat(50));
+          outputChannel.appendLine(result.response);
+          outputChannel.show();
+
+          const createFile = await vscode.window.showInformationMessage(
+            'Create test file with generated tests?',
+            'Create', 'Cancel'
+          );
+          if (createFile === 'Create' && result.editedContent) {
+            const testPath = filePath.replace(/\.(\w+)$/, '.test.$1');
+            const uri = vscode.Uri.file(testPath);
+            await vscode.workspace.fs.writeFile(uri, Buffer.from(result.editedContent, 'utf8'));
+            vscode.window.showInformationMessage(`Created: ${testPath}`);
+          }
+        }
+      } catch (err) {
+        vscode.window.showErrorMessage(`Winter: ${err.message}`);
+      }
+    }
+  );
+}
+
+/**
+ * Open Winter CLI in a terminal.
+ */
+function openTerminal() {
+  const terminal = vscode.window.createTerminal('Winter CLI');
+  terminal.show();
+  terminal.sendText('winter');
+}
+
+/**
+ * Code review of the current file.
+ */
+async function codeReview() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showInformationMessage('No active editor');
+    return;
+  }
+
+  const filePath = editor.document.uri.fsPath;
+  const content = editor.document.getText();
+
+  vscode.window.withProgress(
+    { location: vscode.ProgressLocation.Window, title: 'Winter: Reviewing code...' },
+    async () => {
+      try {
+        const result = await sendMessage({
+          type: 'ai:action',
+          action: 'review',
+          code: content,
+          filePath,
+        });
+
+        if (result && result.response) {
+          // Show diagnostics
+          const diagnostics = [];
+          if (result.diagnostics) {
+            for (const d of result.diagnostics) {
+              const range = new vscode.Range(
+                new vscode.Position(d.line - 1, d.column || 0),
+                new vscode.Position(d.line - 1, (d.endColumn || d.column || 0) + 50)
+              );
+              diagnostics.push(new vscode.Diagnostic(
+                range,
+                d.message,
+                d.severity === 'error' ? vscode.DiagnosticSeverity.Error :
+                d.severity === 'warning' ? vscode.DiagnosticSeverity.Warning :
+                vscode.DiagnosticSeverity.Information
+              ));
+            }
+          }
+
+          if (diagnostics.length > 0) {
+            const diagnosticCollection = vscode.languages.createDiagnosticCollection('winter');
+            diagnosticCollection.set(editor.document.uri, diagnostics);
+            setTimeout(() => diagnosticCollection.clear(), 30000);
+          }
+
+          outputChannel.clear();
+          outputChannel.appendLine('❄️ Code Review');
+          outputChannel.appendLine('─'.repeat(50));
+          outputChannel.appendLine(result.response);
+          outputChannel.show();
+        }
+      } catch (err) {
+        vscode.window.showErrorMessage(`Winter: ${err.message}`);
+      }
+    }
+  );
+}
+
+/**
+ * Send a JSON message to the Winter MCP server.
+ * Returns parsed response or null.
+ */
+function sendMessage(message) {
+  return new Promise((resolve, reject) => {
+    const net = require('net');
+
+    const client = new net.Socket();
+    const timeout = setTimeout(() => {
+      client.destroy();
+      reject(new Error('Connection timed out. Is Winter running? (winter --mcp)'));
+    }, 5000);
+
+    let responseData = '';
+
+    client.connect(SERVER_PORT, SERVER_HOST, () => {
+      client.write(JSON.stringify(message) + '\n');
+    });
+
+    client.on('data', (data) => {
+      responseData += data.toString();
+      try {
+        const response = JSON.parse(responseData);
+        clearTimeout(timeout);
+        client.destroy();
+        resolve(response);
+      } catch {
+        // Incomplete JSON, wait for more data
+      }
+    });
+
+    client.on('error', (err) => {
+      clearTimeout(timeout);
+      client.destroy();
+      reject(new Error(`Cannot connect to Winter MCP server on ${SERVER_HOST}:${SERVER_PORT}. Start Winter with 'winter --mcp' first.`));
+    });
+
+    client.on('close', () => {
+      clearTimeout(timeout);
+      if (responseData) {
+        try {
+          resolve(JSON.parse(responseData));
+        } catch {
+          reject(new Error('Invalid response from Winter MCP server'));
+        }
+      } else {
+        reject(new Error('Connection closed without response'));
+      }
+    });
+  });
+}
+
+module.exports = { activate, deactivate };

package/memories/readme.md

@@ -0,0 +1,35 @@
+# ❄️ Winter Memories
+
+This directory stores cross-project knowledge and learnings.
+
+## Memory Types
+
+### Long-term Memory
+Learned patterns, best practices, and project insights that persist across sessions.
+
+### Project Memory
+Project-specific knowledge including:
+- Project structure
+- Key files and their purposes
+- Common workflows
+- Team conventions
+
+## Commands
+
+- `/remember <text>` - Add a memory
+- `/memories` - Show all memories
+- `/memories search <query>` - Search memories
+- `/forget <pattern>` - Remove memories
+
+## Example Memories
+
+```
+- User prefers TypeScript over JavaScript
+- This project uses React with Vite
+- Database is PostgreSQL
+- API is REST-based
+```
+
+## Storage
+
+Memories are stored as JSON files in this directory, automatically organized by date and topic.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.6.21",
+  "version": "2026.6.23",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",
@@ -10,18 +10,39 @@
   },
   "files": [
     "bin/",
+    "docs/",
+    "extensions/vscode/",
+    "!extensions/vscode/node_modules/**",
+    "!extensions/vscode/*.vsix",
+    "rules/",
     "scripts/audit-pack.js",
     "scripts/smoke-package.js",
     "scripts/prepublish-gate.js",
     "src/**/*.js",
     "!src/**/*.test.js",
     "resources/local/manifest.json",
+    "resources/local/agents.md/",
+    "resources/local/awesome-design-md/",
+    "resources/local/codex/AGENTS.md",
+    "resources/local/codex/models_cache.json",
+    "resources/local/codex/plugins/",
+    "resources/local/codex/rules/",
+    "resources/local/codex/skills/",
+    "resources/local/claude/plugins/",
+    "resources/local/claude/skills/",
+    "resources/local/karpathy-tools/",
     "resources/local/page-agent/",
     "resources/local/ecc/",
     "!resources/local/ecc/node_modules/**",
     "!resources/local/ecc/package-lock.json",
+    "skills/",
+    "memories/",
     "README.md",
     "WINTER.md",
+    "CLAUDE.md",
+    "design.md",
+    "skill.md",
+    "rule.md",
     "CHANGELOG.md",
     "winter.d.ts"
   ],

package/resources/local/agents.md/AGENTS.md

@@ -0,0 +1,43 @@
+# AGENTS Guidelines for This Repository
+
+This repository contains a Next.js application located in the root of this repository. When
+working on the project interactively with an agent (e.g. the Codex CLI) please follow
+the guidelines below so that the development experience – in particular Hot Module
+Replacement (HMR) – continues to work smoothly.
+
+## 1. Use the Development Server, **not** `npm run build`
+
+* **Always use `npm run dev` (or `pnpm dev`, `yarn dev`, etc.)** while iterating on the
+  application.  This starts Next.js in development mode with hot-reload enabled.
+* **Do _not_ run `npm run build` inside the agent session.**  Running the production
+  build command switches the `.next` folder to production assets which disables hot
+  reload and can leave the development server in an inconsistent state.  If a
+  production build is required, do it outside of the interactive agent workflow.
+
+## 2. Keep Dependencies in Sync
+
+If you add or update dependencies remember to:
+
+1. Update the appropriate lockfile (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`).
+2. Re-start the development server so that Next.js picks up the changes.
+
+## 3. Coding Conventions
+
+* Prefer TypeScript (`.tsx`/`.ts`) for new components and utilities.
+* Co-locate component-specific styles in the same folder as the component when
+  practical.
+
+## 4. Useful Commands Recap
+
+| Command            | Purpose                                            |
+| ------------------ | -------------------------------------------------- |
+| `npm run dev`      | Start the Next.js dev server with HMR.             |
+| `npm run lint`     | Run ESLint checks.                                 |
+| `npm run test`     | Execute the test suite (if present).               |
+| `npm run build`    | **Production build – _do not run during agent sessions_** |
+
+---
+
+Following these practices ensures that the agent-assisted development workflow stays
+fast and dependable.  When in doubt, restart the dev server rather than running the
+production build.

package/resources/local/agents.md/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/resources/local/agents.md/README.md

@@ -0,0 +1,49 @@
+# AGENTS.md
+
+![AGENTS.md logo](./public/og.png)
+
+[AGENTS.md](https://agents.md) is a simple, open format for guiding coding agents.
+
+Think of AGENTS.md as a README for agents: a dedicated, predictable place
+to provide context and instructions to help AI coding agents work on your project.
+
+Below is a minimal example of an AGENTS.md file:
+
+```markdown
+# Sample AGENTS.md file
+
+## Dev environment tips
+- Use `pnpm dlx turbo run where <project_name>` to jump to a package instead of scanning with `ls`.
+- Run `pnpm install --filter <project_name>` to add the package to your workspace so Vite, ESLint, and TypeScript can see it.
+- Use `pnpm create vite@latest <project_name> -- --template react-ts` to spin up a new React + Vite package with TypeScript checks ready.
+- Check the name field inside each package's package.json to confirm the right name—skip the top-level one.
+
+## Testing instructions
+- Find the CI plan in the .github/workflows folder.
+- Run `pnpm turbo run test --filter <project_name>` to run every check defined for that package.
+- From the package root you can just call `pnpm test`. The commit should pass all tests before you merge.
+- To focus on one step, add the Vitest pattern: `pnpm vitest run -t "<test name>"`.
+- Fix any test or type errors until the whole suite is green.
+- After moving files or changing imports, run `pnpm lint --filter <project_name>` to be sure ESLint and TypeScript rules still pass.
+- Add or update tests for the code you change, even if nobody asked.
+
+## PR instructions
+- Title format: [<project_name>] <Title>
+- Always run `pnpm lint` and `pnpm test` before committing.
+```
+
+## Website
+
+This repository also includes a basic Next.js website hosted at https://agents.md/
+that explains the project’s goals in a simple way, and featuring some examples.
+
+### Running the app locally
+1. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+2. Start the development server:
+   ```bash
+   pnpm run dev
+   ```
+3. Open your browser and go to http://localhost:3000

package/resources/local/agents.md/components/AboutSection.tsx

@@ -0,0 +1,37 @@
+import Section from "@/components/Section";
+
+const AboutSection = () => (
+  <Section title="About" className="pb-0" center maxWidthClass="max-w-3xl">
+    <p className="max-w-3xl">
+      AGENTS.md emerged from collaborative efforts across the AI software
+      development ecosystem, including{" "}
+      <a href="https://openai.com/codex/" className="underline hover:no-underline" target="_blank" rel="noopener noreferrer">OpenAI Codex</a>,{" "}
+      <a href="https://ampcode.com" className="underline hover:no-underline" target="_blank" rel="noopener noreferrer">Amp</a>,{" "}
+      <a href="https://jules.google" className="underline hover:no-underline" target="_blank" rel="noopener noreferrer">Jules from Google</a>,{" "}
+      <a href="https://cursor.com" className="underline hover:no-underline" target="_blank" rel="noopener noreferrer">Cursor</a>, and{" "}
+      <a href="https://factory.ai" className="underline hover:no-underline" target="_blank" rel="noopener noreferrer">Factory</a>.
+    </p>
+
+    <p className="max-w-3xl mt-4">
+      We&rsquo;re committed to helping maintain and evolve this as an open format that benefits the entire developer community,
+      regardless of which coding agent you use.
+    </p>
+
+    <p className="max-w-3xl mt-4">
+      AGENTS.md is now stewarded by the{" "}
+      <a href="https://aaif.io" className="underline hover:no-underline">
+        Agentic AI Foundation
+      </a>{" "}
+      under the Linux Foundation.{" "}
+      <a
+        href="https://openai.com/index/agentic-ai-foundation/"
+        className="underline hover:no-underline"
+      >
+        Learn more &rarr;
+      </a>
+    </p>
+
+  </Section>
+);
+
+export default AboutSection;