kortext 2.2.3 → 3.1.0

package/dist/engines.js

@@ -0,0 +1,225 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// The first four ran a real project here. The rest are prepared from each
+// CLI's own documentation (2026-09) so the panel offers them the day they are
+// installed; the first run on a real machine settles the flags.
+export const ENGINES = [
+    {
+        id: 'claude',
+        binary: 'claude',
+        // --print: headless (no REPL); skip-permissions: auto-approve tool use;
+        // stdin carries the step prompt.
+        args: ['--print', '--dangerously-skip-permissions'],
+        modelFlag: '--model',
+        // Aliases the CLI resolves to its latest of each tier.
+        models: ['fable', 'opus', 'sonnet', 'haiku'],
+        installHint: 'npm install -g @anthropic-ai/claude-code',
+    },
+    {
+        id: 'codex',
+        binary: 'codex',
+        // exec = non-interactive; workspace-write so it can create the output
+        // file; skip-git-repo-check: project may not be a git repo (yet).
+        args: ['exec', '--sandbox', 'workspace-write', '--skip-git-repo-check'],
+        modelFlag: '-m',
+        models: ['gpt-6-astra', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.6-sol', 'gpt-5.4-mini'],
+        installHint: 'npm install -g @openai/codex',
+    },
+    {
+        id: 'antigravity',
+        binary: 'agy',
+        // Antigravity's CLI. --print takes the prompt itself, so it rides as an
+        // argument; the default print timeout is 5 minutes, too short for a document.
+        args: ['--dangerously-skip-permissions', '--print-timeout', '30m'],
+        promptFlag: '--print',
+        // Without it the workspace is ~/.gemini/antigravity-cli and the agent
+        // hunts for the repository with find and ls.
+        cwdFlag: '--add-dir',
+        modelFlag: '--model',
+        // `agy models` lists more; these are the tiers.
+        models: [
+            'gemini-3.8-flash-high',
+            'gemini-3.1-pro-high',
+            'claude-opus-4-6-thinking',
+            'claude-sonnet-4-6',
+            'gpt-oss-120b-medium',
+        ],
+        installHint: 'install Antigravity, then run: agy install',
+    },
+    {
+        id: 'gemini',
+        binary: 'gemini',
+        args: ['--yolo'],
+        modelFlag: '-m',
+        models: ['gemini-2.5-pro', 'gemini-2.5-flash'],
+        installHint: 'npm install -g @google/gemini-cli',
+    },
+    {
+        id: 'cursor',
+        // Cursor's agent CLI installs as `agent`. -p prints instead of opening
+        // the TUI; --force lets it write files in that mode.
+        binary: 'agent',
+        args: ['--force'],
+        promptFlag: '-p',
+        modelFlag: '--model',
+        models: ['auto', 'composer-2', 'sonnet-4.6', 'opus-4.6', 'gpt-5.4'],
+        installHint: 'curl https://cursor.com/install -fsS | bash',
+        untested: true,
+    },
+    {
+        id: 'copilot',
+        // -p runs one prompt and exits; -s drops the decoration; --yolo is
+        // --allow-all-tools plus paths and URLs; --no-ask-user stops it pausing
+        // for a human who is not there.
+        binary: 'copilot',
+        args: ['-s', '--yolo', '--no-ask-user'],
+        promptFlag: '-p',
+        modelFlag: '--model',
+        models: ['gpt-5.4', 'gpt-5.3-codex', 'claude-sonnet-4.6', 'claude-haiku-4.5'],
+        installHint: 'npm install -g @github/copilot',
+        untested: true,
+    },
+    {
+        id: 'opencode',
+        // `opencode run <message>`; --auto approves what is not explicitly denied.
+        binary: 'opencode',
+        args: ['run', '--auto'],
+        promptFlag: '',
+        modelFlag: '-m',
+        // provider/model.
+        models: ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.4', 'google/gemini-3.1-pro'],
+        installHint: 'npm install -g opencode-ai',
+        untested: true,
+    },
+    {
+        id: 'amp',
+        // -x reads the prompt from stdin and exits after one turn. No model flag:
+        // Amp picks its own.
+        binary: 'amp',
+        args: ['--dangerously-allow-all', '-x'],
+        models: [],
+        installHint: 'npm install -g @sourcegraph/amp',
+        untested: true,
+    },
+    {
+        id: 'droid',
+        // `droid exec` reads stdin; --auto low is file edits without shell.
+        binary: 'droid',
+        args: ['exec', '--auto', 'low'],
+        modelFlag: '-m',
+        models: ['claude-sonnet-4-6', 'claude-opus-4-6', 'gpt-5.3-codex'],
+        installHint: 'curl -fsSL https://app.factory.ai/cli | sh',
+        untested: true,
+    },
+    {
+        id: 'goose',
+        // `goose run -i -` reads stdin; approval and model come from the
+        // environment, not flags.
+        binary: 'goose',
+        args: ['run', '-i', '-'],
+        env: { GOOSE_MODE: 'auto' },
+        modelEnv: 'GOOSE_MODEL',
+        models: [],
+        installHint: 'brew install block-goose-cli',
+        untested: true,
+    },
+    {
+        id: 'qwen',
+        // Qwen Code is a gemini-cli fork: same --yolo, same stdin prompt.
+        binary: 'qwen',
+        args: ['--yolo'],
+        modelFlag: '-m',
+        models: ['qwen3-coder-plus', 'qwen3-coder-flash'],
+        installHint: 'npm install -g @qwen-code/qwen-code',
+        untested: true,
+    },
+    {
+        id: 'cline',
+        // The prompt is the last argument; -y skips approvals and exits when the
+        // turn ends; provider/model ids.
+        binary: 'cline',
+        args: ['-y'],
+        promptFlag: '',
+        modelFlag: '-m',
+        models: ['anthropic/claude-sonnet-4.6', 'anthropic/claude-opus-4-6', 'google/gemini-3-pro'],
+        installHint: 'npm install -g cline',
+        untested: true,
+    },
+];
+/** The CLI's arguments with the project's model, when one is set. */
+export function engineArgs(engine, project) {
+    const model = (project.model ?? '').trim();
+    return [
+        ...engine.args,
+        ...(engine.cwdFlag && project.repo_path ? [engine.cwdFlag, project.repo_path] : []),
+        ...(model && engine.modelFlag ? [engine.modelFlag, model] : []),
+    ];
+}
+/** The CLI's environment: the server's, the spec's, and the model when it
+ *  travels as a variable. */
+export function engineEnv(engine, project) {
+    const model = (project.model ?? '').trim();
+    if (!engine.env && !(model && engine.modelEnv))
+        return undefined;
+    return {
+        ...process.env,
+        ...engine.env,
+        ...(model && engine.modelEnv ? { [engine.modelEnv]: model } : {}),
+    };
+}
+/**
+ * Check PATH with which on POSIX and where on Windows.
+ * Windows support is experimental and has not been runtime-tested.
+ */
+/** Where the CLI is, or null: the bare name when PATH has it, else the one
+ *  place a server started from an app rather than a shell tends to miss —
+ *  ~/.local/bin, where agy lands. */
+export function binaryPath(binary) {
+    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    if (spawnSync(lookup, [binary], { stdio: 'ignore' }).status === 0)
+        return binary;
+    const local = join(homedir(), '.local', 'bin', binary);
+    return existsSync(local) ? local : null;
+}
+export function onPath(binary) {
+    return binaryPath(binary) !== null;
+}
+// Cache blocking PATH lookups briefly to avoid spawning a lookup on every panel poll.
+const DETECT_TTL_MS = 5000;
+let detected = null;
+export function detectEngines() {
+    if (detected && Date.now() - detected.at < DETECT_TTL_MS)
+        return detected.engines;
+    const engines = ENGINES.map((e) => {
+        const path = binaryPath(e.binary);
+        return { ...e, binary: path ?? e.binary, available: path !== null };
+    });
+    detected = { at: Date.now(), engines };
+    return engines;
+}
+/** Forget the cache — the user just told us the installed set may have changed. */
+export function forgetDetectedEngines() {
+    detected = null;
+}
+export function getSetting(db, key) {
+    const row = db.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+    return row?.value ?? null;
+}
+export function setSetting(db, key, value) {
+    db.prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);
+}
+/** Prefer the project CLI when installed; otherwise use the global selection or first available CLI. */
+export function engineFor(db, project) {
+    const detected = detectEngines();
+    return detected.find((e) => e.id === project.engine && e.available) ?? selectedEngine(db);
+}
+// Selected engine: explicit setting if still installed, else first available.
+export function selectedEngine(db) {
+    const detected = detectEngines();
+    const chosen = getSetting(db, 'engine');
+    return (detected.find((e) => e.id === chosen && e.available) ??
+        detected.find((e) => e.available) ??
+        null);
+}

package/dist/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { readFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { defaultDbPath, openDb } from './db.js';
+import { buildApp } from './app.js';
+import { abortAllRuns } from './runner.js';
+import { respawnDetached, serverUp, waitForServer } from './daemon.js';
+const { values } = parseArgs({
+    options: {
+        port: { type: 'string' },
+        db: { type: 'string' },
+        'no-open': { type: 'boolean' },
+        'no-detach': { type: 'boolean' },
+        stop: { type: 'boolean' },
+        help: { type: 'boolean', short: 'h' },
+        version: { type: 'boolean', short: 'v' },
+    },
+    allowPositionals: true,
+});
+const here = dirname(fileURLToPath(import.meta.url));
+// package root works from both server/ (tsx dev) and dist/ (built)
+const pkgRoot = join(here, '..');
+if (values.version) {
+    const pkg = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8'));
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (values.help) {
+    console.log(`kortext — project brain for AI-driven development
+
+Usage: kortext [--port 3441] [--db ~/.kortext/kortext.db] [--no-open] [--no-detach]
+       kortext --stop
+       kortext --version
+
+Starts the server in the background and opens the panel in your browser: the
+terminal window can be closed, and the panel's ⏻ button stops the server.
+--no-detach keeps it in this terminal, where Ctrl+C stops it.
+--stop stops a server running in the background, like the panel's ⏻ button.
+Data lives in a global SQLite database — one database, multiple projects.`);
+    process.exit(0);
+}
+const PORT = Number(values.port ?? process.env.PORT ?? 3441);
+const DB_PATH = values.db ?? defaultDbPath();
+// Use the panel shutdown endpoint so CLI and UI enforce the same busy check.
+if (values.stop) {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/quit`, { method: 'POST' }).catch(() => null);
+    if (!res) {
+        console.log(`nothing is running on port ${PORT}`);
+        process.exit(0);
+    }
+    if (!res.ok) {
+        const { error } = (await res.json().catch(() => ({})));
+        console.error(error ?? `could not stop kortext (HTTP ${res.status})`);
+        process.exit(1);
+    }
+    console.log('kortext stopped');
+    process.exit(0);
+}
+// Detach with KORTEXT_CHILD set so closing the terminal leaves the server running.
+// Development uses --no-detach to keep the watcher in the foreground.
+if (!process.env.KORTEXT_CHILD && !values['no-detach']) {
+    const url = `http://localhost:${PORT}`;
+    const logPath = `${DB_PATH}.log`;
+    // Reuse an existing Kortext server on this port.
+    const already = await serverUp(PORT);
+    if (!already) {
+        // Only the parent opens the browser, after the server passes its health check.
+        respawnDetached(fileURLToPath(import.meta.url), [...process.argv.slice(2), '--no-open'], logPath);
+    }
+    if (!(already || (await waitForServer(PORT)))) {
+        console.error(`kortext did not start. See ${logPath}`);
+        process.exit(1);
+    }
+    console.log(`${already ? 'kortext is already running' : 'kortext panel'}: ${url}`);
+    console.log('You can close this window. Stop it with the ⏻ button in the panel.');
+    if (!values['no-open'])
+        openBrowser(url);
+    process.exit(0);
+}
+const db = openDb(DB_PATH);
+const app = buildApp(db, pkgRoot, DB_PATH);
+// Bind only loopback addresses: the API exposes local paths and file mutations without authentication.
+// Listen on IPv4 and, where available, IPv6 because localhost can resolve to either.
+app.listen(PORT, '127.0.0.1', () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`kortext panel: ${url}`);
+    console.log(`db:            ${DB_PATH}`);
+    if (!values['no-open'])
+        openBrowser(url);
+});
+app.listen(PORT, '::1').on('error', () => {
+    /* no IPv6 loopback on this machine; the IPv4 listener above is the panel */
+});
+// tsx watch, kortext --stop and a terminal Ctrl-C all arrive as a signal. Kill
+// the CLIs first — SIGTERM, then SIGKILL a second later — or they outlive us.
+for (const sig of ['SIGTERM', 'SIGINT']) {
+    process.on(sig, () => {
+        abortAllRuns();
+        setTimeout(() => process.exit(0), 1500).unref();
+    });
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+}

package/dist/pick-directory.js

@@ -0,0 +1,38 @@
+import { spawn } from 'node:child_process';
+/**
+ * Parse the output of the macOS folder chooser (osascript). Returns the chosen
+ * absolute POSIX path on success (trailing slash stripped), or null when the
+ * user cancelled (non-zero exit) or the output was empty.
+ */
+export function parsePickedPath(stdout, exitCode) {
+    if (exitCode !== 0)
+        return null;
+    const p = stdout.trim();
+    if (!p)
+        return null;
+    return p.replace(/\/+$/, '');
+}
+/**
+ * Open a native folder picker and resolve to the chosen absolute path, or null
+ * (cancelled / unsupported platform). macOS-only for now via `osascript`; other
+ * platforms resolve to null so the UI falls back to a typed path. The spawn is
+ * injectable so the parsing logic stays unit-testable.
+ */
+export function pickDirectoryNative(platform = process.platform, spawnFn = spawn) {
+    if (platform !== 'darwin')
+        return Promise.resolve(null);
+    return new Promise((resolveResult) => {
+        const proc = spawnFn('osascript', [
+            '-e',
+            'POSIX path of (choose folder with prompt "Select the project folder for Kortext")',
+        ]);
+        let out = '';
+        proc.stdout?.on('data', (d) => {
+            out += String(d);
+        });
+        proc.on('close', (code) => {
+            resolveResult(parsePickedPath(out, code ?? 1));
+        });
+        proc.on('error', () => resolveResult(null));
+    });
+}

package/dist/projects.js

@@ -0,0 +1,189 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+// Live workspace inside a registered repo:
+//   AGENTS.md      (repo root — the agent's entry contract)
+//   .kortext/*.md  (every document, one flat shelf, in the order they are written)
+// Workflows and personas are NOT copied — kortext itself drives the engine
+// with them during the analysis; after the handshake the docs are the contract.
+export const BRIEF_REL = join('.kortext', 'BRIEF.md');
+// Resolve existing ancestors too, so a new folder below a symlink has one identity.
+function canonicalRepo(path) {
+    const absolute = resolve(path);
+    return existsSync(absolute)
+        ? realpathSync.native(absolute)
+        : join(canonicalRepo(dirname(absolute)), basename(absolute));
+}
+export function scaffoldProject(repoPath, pkgRoot, opts = {}) {
+    const kx = join(repoPath, '.kortext');
+    mkdirSync(kx, { recursive: true });
+    const templates = join(pkgRoot, 'templates');
+    installContract(repoPath, templates);
+    // Initialize the brief separately so an empty template always starts as draft.
+    copyDirIfMissing(join(templates, 'docs'), kx, new Set(['BRIEF.md']));
+    if (opts.skipBrief)
+        return;
+    const brief = join(repoPath, BRIEF_REL);
+    if (!existsSync(brief)) {
+        const template = join(templates, 'docs', 'BRIEF.md');
+        if (existsSync(template)) {
+            copyFileSync(template, brief);
+            forceStatus(brief, 'draft');
+        }
+        else {
+            writeFileSync(brief, '---\nstatus: draft\n---\n\n# Brief\n', 'utf8');
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// The handover contract
+// ---------------------------------------------------------------------------
+// Keep the contract in a marked AGENTS.md block to preserve user content.
+// Add a pointer to an existing CLAUDE.md rather than duplicating the contract.
+const BLOCK_START = '<!-- kortext:start -->';
+const BLOCK_END = '<!-- kortext:end -->';
+const POINTER = '<!-- kortext --> Read AGENTS.md and the .kortext/ docs before any work.';
+export function writeContractBlock(path, body) {
+    const block = `${BLOCK_START}\n${body.trim()}\n${BLOCK_END}`;
+    if (!existsSync(path)) {
+        writeFileSync(path, `${block}\n`, 'utf8');
+        return;
+    }
+    const current = readFileSync(path, 'utf8');
+    // The panel re-scaffolds on every poll; an unchanged block is not rewritten.
+    if (current.includes(block))
+        return;
+    const start = current.indexOf(BLOCK_START);
+    const end = current.indexOf(BLOCK_END);
+    if (start !== -1 && end > start) {
+        writeFileSync(path, current.slice(0, start) + block + current.slice(end + BLOCK_END.length), 'utf8');
+        return;
+    }
+    writeFileSync(path, `${current.replace(/\s*$/, '')}\n\n${block}\n`, 'utf8');
+}
+/** Takes back only kortext's block. A file that held anything else stays. */
+export function removeContractBlock(path) {
+    if (!existsSync(path))
+        return;
+    const current = readFileSync(path, 'utf8');
+    const start = current.indexOf(BLOCK_START);
+    const end = current.indexOf(BLOCK_END);
+    if (start === -1 || end < start)
+        return; // not ours — never written by kortext
+    const rest = (current.slice(0, start) + current.slice(end + BLOCK_END.length)).trim();
+    if (rest === '')
+        rmSync(path, { force: true });
+    else
+        writeFileSync(path, `${rest}\n`, 'utf8');
+}
+function writePointer(path) {
+    if (!existsSync(path))
+        return; // kortext never invents another tool's memory file
+    const current = readFileSync(path, 'utf8');
+    if (current.includes('<!-- kortext -->'))
+        return;
+    writeFileSync(path, `${current.replace(/\s*$/, '')}\n\n${POINTER}\n`, 'utf8');
+}
+function removePointer(path) {
+    if (!existsSync(path))
+        return;
+    const kept = readFileSync(path, 'utf8')
+        .split('\n')
+        .filter((l) => !l.includes('<!-- kortext -->'));
+    writeFileSync(path, `${kept.join('\n').replace(/\s*$/, '')}\n`, 'utf8');
+}
+function installContract(repoPath, templates) {
+    const template = join(templates, 'AGENTS.md');
+    if (!existsSync(template))
+        return;
+    writeContractBlock(join(repoPath, 'AGENTS.md'), readFileSync(template, 'utf8'));
+    writePointer(join(repoPath, 'CLAUDE.md'));
+}
+/** Remove the Kortext contract block and CLAUDE.md pointer, preserving user content. */
+export function uninstallContract(repoPath) {
+    removeContractBlock(join(repoPath, 'AGENTS.md'));
+    removePointer(join(repoPath, 'CLAUDE.md'));
+}
+function copyIfMissing(from, to) {
+    if (existsSync(from) && !existsSync(to))
+        copyFileSync(from, to);
+}
+function copyDirIfMissing(fromDir, toDir, skip = new Set()) {
+    if (!existsSync(fromDir))
+        return;
+    for (const entry of readdirSync(fromDir, { withFileTypes: true })) {
+        if (entry.isFile() && !skip.has(entry.name)) {
+            copyIfMissing(join(fromDir, entry.name), join(toDir, entry.name));
+        }
+    }
+}
+// A freshly scaffolded brief always starts as draft, whatever the template says.
+function forceStatus(path, status) {
+    const body = readFileSync(path, 'utf8');
+    if (/^status:/m.test(body)) {
+        writeFileSync(path, body.replace(/^status:.*$/m, `status: ${status}`), 'utf8');
+    }
+    else if (body.startsWith('---\n')) {
+        writeFileSync(path, body.replace('---\n', `---\nstatus: ${status}\n`), 'utf8');
+    }
+    else {
+        writeFileSync(path, `---\nstatus: ${status}\n---\n\n${body}`, 'utf8');
+    }
+}
+export function listProjects(db) {
+    return db.prepare('SELECT * FROM projects ORDER BY created_at DESC').all();
+}
+// Derive an uppercase project code from the name when no code is supplied.
+export function deriveCode(name) {
+    // Strip digits so derived codes pass the same validation as user-supplied codes.
+    const cleaned = name
+        .toUpperCase()
+        .replace(/[ÇĞİIÖŞÜ]/g, (c) => 'CGIIOSU'['ÇĞİIÖŞÜ'.indexOf(c)] ?? c)
+        .replace(/[^A-Z]/g, '');
+    return (cleaned.slice(0, 5) || 'PROJ').padEnd(2, 'X');
+}
+export function createProject(db, input, pkgRoot) {
+    const name = input.name.trim();
+    // Compare real filesystem identities, including older registry entries that
+    // stored an alias, before another project can own and reset these documents.
+    const repoPath = input.repoPath.trim() ? canonicalRepo(input.repoPath.trim()) : '';
+    const kind = input.kind === 'existing' ? 'existing' : 'new';
+    const code = (input.code ?? '').trim().toUpperCase() || deriveCode(name);
+    if (!name)
+        throw new Error('name is required');
+    if (!repoPath)
+        throw new Error('repoPath is required');
+    if (!/^[A-Z]{2,8}$/.test(code)) {
+        throw new Error(`code must be 2-8 letters, A-Z (got: ${code})`);
+    }
+    const codeTaken = db.prepare('SELECT name FROM projects WHERE code = ?').get(code);
+    if (codeTaken) {
+        throw new Error(`The code ${code} already belongs to "${codeTaken.name}" — task ids carry it, so two projects cannot share one. Pick another, or remove that project first.`);
+    }
+    const taken = listProjects(db).find((p) => canonicalRepo(p.repo_path) === repoPath);
+    if (taken) {
+        throw new Error(taken.archived
+            ? `This folder is already the archived project "${taken.name}" — unarchive it instead of adding it again.`
+            : `This folder is already the project "${taken.name}".`);
+    }
+    mkdirSync(repoPath, { recursive: true });
+    // existing projects take no brief — the ground truth is the code itself
+    scaffoldProject(repoPath, pkgRoot, { skipBrief: kind === 'existing' });
+    const brief = input.brief?.trim();
+    if (brief) {
+        // Treat a submitted brief as approved; readiness is checked on Start and may demote it to draft.
+        writeFileSync(join(repoPath, BRIEF_REL), `---\nstatus: approved\nauthor: +prime\napprover: +prime\n---\n\n${brief}\n`, 'utf8');
+    }
+    const row = db
+        .prepare('INSERT INTO projects (name, repo_path, kind, code, doc_lang, engine) VALUES (?, ?, ?, ?, ?, ?) RETURNING *')
+        .get(name, repoPath, kind, code, (input.docLang ?? '').trim(), (input.engine ?? '').trim());
+    return row;
+}
+// Archive without deleting the registry row or project files.
+export function setArchived(db, id, archived) {
+    return (db.prepare('UPDATE projects SET archived = ? WHERE id = ?').run(archived ? 1 : 0, id).changes >
+        0);
+}
+// Unregister only — never touches files in the repo.
+export function removeProject(db, id) {
+    return db.prepare('DELETE FROM projects WHERE id = ?').run(id).changes > 0;
+}