sid-harness 0.3.0__py3-none-any.whl

sid_harness-0.3.0.data/data/share/sid-harness/editors/vscode/extension.js

@@ -0,0 +1,395 @@
+'use strict';
+
+const vscode = require('vscode');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+let channel;
+let lspProcess = null;
+let lspBuffer = Buffer.alloc(0);
+let currentSession = null;
+let attachedSelection = '';
+
+function configuration() {
+    return vscode.workspace.getConfiguration('sid');
+}
+
+function sidCommand() {
+    return configuration().get('command') || 'sid';
+}
+
+function workspaceRoot() {
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders || folders.length === 0) {
+        throw new Error('open a folder before starting a SID session');
+    }
+    return folders[0].uri.fsPath;
+}
+
+function spawnSid(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = cp.spawn(sidCommand(), args, {
+            cwd,
+            env: process.env,
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('error', reject);
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+}
+
+function frame(message) {
+    const body = Buffer.from(JSON.stringify(message), 'utf8');
+    return Buffer.concat([
+        Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii'),
+        body,
+    ]);
+}
+
+function sendLsp(message) {
+    if (!lspProcess || !lspProcess.stdin || !lspProcess.stdin.writable) {
+        return;
+    }
+    lspProcess.stdin.write(frame(message));
+}
+
+function handleLspData(chunk) {
+    lspBuffer = Buffer.concat([lspBuffer, chunk]);
+    for (;;) {
+        const headerEnd = lspBuffer.indexOf('\r\n\r\n');
+        if (headerEnd < 0) {
+            return;
+        }
+        const header = lspBuffer.slice(0, headerEnd).toString('ascii');
+        const match = /Content-Length:\s*(\d+)/i.exec(header);
+        if (!match) {
+            lspBuffer = lspBuffer.slice(headerEnd + 4);
+            continue;
+        }
+        const length = Number(match[1]);
+        const start = headerEnd + 4;
+        if (lspBuffer.length < start + length) {
+            return;
+        }
+        const body = lspBuffer.slice(start, start + length).toString('utf8');
+        lspBuffer = lspBuffer.slice(start + length);
+        try {
+            const message = JSON.parse(body);
+            if (message.method === 'textDocument/publishDiagnostics') {
+                for (const item of (message.params && message.params.diagnostics) || []) {
+                    channel.appendLine(`[${item.source || 'sid-lsp'}] ${item.message}`);
+                }
+            }
+        } catch (error) {
+            channel.appendLine(`sid lsp: invalid message (${error.message})`);
+        }
+    }
+}
+
+function startLsp(root) {
+    if (lspProcess || !configuration().get('autoStartLsp', true)) {
+        return;
+    }
+    lspProcess = cp.spawn(sidCommand(), ['lsp', '--dir', root], {
+        cwd: root,
+        env: process.env,
+        windowsHide: true,
+    });
+    lspProcess.stdout.on('data', handleLspData);
+    lspProcess.stderr.on('data', (data) => channel.append(data.toString()));
+    lspProcess.on('error', (error) => {
+        channel.appendLine(`sid lsp failed: ${error.message}`);
+        lspProcess = null;
+    });
+    lspProcess.on('exit', () => { lspProcess = null; });
+    const rootUri = vscode.Uri.file(root).toString();
+    sendLsp({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+            processId: process.pid,
+            rootUri,
+            capabilities: {},
+            workspaceFolders: [{ uri: rootUri, name: path.basename(root) }],
+        },
+    });
+    sendLsp({ jsonrpc: '2.0', method: 'initialized', params: {} });
+}
+
+function stopLsp() {
+    if (!lspProcess) {
+        return;
+    }
+    const child = lspProcess;
+    sendLsp({ jsonrpc: '2.0', id: 2, method: 'shutdown' });
+    setTimeout(() => {
+        try { child.kill(); } catch (error) { channel.appendLine(`sid lsp: ${error.message}`); }
+    }, 250);
+    lspProcess = null;
+}
+
+function syncDocument(document) {
+    sendLsp({
+        jsonrpc: '2.0',
+        method: 'textDocument/didOpen',
+        params: {
+            textDocument: {
+                uri: document.uri.toString(),
+                languageId: document.languageId,
+                version: document.version,
+                text: document.getText(),
+            },
+        },
+    });
+}
+
+function changeDocument(event) {
+    sendLsp({
+        jsonrpc: '2.0',
+        method: 'textDocument/didChange',
+        params: {
+            textDocument: {
+                uri: event.document.uri.toString(),
+                version: event.document.version,
+            },
+            contentChanges: [{ text: event.document.getText() }],
+        },
+    });
+}
+
+function saveDocument(document) {
+    sendLsp({
+        jsonrpc: '2.0',
+        method: 'textDocument/didSave',
+        params: {
+            textDocument: { uri: document.uri.toString() },
+            text: document.getText(),
+        },
+    });
+    forwardDiagnostics();
+}
+
+function forwardDiagnostics() {
+    const diagnostics = [];
+    for (const [uri, entries] of vscode.languages.getDiagnostics()) {
+        for (const entry of entries) {
+            diagnostics.push({
+                uri: uri.toString(),
+                line: entry.range.start.line,
+                character: entry.range.start.character,
+                end_line: entry.range.end.line,
+                end_character: entry.range.end.character,
+                severity: entry.severity,
+                message: entry.message,
+                source: entry.source || 'vscode',
+            });
+        }
+    }
+    sendLsp({ jsonrpc: '2.0', method: 'sid/diagnostics', params: { diagnostics } });
+}
+
+function selectionContext() {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+        return '';
+    }
+    const selection = editor.selection;
+    if (selection.isEmpty) {
+        return '';
+    }
+    const text = editor.document.getText(selection);
+    if (!text.trim()) {
+        return '';
+    }
+    const rel = vscode.workspace.asRelativePath(editor.document.uri, false);
+    return `\n\n[Editor selection: ${rel} lines ${selection.start.line + 1}-${selection.end.line + 1}]\n${text}\n[/Editor selection]`;
+}
+
+function attachSelection() {
+    const block = selectionContext();
+    if (!block) {
+        vscode.window.showInformationMessage('SID: select text in the editor first.');
+        return;
+    }
+    attachedSelection = block;
+    vscode.window.showInformationMessage(`SID: selection attached (${block.length} char(s)); the next session includes it.`);
+}
+
+function pushDiagnostics() {
+    forwardDiagnostics();
+    vscode.window.showInformationMessage('SID: editor diagnostics pushed to the session feed.');
+}
+
+async function openSession() {
+    let root;
+    try {
+        root = workspaceRoot();
+    } catch (error) {
+        vscode.window.showErrorMessage(`SID: ${error.message}`);
+        return;
+    }
+    const task = await vscode.window.showInputBox({
+        prompt: 'SID task',
+        placeHolder: 'Describe the change; the current selection is attached automatically.',
+        ignoreFocusOut: true,
+    });
+    if (!task) {
+        return;
+    }
+    const context = attachedSelection || selectionContext();
+    attachedSelection = '';
+    const args = ['session', 'start', '--task', task + context, '--dir', root, '--json', '--quiet'];
+    const baseUrl = configuration().get('baseUrl');
+    if (baseUrl) {
+        args.push('--base-url', baseUrl);
+    }
+    const model = configuration().get('model');
+    if (model) {
+        args.push('--model', model);
+    }
+    const testCommand = configuration().get('testCommand');
+    if (testCommand) {
+        args.push('--test-cmd', testCommand);
+    }
+    if (!configuration().get('includeDiagnostics', true)) {
+        args.push('--no-diagnostics');
+    }
+    channel.show(true);
+    channel.appendLine(`sid session start in ${root}`);
+    let result;
+    try {
+        result = await spawnSid(args, root);
+    } catch (error) {
+        vscode.window.showErrorMessage(`SID: could not start ${sidCommand()}: ${error.message}`);
+        return;
+    }
+    if (result.stderr) {
+        channel.append(result.stderr);
+    }
+    if (result.code !== 0) {
+        vscode.window.showErrorMessage(`SID session failed (exit ${result.code}): ${result.stderr.trim() || 'no stderr'}`);
+        return;
+    }
+    try {
+        currentSession = JSON.parse(result.stdout);
+    } catch (error) {
+        vscode.window.showErrorMessage(`SID: session output was not a receipt (${error.message}).`);
+        return;
+    }
+    const changed = currentSession.changed || [];
+    channel.appendLine(`sid session: ${changed.length} file(s) changed`);
+    const choice = await vscode.window.showInformationMessage(
+        `SID session complete: ${changed.length} file(s) changed.`,
+        'Show diff',
+        'Approve and apply'
+    );
+    if (choice === 'Show diff') {
+        await showDiff();
+    } else if (choice === 'Approve and apply') {
+        await applyApproved();
+    }
+}
+
+async function showDiff() {
+    if (!currentSession) {
+        vscode.window.showInformationMessage('SID: run a session first.');
+        return;
+    }
+    const content = currentSession.diff || 'No changes were proposed.';
+    const document = await vscode.workspace.openTextDocument({ content, language: 'diff' });
+    await vscode.window.showTextDocument(document, { preview: true });
+}
+
+async function applyApproved() {
+    if (!currentSession) {
+        vscode.window.showInformationMessage('SID: run a session first.');
+        return;
+    }
+    const changed = currentSession.changed || [];
+    if (changed.length === 0) {
+        vscode.window.showInformationMessage('SID: this run proposed no changes.');
+        return;
+    }
+    let root;
+    try {
+        root = workspaceRoot();
+    } catch (error) {
+        vscode.window.showErrorMessage(`SID: ${error.message}`);
+        return;
+    }
+    const receiptPath = path.join(root, '.sid', 'runs', `${currentSession.run_id}.json`);
+    if (!fs.existsSync(receiptPath)) {
+        vscode.window.showErrorMessage(`SID: receipt not found at ${receiptPath}`);
+        return;
+    }
+    const choice = await vscode.window.showWarningMessage(
+        `Apply SID changes to ${changed.length} file(s)?`,
+        { modal: true, detail: changed.join('\n') },
+        'Apply'
+    );
+    if (choice !== 'Apply') {
+        return;
+    }
+    let result;
+    try {
+        result = await spawnSid(
+            ['apply', '--dir', root, '--receipt', receiptPath, '--approve', '--json'],
+            root
+        );
+    } catch (error) {
+        vscode.window.showErrorMessage(`SID: apply failed: ${error.message}`);
+        return;
+    }
+    if (result.code !== 0) {
+        vscode.window.showErrorMessage(`SID apply refused: ${result.stderr.trim() || result.stdout.trim()}`);
+        return;
+    }
+    let summary;
+    try {
+        summary = JSON.parse(result.stdout);
+    } catch (error) {
+        summary = { applied: changed, status: 'applied' };
+    }
+    const applied = summary.applied || [];
+    vscode.window.showInformationMessage(`SID: applied ${applied.length} file(s).`);
+}
+
+function activate(context) {
+    channel = vscode.window.createOutputChannel('SID');
+    context.subscriptions.push(channel);
+    context.subscriptions.push(
+        vscode.commands.registerCommand('sid.openSession', openSession),
+        vscode.commands.registerCommand('sid.showDiff', showDiff),
+        vscode.commands.registerCommand('sid.applyApproved', applyApproved),
+        vscode.commands.registerCommand('sid.attachSelection', attachSelection),
+        vscode.commands.registerCommand('sid.sendDiagnostics', pushDiagnostics),
+        vscode.workspace.onDidOpenTextDocument(syncDocument),
+        vscode.workspace.onDidChangeTextDocument(changeDocument),
+        vscode.workspace.onDidSaveTextDocument(saveDocument),
+        vscode.languages.onDidChangeDiagnostics(forwardDiagnostics),
+        vscode.workspace.onDidChangeWorkspaceFolders(() => {
+            stopLsp();
+            try { startLsp(workspaceRoot()); } catch (error) { channel.appendLine(`sid lsp: ${error.message}`); }
+        }),
+        { dispose: stopLsp }
+    );
+    let root = null;
+    try { root = workspaceRoot(); } catch (error) { root = null; }
+    if (root) {
+        startLsp(root);
+        vscode.workspace.textDocuments.forEach(syncDocument);
+        forwardDiagnostics();
+    }
+}
+
+function deactivate() {
+    stopLsp();
+}
+
+module.exports = { activate, deactivate };

sid_harness-0.3.0.data/data/share/sid-harness/editors/vscode/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "sid-harness",
+  "displayName": "SID Harness",
+  "description": "Drive SID's first-party coding loop from VS Code: sessions, diffs, approve/apply, selection context, and compiler diagnostics.",
+  "publisher": "sid",
+  "version": "0.1.0",
+  "license": "UNLICENSED",
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Other"
+  ],
+  "keywords": [
+    "sid",
+    "coding-agent",
+    "lsp",
+    "diagnostics"
+  ],
+  "activationEvents": [
+    "onStartupFinished",
+    "onCommand:sid.openSession",
+    "onCommand:sid.showDiff",
+    "onCommand:sid.applyApproved",
+    "onCommand:sid.attachSelection",
+    "onCommand:sid.sendDiagnostics"
+  ],
+  "main": "./extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "sid.openSession",
+        "title": "SID: Open Coding Session",
+        "category": "SID"
+      },
+      {
+        "command": "sid.showDiff",
+        "title": "SID: Show Proposed Diff",
+        "category": "SID"
+      },
+      {
+        "command": "sid.applyApproved",
+        "title": "SID: Approve and Apply",
+        "category": "SID"
+      },
+      {
+        "command": "sid.attachSelection",
+        "title": "SID: Attach Selection as Context",
+        "category": "SID"
+      },
+      {
+        "command": "sid.sendDiagnostics",
+        "title": "SID: Push Diagnostics to Session",
+        "category": "SID"
+      }
+    ],
+    "menus": {
+      "editor/context": [
+        {
+          "command": "sid.attachSelection",
+          "when": "editorHasSelection",
+          "group": "navigation@9"
+        }
+      ],
+      "commandPalette": [
+        {
+          "command": "sid.openSession"
+        },
+        {
+          "command": "sid.showDiff"
+        },
+        {
+          "command": "sid.applyApproved"
+        },
+        {
+          "command": "sid.attachSelection"
+        },
+        {
+          "command": "sid.sendDiagnostics"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "SID",
+      "properties": {
+        "sid.command": {
+          "type": "string",
+          "default": "sid",
+          "description": "The SID harness executable (env inherited, so SID_API_KEY applies)."
+        },
+        "sid.baseUrl": {
+          "type": "string",
+          "default": "",
+          "description": "Optional SID /v1 base URL; leave empty to use the harness default."
+        },
+        "sid.model": {
+          "type": "string",
+          "default": "auto",
+          "description": "Model id or 'auto' (SID routes it)."
+        },
+        "sid.testCommand": {
+          "type": "string",
+          "default": "",
+          "description": "Optional approved test command (executed as an argv list by the harness)."
+        },
+        "sid.autoStartLsp": {
+          "type": "boolean",
+          "default": true,
+          "description": "Start 'sid lsp' for this workspace and feed diagnostics into the loop."
+        },
+        "sid.includeDiagnostics": {
+          "type": "boolean",
+          "default": true,
+          "description": "Include the editor/LSP diagnostics feed in each SID session."
+        }
+      }
+    }
+  }
+}