codymaster 5.2.0 → 7.0.1

package/dist/agent/copilot.js

@@ -0,0 +1,284 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotBackend = void 0;
+const child_process_1 = require("child_process");
+const child_process_2 = require("child_process");
+class AsyncIterableEmitter {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    emit(value) {
+        if (this.done)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+function spawnTextProcess(opts) {
+    var _a;
+    const mergedEnv = Object.assign(Object.assign({}, process.env), opts.env);
+    const child = (0, child_process_1.spawn)(opts.command, opts.args, {
+        cwd: opts.cwd,
+        env: mergedEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true,
+    });
+    const pgid = (_a = child.pid) !== null && _a !== void 0 ? _a : 0;
+    const emitter = new AsyncIterableEmitter();
+    const stderrLines = [];
+    let lastMessageTime = Date.now();
+    let inactivityTimer;
+    let timeoutTimer;
+    function clearTimers() {
+        if (inactivityTimer)
+            clearTimeout(inactivityTimer);
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+    }
+    function killProcess() {
+        clearTimers();
+        return new Promise((resolve) => {
+            try {
+                if (pgid > 0) {
+                    process.kill(-pgid, 'SIGKILL');
+                }
+                else if (child.pid) {
+                    child.kill('SIGKILL');
+                }
+            }
+            catch (_a) {
+                // process may already be dead
+            }
+            resolve();
+        });
+    }
+    if (opts.timeoutMs) {
+        timeoutTimer = setTimeout(() => {
+            killProcess();
+        }, opts.timeoutMs);
+    }
+    function resetInactivityWatchdog() {
+        if (inactivityTimer)
+            clearTimeout(inactivityTimer);
+        if (!opts.semanticInactivityMs)
+            return;
+        inactivityTimer = setTimeout(() => {
+            const elapsed = Date.now() - lastMessageTime;
+            if (elapsed >= opts.semanticInactivityMs) {
+                killProcess();
+            }
+        }, opts.semanticInactivityMs);
+    }
+    resetInactivityWatchdog();
+    // stdout: emit each line as a text message
+    let stdoutBuffer = '';
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk.toString('utf8');
+        const lines = stdoutBuffer.split('\n');
+        stdoutBuffer = lines.pop();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            lastMessageTime = Date.now();
+            emitter.emit({ type: 'text', content: trimmed });
+        }
+    });
+    // stderr: collect lines
+    let stderrBuffer = '';
+    child.stderr.on('data', (chunk) => {
+        stderrBuffer += chunk.toString('utf8');
+        const lines = stderrBuffer.split('\n');
+        stderrBuffer = lines.pop();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed)
+                stderrLines.push(trimmed);
+        }
+    });
+    child.on('exit', () => {
+        clearTimers();
+        emitter.close();
+    });
+    child.on('error', () => {
+        clearTimers();
+        emitter.close();
+    });
+    function cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            clearTimers();
+            try {
+                if (pgid > 0) {
+                    process.kill(-pgid, 'SIGTERM');
+                }
+                else if (child.pid) {
+                    child.kill('SIGTERM');
+                }
+            }
+            catch (_a) {
+                return;
+            }
+            yield new Promise((resolve) => {
+                const graceTimer = setTimeout(() => {
+                    try {
+                        if (pgid > 0) {
+                            process.kill(-pgid, 'SIGKILL');
+                        }
+                        else if (child.pid) {
+                            child.kill('SIGKILL');
+                        }
+                    }
+                    catch (_a) {
+                        // ignore
+                    }
+                    resolve();
+                }, 5000);
+                child.on('exit', () => {
+                    clearTimeout(graceTimer);
+                    resolve();
+                });
+            });
+        });
+    }
+    return { child, messages: emitter, cancel };
+}
+function collectResult(proc) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        let resultText = '';
+        let status = 'completed';
+        let errorText;
+        const stderrLines = [];
+        proc.child.stderr.on('data', (chunk) => {
+            stderrLines.push(chunk.toString('utf8'));
+        });
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                try {
+                    for (var _d = true, _e = __asyncValues(proc.messages), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const msg = _c;
+                        if (msg.type === 'text') {
+                            resultText += (resultText ? '\n' : '') + msg.content;
+                        }
+                        else if (msg.type === 'error') {
+                            status = 'failed';
+                            errorText = msg.content;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (err) {
+                status = 'failed';
+                errorText = err instanceof Error ? err.message : String(err);
+            }
+            proc.child.on('exit', (code) => {
+                if (status === 'completed' && code !== 0) {
+                    status = 'failed';
+                    const stderr = stderrLines.join('');
+                    errorText = stderr || `Process exited with code ${code}`;
+                }
+                resolve({
+                    status,
+                    output: resultText,
+                    error: errorText,
+                    durationMs: Date.now() - start,
+                });
+            });
+        }))();
+    });
+}
+class CopilotBackend {
+    constructor() {
+        this.name = 'copilot';
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (0, child_process_2.execFileSync)('copilot', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                }).trim();
+            }
+            catch (_a) {
+                return 'unknown';
+            }
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['-p', prompt];
+            if (opts.model)
+                args.push('--model', opts.model);
+            if (opts.customArgs)
+                args.push(...opts.customArgs);
+            const proc = spawnTextProcess({
+                command: 'copilot',
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+                semanticInactivityMs: opts.semanticInactivityMs,
+            });
+            return {
+                messages: proc.messages,
+                result: collectResult(proc),
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.CopilotBackend = CopilotBackend;

package/dist/agent/cursor.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorBackend = void 0;
+const spawn_helper_1 = require("./spawn-helper");
+const NAME = 'cursor';
+function transformStdoutLines(child, emit) {
+    return new Promise((resolve) => {
+        var _a, _b, _c;
+        let buffer = '';
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    emit({ type: 'text', content: trimmed });
+                }
+            }
+        });
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (chunk) => {
+            const text = chunk.toString('utf8').trim();
+            if (text) {
+                emit({ type: 'log', level: 'warn', content: text });
+            }
+        });
+        (_c = child.stdout) === null || _c === void 0 ? void 0 : _c.on('end', () => {
+            if (buffer.trim()) {
+                emit({ type: 'text', content: buffer.trim() });
+            }
+            resolve();
+        });
+        child.on('error', () => resolve());
+        child.on('exit', () => resolve());
+    });
+}
+class AsyncMessageEmitter {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    emit(value) {
+        if (this.done)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+class CursorBackend {
+    constructor() {
+        this.name = NAME;
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { spawn } = yield Promise.resolve().then(() => __importStar(require('child_process')));
+            return new Promise((resolve, reject) => {
+                var _a;
+                const child = spawn('cursor', ['--version'], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stdout = '';
+                (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                    stdout += chunk.toString('utf8');
+                });
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(stdout.trim());
+                    }
+                    else {
+                        reject(new Error(`cursor --version exited with code ${code}`));
+                    }
+                });
+                child.on('error', (err) => {
+                    reject(new Error(`Failed to run cursor: ${err.message}`));
+                });
+            });
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['chat'];
+            if (opts.model) {
+                args.push('--model', opts.model);
+            }
+            if (opts.customArgs) {
+                args.push(...opts.customArgs);
+            }
+            args.push(prompt);
+            const proc = (0, spawn_helper_1.spawnProcess)({
+                command: NAME,
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+                semanticInactivityMs: opts.semanticInactivityMs,
+            });
+            const emitter = new AsyncMessageEmitter();
+            const startTime = Date.now();
+            const drainPromise = transformStdoutLines(proc.child, (msg) => emitter.emit(msg));
+            const resultPromise = drainPromise.then(() => {
+                return new Promise((resolve) => {
+                    proc.child.on('exit', (code, signal) => {
+                        const durationMs = Date.now() - startTime;
+                        let status = 'completed';
+                        let error;
+                        if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+                            status = 'cancelled';
+                        }
+                        else if (code !== null && code !== 0) {
+                            status = 'failed';
+                            error = `cursor exited with code ${code}`;
+                        }
+                        emitter.close();
+                        resolve({
+                            status,
+                            output: '',
+                            error,
+                            durationMs,
+                        });
+                    });
+                    proc.child.on('error', (err) => {
+                        const durationMs = Date.now() - startTime;
+                        emitter.close();
+                        resolve({
+                            status: 'failed',
+                            output: '',
+                            error: err.message,
+                            durationMs,
+                            failureReason: 'agent_crash',
+                        });
+                    });
+                });
+            });
+            return {
+                messages: emitter,
+                result: resultPromise,
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.CursorBackend = CursorBackend;

package/dist/agent/factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackend = getBackend;
+exports.listBackends = listBackends;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const cursor_1 = require("./cursor");
+const gemini_1 = require("./gemini");
+const copilot_1 = require("./copilot");
+const antigravity_1 = require("./antigravity");
+const opencode_1 = require("./opencode");
+const backends = {
+    'claude-code': () => new claude_1.ClaudeBackend(),
+    'codex': () => new codex_1.CodexBackend(),
+    'cursor': () => new cursor_1.CursorBackend(),
+    'gemini': () => new gemini_1.GeminiBackend(),
+    'copilot': () => new copilot_1.CopilotBackend(),
+    'antigravity': () => new antigravity_1.AntigravityBackend(),
+    'opencode': () => new opencode_1.OpenCodeBackend(),
+};
+function getBackend(name) {
+    const factory = backends[name];
+    if (!factory) {
+        throw new Error(`Unknown agent backend: ${name}. Available: ${Object.keys(backends).join(', ')}`);
+    }
+    return factory();
+}
+function listBackends() {
+    return Object.keys(backends);
+}

package/dist/agent/gemini.js

@@ -0,0 +1,142 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiBackend = void 0;
+const child_process_1 = require("child_process");
+const spawn_helper_1 = require("./spawn-helper");
+function asyncTransform(raw) {
+    return __asyncGenerator(this, arguments, function* asyncTransform_1() {
+        var _a, e_1, _b, _c;
+        try {
+            for (var _d = true, raw_1 = __asyncValues(raw), raw_1_1; raw_1_1 = yield __await(raw_1.next()), _a = raw_1_1.done, !_a; _d = true) {
+                _c = raw_1_1.value;
+                _d = false;
+                const msg = _c;
+                const text = msg.content;
+                if (typeof text === 'string' && text.length > 0) {
+                    yield yield __await({ type: 'text', content: text });
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = raw_1.return)) yield __await(_b.call(raw_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function collectResult(proc) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        let output = '';
+        let lastError;
+        let status = 'completed';
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
+            try {
+                try {
+                    for (var _d = true, _e = __asyncValues(proc.messages), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const msg = _c;
+                        const text = msg.content;
+                        if (typeof text === 'string' && text.length > 0) {
+                            output += text + '\n';
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            catch (err) {
+                status = 'failed';
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+            resolve({
+                status,
+                output: output.trim(),
+                error: lastError,
+                durationMs: Date.now() - start,
+            });
+        }))();
+    });
+}
+class GeminiBackend {
+    constructor() {
+        this.name = 'gemini';
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (0, child_process_1.execFileSync)('gemini', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                }).trim();
+            }
+            catch (_a) {
+                return 'unknown';
+            }
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['-p', prompt];
+            if (opts.model)
+                args.push('--model', opts.model);
+            if (opts.customArgs)
+                args.push(...opts.customArgs);
+            const proc = (0, spawn_helper_1.spawnProcess)({
+                command: 'gemini',
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+                semanticInactivityMs: opts.semanticInactivityMs,
+                outputFormat: 'text',
+            });
+            const messages = asyncTransform(proc.messages);
+            const result = collectResult(proc);
+            return {
+                messages,
+                result,
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.GeminiBackend = GeminiBackend;