kortext 3.0.0 → 3.1.0

package/dist/cli-spawn.js

@@ -0,0 +1,137 @@
+import { spawn } from 'node:child_process';
+import { createWriteStream, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export async function spawnCli(opts) {
+    // Keep escalation shorter than the restart/cancel delay before project files are removed.
+    const sigkillDelayMs = opts.sigkillDelayMs ?? 1000;
+    const summaryCap = opts.summaryBufferBytes ?? 64 * 1024;
+    if (opts.signal.aborted) {
+        return {
+            exitCode: null,
+            signal: null,
+            stdoutTail: '',
+            stderrTail: '',
+            aborted: true,
+            timedOut: false,
+        };
+    }
+    // Windows support is experimental: .cmd shims require a shell and process-tree termination
+    // uses taskkill. Keep binary/arguments trusted and send user-written prompts through stdin.
+    const onWindows = process.platform === 'win32';
+    // A prompt on the command line is untrusted text; the Windows path runs
+    // through a shell, so it stays on stdin there or not at all.
+    const asArg = opts.promptFlag !== undefined;
+    if (asArg && onWindows)
+        throw new Error(`${opts.binary} needs stdin prompts on Windows`);
+    const args = asArg && opts.stdin !== undefined
+        ? [...opts.args, ...(opts.promptFlag ? [opts.promptFlag] : []), opts.stdin]
+        : opts.args;
+    const stdin = asArg ? undefined : opts.stdin;
+    const proc = spawn(opts.binary, args, {
+        cwd: opts.cwd,
+        env: opts.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: onWindows,
+        // Use a POSIX process group to terminate descendants that could keep output pipes open.
+        detached: !onWindows,
+    });
+    const killTree = (sig) => {
+        try {
+            if (onWindows)
+                throw new Error('no process groups'); // straight to the fallback
+            process.kill(-proc.pid, sig); // negative pid = the process group
+        }
+        catch {
+            try {
+                proc.kill(sig);
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    };
+    // Create the log directory before opening the stream to prevent an unhandled ENOENT error.
+    mkdirSync(dirname(opts.logPath), { recursive: true });
+    const log = createWriteStream(opts.logPath, { flags: 'a' });
+    log.write(`\n# kortext cli-executor — ${new Date().toISOString()}\n# binary: ${opts.binary}\n# args: ${JSON.stringify(opts.args)}\n# cwd: ${opts.cwd}\n\n`);
+    // Bound output buffers to limit memory use.
+    let stdoutBuf = '';
+    let stderrBuf = '';
+    const appendCapped = (current, chunk) => {
+        const combined = current + chunk;
+        return combined.length > summaryCap ? combined.slice(combined.length - summaryCap) : combined;
+    };
+    proc.stdout?.on('data', (chunk) => {
+        const s = chunk.toString('utf8');
+        stdoutBuf = appendCapped(stdoutBuf, s);
+        log.write(s);
+    });
+    proc.stderr?.on('data', (chunk) => {
+        const s = chunk.toString('utf8');
+        stderrBuf = appendCapped(stderrBuf, s);
+        log.write(`[stderr] ${s}`);
+    });
+    // A child can close stdin before the prompt is written; handle EPIPE without crashing the server.
+    if (proc.stdin) {
+        proc.stdin.on('error', (err) => {
+            const code = err.code;
+            if (code !== 'EPIPE') {
+                log.write(`\n[stdin-error] ${err.message}\n`);
+            }
+        });
+        if (stdin !== undefined) {
+            proc.stdin.write(stdin);
+        }
+        proc.stdin.end();
+    }
+    let aborted = false;
+    let timedOut = false;
+    let killTimer = null;
+    let timeoutTimer = null;
+    const onAbort = () => {
+        aborted = true;
+        killTree('SIGTERM');
+        killTimer = setTimeout(() => killTree('SIGKILL'), sigkillDelayMs);
+    };
+    opts.signal.addEventListener('abort', onAbort, { once: true });
+    if (opts.timeoutMs !== undefined) {
+        timeoutTimer = setTimeout(() => {
+            timedOut = true; // the caller aborted nothing; this run outstayed its limit
+            onAbort();
+        }, opts.timeoutMs);
+    }
+    const result = await new Promise((resolveResult) => {
+        // Resolve after the log stream finishes so callers can read complete output.
+        // Spawn failures emit both error and close; settle once to avoid writes after the log has ended.
+        let settled = false;
+        const finish = (line, result) => {
+            if (settled)
+                return;
+            settled = true;
+            log.write(line);
+            log.end(() => resolveResult({ ...result, aborted, timedOut }));
+        };
+        proc.on('error', (err) => {
+            finish(`\n[spawn-error] ${err.message}\n`, {
+                exitCode: null,
+                signal: null,
+                stdoutTail: stdoutBuf,
+                stderrTail: stderrBuf + `\n[spawn-error] ${err.message}`,
+            });
+        });
+        proc.on('close', (code, signal) => {
+            finish(`\n# exit code=${code} signal=${signal} aborted=${aborted}\n`, {
+                exitCode: code,
+                signal,
+                stdoutTail: stdoutBuf,
+                stderrTail: stderrBuf,
+            });
+        });
+    });
+    if (killTimer)
+        clearTimeout(killTimer);
+    if (timeoutTimer)
+        clearTimeout(timeoutTimer);
+    opts.signal.removeEventListener('abort', onAbort);
+    return result;
+}

package/dist/daemon.js

@@ -0,0 +1,40 @@
+import { spawn } from 'node:child_process';
+import { mkdirSync, openSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Is a kortext already answering on this port? */
+export async function serverUp(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
+            signal: AbortSignal.timeout(700),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Wait for the detached server health check, including initial SQLite startup. */
+export async function waitForServer(port, timeoutMs = 15000) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (await serverUp(port))
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await new Promise((r) => setTimeout(r, 150));
+    }
+}
+/**
+ * Detach into a separate process group and redirect output to a log file.
+ * Unref the child so the parent can exit without stopping the server.
+ */
+export function respawnDetached(entry, args, logPath) {
+    mkdirSync(dirname(logPath), { recursive: true });
+    const log = openSync(logPath, 'a');
+    const child = spawn(process.execPath, [entry, ...args], {
+        detached: true,
+        stdio: ['ignore', log, log],
+        env: { ...process.env, KORTEXT_CHILD: '1' },
+    });
+    child.unref();
+}

package/dist/db.js

@@ -0,0 +1,78 @@
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+export function defaultDbPath() {
+    return join(homedir(), '.kortext', 'kortext.db');
+}
+// The database filename is part of the namespace, including for sibling DBs.
+export function logRootDir(db) {
+    return `${resolve(db.name)}.logs`;
+}
+export function logPathFor(db, name) {
+    return join(logRootDir(db), name);
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  repo_path TEXT NOT NULL UNIQUE,
+  kind TEXT NOT NULL DEFAULT 'new',   -- new | existing → which analysis workflow applies
+  code TEXT NOT NULL DEFAULT '',      -- task-id prefix, e.g. ACME
+  paused INTEGER NOT NULL DEFAULT 0,  -- 1 = the chain starts no new steps
+  archived INTEGER NOT NULL DEFAULT 0,-- 1 = folded away in the panel; files untouched
+  doc_lang TEXT NOT NULL DEFAULT '',  -- the language the documents are written in
+  engine TEXT NOT NULL DEFAULT '',    -- the agent CLI this project runs on
+  model TEXT NOT NULL DEFAULT '',     -- the model that CLI is told to use; '' = the CLI's own default
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS jobs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  doc_rel TEXT NOT NULL,
+  kind TEXT NOT NULL DEFAULT 'doc',   -- doc (analysis step) | plan (kopeng split)
+  status TEXT NOT NULL DEFAULT 'running',  -- running | done | failed | stopped
+  error TEXT,
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  finished_at TEXT
+);
+-- What a document said before it was last written. Not document state — the
+-- current text still lives only on disk — but a write log, like the jobs table,
+-- so the panel can show what a revision replaced.
+CREATE TABLE IF NOT EXISTS doc_versions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  rel TEXT NOT NULL,
+  sha TEXT NOT NULL,
+  content TEXT NOT NULL,
+  source TEXT NOT NULL,               -- agent | prime | proposal | pre-existing
+  job_id INTEGER,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_doc_versions ON doc_versions(project_id, rel, id DESC);
+CREATE TABLE IF NOT EXISTS pending_rechecks (
+  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  source_rel TEXT NOT NULL,
+  reader_rel TEXT NOT NULL,
+  generation INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (project_id, source_rel, reader_rel)
+);
+`;
+export function openDb(path = defaultDbPath()) {
+    mkdirSync(dirname(path), { recursive: true });
+    const db = new Database(path);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.exec(SCHEMA);
+    if (!db.pragma('table_info(jobs)').some((c) => c.name === 'notes')) {
+        db.exec("ALTER TABLE jobs ADD COLUMN notes TEXT NOT NULL DEFAULT '[]'");
+    }
+    if (!db.pragma('table_info(projects)').some((c) => c.name === 'model')) {
+        db.exec("ALTER TABLE projects ADD COLUMN model TEXT NOT NULL DEFAULT ''");
+    }
+    return db;
+}