scalix 1.0.0 → 1.2.0

package/dist/worktree.js

@@ -0,0 +1,172 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { logger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const WORKTREE_DIR = '.scalix/worktrees';
+const BRANCH_PREFIX = 'scalix-agent/';
+async function isGitRepo(dir) {
+    try {
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getCurrentBranch(dir) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir });
+        return stdout.trim();
+    }
+    catch {
+        return 'HEAD';
+    }
+}
+export async function createWorktree(agentId, basePath) {
+    if (!await isGitRepo(basePath)) {
+        throw new Error('Not a git repository — worktree isolation requires git');
+    }
+    const safeName = agentId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40);
+    const worktreePath = path.join(basePath, WORKTREE_DIR, safeName);
+    const branch = `${BRANCH_PREFIX}${safeName}`;
+    await fs.mkdir(path.dirname(worktreePath), { recursive: true });
+    try {
+        await execFileAsync('git', ['worktree', 'add', worktreePath, '-b', branch], {
+            cwd: basePath,
+            timeout: 30_000,
+        });
+    }
+    catch (err) {
+        await fs.rm(worktreePath, { recursive: true, force: true }).catch(() => { });
+        await execFileAsync('git', ['branch', '-D', branch], { cwd: basePath }).catch(() => { });
+        throw new Error(`Failed to create worktree: ${err.message}`);
+    }
+    logger.info('Created worktree for agent', { agentId, path: worktreePath, branch });
+    return {
+        path: worktreePath,
+        branch,
+        agentId,
+        createdAt: Date.now(),
+    };
+}
+export async function removeWorktree(info, basePath) {
+    try {
+        await execFileAsync('git', ['worktree', 'remove', info.path, '--force'], {
+            cwd: basePath,
+            timeout: 30_000,
+        });
+    }
+    catch (err) {
+        logger.warn('Failed to remove worktree via git, cleaning up manually', { error: err.message });
+        try {
+            await fs.rm(info.path, { recursive: true, force: true });
+            await execFileAsync('git', ['worktree', 'prune'], { cwd: basePath, timeout: 10_000 });
+        }
+        catch {
+            // best effort
+        }
+    }
+    try {
+        await execFileAsync('git', ['branch', '-D', info.branch], {
+            cwd: basePath,
+            timeout: 10_000,
+        });
+    }
+    catch {
+        // branch may already be deleted
+    }
+    logger.info('Removed worktree', { agentId: info.agentId, path: info.path });
+}
+export async function mergeWorktree(info, basePath, targetBranch) {
+    const target = targetBranch || await getCurrentBranch(basePath);
+    // Check if worktree has any commits beyond the branch point
+    try {
+        const { stdout: logOutput } = await execFileAsync('git', ['log', `${target}..${info.branch}`, '--oneline'], { cwd: basePath, timeout: 10_000 });
+        const commits = logOutput.trim().split('\n').filter(l => l.length > 0);
+        if (commits.length === 0) {
+            return { merged: true, commitCount: 0 };
+        }
+        try {
+            await execFileAsync('git', ['merge', info.branch, '--no-edit'], {
+                cwd: basePath,
+                timeout: 30_000,
+            });
+            return { merged: true, commitCount: commits.length };
+        }
+        catch (mergeErr) {
+            // Merge conflict — abort and report
+            try {
+                await execFileAsync('git', ['merge', '--abort'], { cwd: basePath, timeout: 10_000 });
+            }
+            catch {
+                // best effort abort
+            }
+            // Get list of conflicting files
+            const { stdout: diffOutput } = await execFileAsync('git', ['diff', '--name-only', target, info.branch], { cwd: basePath, timeout: 10_000 });
+            const conflicts = diffOutput.trim().split('\n').filter(l => l.length > 0);
+            return { merged: false, conflicts, commitCount: commits.length };
+        }
+    }
+    catch {
+        return { merged: true, commitCount: 0 };
+    }
+}
+export async function listWorktrees(basePath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], {
+            cwd: basePath,
+            timeout: 10_000,
+        });
+        const worktrees = [];
+        const entries = stdout.split('\n\n');
+        for (const entry of entries) {
+            const lines = entry.trim().split('\n');
+            const worktreeLine = lines.find(l => l.startsWith('worktree '));
+            const branchLine = lines.find(l => l.startsWith('branch '));
+            if (!worktreeLine || !branchLine)
+                continue;
+            const wtPath = worktreeLine.slice('worktree '.length);
+            const fullBranch = branchLine.slice('branch '.length);
+            const branch = fullBranch.replace('refs/heads/', '');
+            if (!branch.startsWith(BRANCH_PREFIX))
+                continue;
+            const agentId = branch.slice(BRANCH_PREFIX.length);
+            worktrees.push({
+                path: wtPath,
+                branch,
+                agentId,
+                createdAt: 0, // unknown from git porcelain
+            });
+        }
+        return worktrees;
+    }
+    catch {
+        return [];
+    }
+}
+export async function cleanupStaleWorktrees(basePath, maxAgeMs = 3600_000) {
+    const worktrees = await listWorktrees(basePath);
+    let cleaned = 0;
+    for (const wt of worktrees) {
+        try {
+            const stat = await fs.stat(wt.path);
+            if (Date.now() - stat.mtimeMs > maxAgeMs) {
+                await removeWorktree(wt, basePath);
+                cleaned++;
+            }
+        }
+        catch {
+            // worktree path doesn't exist, remove reference
+            try {
+                await execFileAsync('git', ['worktree', 'prune'], { cwd: basePath, timeout: 10_000 });
+                cleaned++;
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    return cleaned;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalix",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "AI coding agent for the terminal — edit code, run commands, and build with Scalix",
   "main": "dist/headless.js",
   "bin": {
@@ -16,6 +16,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "test:e2e": "vitest run --config vitest.config.e2e.ts",
     "check": "npm run typecheck && npm run lint && npm run test",
     "prepublishOnly": "npm run build",
     "release": "npm run build && node scripts/build-release.js"
@@ -56,18 +57,22 @@
     "ink-text-input": "^6.0.0",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "openai": "^4.73.0",
     "react": "^19.2.4",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "@types/react": "^19.2.14",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.0.0",
+    "playwright": "^1.59.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
     "vitest": "^3.0.0"
+  },
+  "optionalDependencies": {
+    "playwright": "^1.59.1"
   }
 }

package/app.py

@@ -1,55 +0,0 @@
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-
-app = Flask(__name__)
-CORS(app) # Enable CORS for all routes
-
-# In-memory storage for todos
-todos = []
-next_id = 1
-
-@app.route('/todos', methods=['GET'])
-def get_todos():
-    return jsonify(todos)
-
-@app.route('/todos', methods=['POST'])
-def add_todo():
-    global next_id
-    data = request.get_json()
-    if not data or 'task' not in data:
-        return jsonify({'error': 'Task is required'}), 400
-
-    new_todo = {
-        'id': next_id,
-        'task': data['task'],
-        'completed': data.get('completed', False)
-    }
-    todos.append(new_todo)
-    next_id += 1
-    return jsonify(new_todo), 201
-
-@app.route('/todos/<int:todo_id>', methods=['PUT'])
-def update_todo(todo_id):
-    data = request.get_json()
-    for todo in todos:
-        if todo['id'] == todo_id:
-            if 'task' in data:
-                todo['task'] = data['task']
-            if 'completed' in data:
-                todo['completed'] = data['completed']
-            return jsonify(todo)
-    return jsonify({'error': 'Todo not found'}), 404
-
-@app.route('/todos/<int:todo_id>', methods=['DELETE'])
-def delete_todo(todo_id):
-    global todos
-    initial_length = len(todos)
-    todos = [todo for todo in todos if todo['id'] != todo_id]
-    if len(todos) < initial_length:
-        return jsonify({'message': 'Todo deleted'})
-    return jsonify({'error': 'Todo not found'}), 404
-
-if __name__ == '__main__':
-    # Note: For production, use a proper WSGI server like Gunicorn.
-    # For development, Flask's built-in server is fine.
-    app.run(debug=True, port=5000) # Specify port for clarity