tokenmaw 0.3.0 → 0.4.0

package/dist/runtime/worktree.js

@@ -0,0 +1,321 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+const execFileAsync = promisify(execFile);
+const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+const MAX_INCLUDE_FILES = 50;
+/**
+ * Managed git worktrees for parallel maw sessions on one repository.
+ *
+ * Worktrees live under `<main-root>/.coder/worktrees/<name>` on branches named
+ * `maw/<name>`. Creation is conservative (a dirty source checkout still
+ * branches from HEAD, never from origin), removal refuses to touch dirty
+ * checkouts or delete branches, and a worktree is `git worktree lock`ed while
+ * a session uses it so concurrent cleanup cannot remove live state.
+ */
+export class WorktreeManager {
+    cwd;
+    constructor(cwd) {
+        this.cwd = resolve(cwd);
+    }
+    async git(cwd, args) {
+        try {
+            const result = await execFileAsync('git', args, { cwd, timeout: 30_000, maxBuffer: 1024 * 1024 * 4 });
+            return { code: 0, stdout: result.stdout, stderr: result.stderr };
+        }
+        catch (error) {
+            const err = error;
+            return { code: err.code ?? 1, stdout: err.stdout ?? '', stderr: err.stderr ?? err.message ?? String(error) };
+        }
+    }
+    async inGitRepo(cwd = this.cwd) {
+        const result = await this.git(cwd, ['rev-parse', '--is-inside-work-tree']);
+        return result.code === 0 && result.stdout.trim() === 'true';
+    }
+    /** Main (first) worktree root for the repository containing `cwd`. */
+    async mainRoot() {
+        if (!(await this.inGitRepo()))
+            throw new Error('worktree: not inside a git repository');
+        const common = await this.git(this.cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+        if (common.code === 0) {
+            const dir = common.stdout.trim();
+            if (dir) {
+                const parent = dirname(dir);
+                if (basename(dir) === '.git' && parent)
+                    return parent;
+                return dir;
+            }
+        }
+        const fallback = await this.git(this.cwd, ['worktree', 'list', '--porcelain']);
+        if (fallback.code === 0) {
+            const first = fallback.stdout.split('\n').find((line) => line.startsWith('worktree '));
+            if (first)
+                return first.slice('worktree '.length).trim();
+        }
+        return this.cwd;
+    }
+    async managedDir() {
+        const main = await this.mainRoot();
+        return join(main, '.coder', 'worktrees');
+    }
+    managedDirSync(mainRoot) {
+        return join(mainRoot, '.coder', 'worktrees');
+    }
+    branchFor(name) {
+        return `maw/${name}`;
+    }
+    async metadataPath(name, mainRoot) {
+        const dir = mainRoot ? this.managedDirSync(mainRoot) : await this.managedDir();
+        return join(dir, `${name}.json`);
+    }
+    async readMetadata(name, mainRoot) {
+        try {
+            const raw = await readFile(await this.metadataPath(name, mainRoot), 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && parsed.name === name)
+                return parsed;
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+    async writeMetadata(mainRoot, name, branch) {
+        const path = join(this.managedDirSync(mainRoot), `${name}.json`);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify({ name, branch, createdAt: new Date().toISOString() }, null, 2)}\n`, 'utf8');
+    }
+    /** Keep the managed worktree dir out of the user's git status. */
+    async excludeManagedDir(mainRoot) {
+        const result = await this.git(mainRoot, ['rev-parse', '--git-path', 'info/exclude']);
+        if (result.code !== 0)
+            return;
+        const relative = result.stdout.trim();
+        if (!relative)
+            return;
+        const excludePath = resolve(mainRoot, relative);
+        let current = '';
+        try {
+            current = await readFile(excludePath, 'utf8');
+        }
+        catch {
+            current = '';
+        }
+        const line = '.coder/worktrees/';
+        if (current.split('\n').map((entry) => entry.trim()).includes(line))
+            return;
+        const next = `${current.trimEnd()}${current.trim() ? '\n' : ''}${line}\n`;
+        try {
+            await mkdir(dirname(excludePath), { recursive: true });
+            await writeFile(excludePath, next, 'utf8');
+        }
+        catch {
+            // Best effort; an untracked .coder dir is acceptable.
+        }
+    }
+    async isGitRepository() {
+        return this.inGitRepo();
+    }
+    /** Create (or reopen) a managed worktree and lock it for the caller. */
+    async create(name, options = {}) {
+        const trimmed = name.trim();
+        if (!NAME_PATTERN.test(trimmed)) {
+            throw new Error('worktree: name must be letters, digits, dot, underscore, or dash (max 64 chars)');
+        }
+        const main = await this.mainRoot();
+        const dir = this.managedDirSync(main);
+        const path = join(dir, trimmed);
+        const branch = this.branchFor(trimmed);
+        await this.excludeManagedDir(main);
+        let created = false;
+        if (!await this.existsDir(path)) {
+            await mkdir(dir, { recursive: true });
+            const head = await this.git(main, ['rev-parse', 'HEAD']);
+            if (head.code !== 0)
+                throw new Error(`worktree: cannot resolve HEAD (${head.stderr.trim()})`);
+            let base = head.stdout.trim();
+            if ((options.baseRef ?? 'fresh') === 'fresh') {
+                const originHead = await this.git(main, ['rev-parse', '--verify', 'origin/HEAD']);
+                if (originHead.code === 0)
+                    base = originHead.stdout.trim();
+            }
+            const branchExists = (await this.git(main, ['rev-parse', '--verify', branch])).code === 0;
+            const args = branchExists
+                ? ['worktree', 'add', path, branch]
+                : ['worktree', 'add', '-b', branch, path, base];
+            const add = await this.git(main, args);
+            if (add.code !== 0) {
+                const stderr = add.stderr.trim();
+                if (/already exists|already.*checked out|already used/i.test(stderr)) {
+                    throw new Error(`worktree: ${trimmed} is already in use (${stderr.split('\n')[0]})`);
+                }
+                throw new Error(`worktree: git worktree add failed: ${stderr.split('\n')[0]}`);
+            }
+            created = true;
+        }
+        await this.writeMetadata(main, trimmed, branch);
+        await this.git(main, ['worktree', 'lock', '--reason', `maw session in ${trimmed}`, path]);
+        if (created)
+            await this.copyIncludedFiles(main, path);
+        return { name: trimmed, path, branch, dirty: await this.dirty(path), locked: true, createdAt: (await this.readMetadata(trimmed, main))?.createdAt };
+    }
+    async existsDir(path) {
+        try {
+            return (await stat(path)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Copy gitignored files matching `.worktreeinclude` from the main checkout. */
+    async copyIncludedFiles(mainRoot, worktreePath) {
+        let patterns = [];
+        try {
+            const raw = await readFile(join(mainRoot, '.worktreeinclude'), 'utf8');
+            patterns = raw.split('\n').map((line) => line.trim()).filter((line) => line && !line.startsWith('#'));
+        }
+        catch {
+            return;
+        }
+        if (!patterns.length)
+            return;
+        const copied = new Set();
+        for (const pattern of patterns) {
+            const result = await this.git(mainRoot, [
+                'ls-files', '--others', '--ignored', '--exclude-standard', '-z', '--', pattern,
+            ]);
+            if (result.code !== 0)
+                continue;
+            for (const file of result.stdout.split('\0').filter(Boolean)) {
+                if (copied.size >= MAX_INCLUDE_FILES)
+                    return;
+                if (copied.has(file))
+                    continue;
+                copied.add(file);
+                const source = join(mainRoot, file);
+                const target = join(worktreePath, file);
+                try {
+                    await mkdir(dirname(target), { recursive: true });
+                    await copyFile(source, target);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    async dirty(worktreePath) {
+        const result = await this.git(worktreePath, ['status', '--porcelain', '--untracked-files=normal']);
+        return result.code === 0 && result.stdout.trim().length > 0;
+    }
+    async lockedPaths() {
+        const main = await this.mainRoot();
+        const result = await this.git(main, ['worktree', 'list', '--porcelain']);
+        const locked = new Set();
+        if (result.code !== 0)
+            return locked;
+        let currentPath;
+        for (const line of result.stdout.split('\n')) {
+            if (line.startsWith('worktree '))
+                currentPath = line.slice('worktree '.length).trim();
+            else if (line.startsWith('locked') && currentPath)
+                locked.add(resolve(currentPath));
+            else if (line === '')
+                currentPath = undefined;
+        }
+        return locked;
+    }
+    /** All managed worktrees with fresh status. */
+    async list() {
+        let dir;
+        try {
+            dir = await this.managedDir();
+        }
+        catch {
+            return [];
+        }
+        let names = [];
+        try {
+            names = (await readdir(dir)).filter((file) => file.endsWith('.json')).map((file) => file.slice(0, -'.json'.length));
+        }
+        catch {
+            return [];
+        }
+        const locked = await this.lockedPaths();
+        const list = [];
+        for (const name of names) {
+            const meta = await this.readMetadata(name);
+            const path = join(dir, name);
+            if (!await this.existsDir(path))
+                continue;
+            list.push({
+                name,
+                path,
+                branch: meta?.branch ?? this.branchFor(name),
+                dirty: await this.dirty(path),
+                locked: locked.has(resolve(path)),
+                createdAt: meta?.createdAt,
+            });
+        }
+        return list.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Identify the managed worktree containing `path`, if any. */
+    async containing(path) {
+        const resolved = resolve(path);
+        const all = await this.list();
+        return all.find((info) => resolved === info.path || resolved.startsWith(info.path + '/'));
+    }
+    async unlock(name) {
+        const info = await this.findExisting(name);
+        await this.git((await this.mainRoot()), ['worktree', 'unlock', info.path]);
+    }
+    async findExisting(name) {
+        const all = await this.list();
+        const info = all.find((item) => item.name === name);
+        if (!info)
+            throw new Error(`worktree: no managed worktree named ${name}`);
+        return info;
+    }
+    /** Remove a worktree. Refuses when it holds changes; never deletes the branch. */
+    async remove(name, options = {}) {
+        const info = await this.findExisting(name);
+        if (info.dirty && !options.force) {
+            throw new Error(`worktree: ${name} holds uncommitted changes; resolve or use force`);
+        }
+        const main = await this.mainRoot();
+        if (info.locked)
+            await this.git(main, ['worktree', 'unlock', info.path]);
+        const result = await this.git(main, ['worktree', 'remove', '--force', info.path]);
+        if (result.code !== 0 && !/is not a working tree|does not exist/i.test(result.stderr)) {
+            throw new Error(`worktree: remove failed: ${result.stderr.trim().split('\n')[0]}`);
+        }
+        await rm(await this.metadataPath(name, main), { force: true }).catch(() => undefined);
+    }
+    /**
+     * Startup/exit sweep: drop managed worktrees that are clean and unlocked.
+     * Dirty or locked worktrees (live sessions) are never touched.
+     */
+    async sweep() {
+        const removed = [];
+        let all = [];
+        try {
+            all = await this.list();
+        }
+        catch {
+            return removed;
+        }
+        for (const info of all) {
+            if (info.dirty || info.locked)
+                continue;
+            try {
+                await this.remove(info.name);
+                removed.push(info.name);
+            }
+            catch {
+                continue;
+            }
+        }
+        return removed;
+    }
+}

package/dist/ui/bracketed-paste.js

@@ -0,0 +1,231 @@
+import { PassThrough } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+const MARKER_START = '\x1b[200~';
+const MARKER_END = '\x1b[201~';
+/** Sequences that switch the terminal's bracketed paste mode on and off. */
+export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h';
+export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l';
+/**
+ * Terminals without bracketed-paste support cannot label a paste, but a real
+ * keyboard's Enter arrives as a lone `\r`, while `\n` only ever shows up in
+ * pasted text (browsers paste CRLF; LF-mode terminals paste LF). So a lone
+ * break stays a typed Enter and any larger chunk carrying `\n` is paste.
+ */
+/** Browsers paste CRLF; stray CRs would otherwise be typed into the draft. */
+const CRLF = /\r\n/g;
+const CR = /\r/g;
+/** Longest suffix of `text` that is a proper prefix of `marker`. */
+const trailingMarkerPrefix = (text, marker) => {
+    for (let length = Math.min(text.length, marker.length - 1); length > 0; length--) {
+        if (marker.startsWith(text.slice(text.length - length)))
+            return length;
+    }
+    return 0;
+};
+/**
+ * Blessed 0.1.x decodes input byte-by-byte, so every line break inside a
+ * pasted chunk arrives as an individual Enter keypress and submits a
+ * half-typed draft. This wrapper enables the terminal's bracketed paste mode
+ * and reassembles `\x1b[200~ ... \x1b[201~` chunks so the TUI can treat the
+ * whole paste as literal content. Terminals without bracketed-paste support
+ * (Apple Terminal, some tmux/screen setups) get a fallback: chunks with line
+ * breaks are recognised as paste content and inserted literally, while a lone
+ * break remains a typed Enter that submits instantly.
+ *
+ * The real input stream is only proxied: blessed keeps talking to the
+ * returned stream (`pause`, `resume`, `setRawMode`, destroyed checks), so the
+ * screen lifecycle still restores the underlying terminal on exit.
+ */
+export function enableBracketedPaste(rawInput, options = {}) {
+    const holdFlushMs = options.holdFlushMs ?? 40;
+    const real = rawInput;
+    const filtered = new PassThrough();
+    const decoder = new StringDecoder('utf8');
+    // Blessed only restores cooked mode when it believes raw mode is on, so the
+    // proxy must mirror the real stream's state (test doubles track it via
+    // setRawMode; a real TTY sets `isRaw` itself).
+    let rawMode = false;
+    Object.defineProperty(filtered, 'isRaw', {
+        get: () => (typeof real.isRaw === 'boolean' ? real.isRaw : rawMode),
+        set: (value) => { rawMode = value; },
+    });
+    // A terminal read error is unrecoverable; never let it crash as a second
+    // unhandled 'error' event on the proxy.
+    filtered.on('error', () => { });
+    const proxied = filtered;
+    let hold = '';
+    let holdTimer;
+    let insidePaste = false;
+    // Once the terminal has spoken bracketed paste, plain data is real
+    // keystrokes and the `\n` heuristic is retired for this session.
+    let bracketedSeen = false;
+    proxied.pasteActive = false;
+    const emit = (text, pasted) => {
+        if (!text)
+            return;
+        proxied.pasteActive = pasted;
+        // PassThrough drains listeners synchronously, so every keypress decoded
+        // from this write observes pasteActive.
+        filtered.write(text);
+        proxied.pasteActive = false;
+    };
+    const clearHoldTimer = () => {
+        if (holdTimer) {
+            clearTimeout(holdTimer);
+            holdTimer = undefined;
+        }
+    };
+    /** A partial marker held across reads must never wedge a bare Escape. */
+    const armHoldFlush = () => {
+        if (holdTimer || !hold || insidePaste)
+            return;
+        holdTimer = setTimeout(() => {
+            holdTimer = undefined;
+            if (hold) {
+                const pending = hold;
+                hold = '';
+                emit(pending, false);
+            }
+        }, holdFlushMs);
+        holdTimer.unref?.();
+    };
+    /** Consumes paste content up to (and including) the end marker or chunk end. */
+    const consumePasteBody = (text) => {
+        let rest = text;
+        for (;;) {
+            const end = rest.indexOf(MARKER_END);
+            if (end < 0) {
+                // Keep a potential partial end marker back so a read boundary
+                // cannot swallow its tail.
+                const keep = trailingMarkerPrefix(rest, MARKER_END);
+                const body = rest.slice(0, rest.length - keep);
+                if (body)
+                    emit(body.replace(CRLF, '\n').replace(CR, '\n'), true);
+                hold = rest.slice(rest.length - keep);
+                insidePaste = true;
+                return '';
+            }
+            // Newlines inside a paste are literal content, never key presses.
+            const body = rest.slice(0, end);
+            if (body)
+                emit(body.replace(CRLF, '\n').replace(CR, '\n'), true);
+            insidePaste = false;
+            return rest.slice(end + MARKER_END.length);
+        }
+    };
+    /** Plain (marker-free) chunk: typed keystrokes, or a bracketless paste burst. */
+    const handlePlain = (chunk) => {
+        if (!chunk)
+            return;
+        // Hold back a partial start marker so a read boundary cannot leak it
+        // into the draft as stray characters.
+        const keep = trailingMarkerPrefix(chunk, MARKER_START);
+        if (keep > 0) {
+            hold = chunk.slice(chunk.length - keep);
+            chunk = chunk.slice(0, chunk.length - keep);
+            if (!chunk) {
+                armHoldFlush();
+                return;
+            }
+        }
+        if (bracketedSeen) {
+            emit(chunk, false);
+            return;
+        }
+        // A lone CR (typed Enter) keeps submitting; LF only rides in pastes.
+        // `\r\n` as a whole chunk is also a keyboard Enter (LF-mode terminals).
+        if (/^\r?$/.test(chunk) || chunk === '\r\n') {
+            emit(chunk === '\r\n' ? '\n' : chunk, false);
+            return;
+        }
+        if (/[\r\n]/.test(chunk)) {
+            emit(chunk.replace(CRLF, '\n').replace(CR, '\n'), true);
+        }
+        else {
+            emit(chunk, false);
+        }
+    };
+    const onData = (data) => {
+        clearHoldTimer();
+        let text = hold + (typeof data === 'string' ? data : decoder.write(data));
+        hold = '';
+        if (insidePaste)
+            text = consumePasteBody(text);
+        while (!insidePaste) {
+            const start = text.indexOf(MARKER_START);
+            if (start < 0)
+                break;
+            const before = text.slice(0, start);
+            text = text.slice(start + MARKER_START.length);
+            bracketedSeen = true;
+            if (before)
+                emit(before, false);
+            insidePaste = true;
+            text = consumePasteBody(text);
+        }
+        handlePlain(text);
+        armHoldFlush();
+    };
+    /** EOF or the real stream dying: flush what is held and close the proxy. */
+    const finish = () => {
+        clearHoldTimer();
+        if (hold) {
+            emit(hold, insidePaste);
+            hold = '';
+        }
+        if (!filtered.writableEnded)
+            filtered.end();
+    };
+    const onEnd = finish;
+    const onClose = finish;
+    const onError = (error) => {
+        filtered.destroy(error);
+    };
+    // Attach lazily: only start forwarding the real input once a consumer
+    // actually reads from this proxy. Tests monkeypatch `blessed.screen` and
+    // swap in their own input stream, so nothing ever consumes the proxy there —
+    // eagerly listening on the real stdin would accumulate listeners across
+    // tests and keep the process alive after the suite finished.
+    let attached = false;
+    const attach = () => {
+        if (attached)
+            return;
+        attached = true;
+        rawInput.on('data', onData);
+        rawInput.on('end', onEnd);
+        rawInput.on('close', onClose);
+        rawInput.on('error', onError);
+    };
+    filtered.on('newListener', (event) => {
+        if (event === 'data' || event === 'readable')
+            attach();
+    });
+    proxied.setRawMode = (mode) => {
+        rawMode = mode;
+        real.setRawMode?.(mode);
+    };
+    // Method overrides are installed via defineProperty so the PassThrough
+    // prototype methods remain reachable through their own names.
+    const override = (name, implementation) => {
+        Object.defineProperty(proxied, name, { value: implementation, writable: true, configurable: true });
+    };
+    override('pause', () => {
+        real.pause?.();
+        PassThrough.prototype.pause.call(filtered);
+    });
+    override('resume', () => {
+        real.resume?.();
+        PassThrough.prototype.resume.call(filtered);
+    });
+    override('destroy', ((error) => {
+        clearHoldTimer();
+        rawInput.removeListener('data', onData);
+        rawInput.removeListener('end', onEnd);
+        rawInput.removeListener('close', onClose);
+        rawInput.removeListener('error', onError);
+        // `filtered.destroy` resolves to this own override; calling through the
+        // prototype keeps teardown from recursing into itself.
+        PassThrough.prototype.destroy.call(filtered, error);
+    }));
+    return proxied;
+}

package/dist/ui/commands.js

@@ -1,6 +1,18 @@
 export const SLASH_COMMANDS = [
     { name: '/provider', description: 'Manage providers' },
     { name: '/model', description: 'Choose a model' },
+    { name: '/aside', description: 'Queue an aside to fold into the next message' },
+    { name: '/btw', description: 'Ask in a side conversation forked from this one' },
+    { name: '/back', description: 'Return from a side conversation to the parent session' },
+    { name: '/fork', description: 'Copy this conversation into a new saved session' },
+    { name: '/goal', description: 'Set a standing goal for this session' },
+    { name: '/cd', description: 'Switch the working directory' },
+    { name: '/pwd', description: 'Show the working directory' },
+    { name: '/worktree', description: 'Create or enter an isolated git worktree' },
+    { name: '/worktree-list', description: 'List managed worktrees' },
+    { name: '/worktree-exit', description: 'Return to the main checkout' },
+    { name: '/worktree-remove', description: 'Remove a clean worktree (branch kept)' },
+    { name: '/theme', description: 'Switch color theme' },
     { name: '/agents', description: 'Inspect agent specs' },
     { name: '/sessions', description: 'Open a saved conversation' },
     { name: '/new', description: 'Start a conversation' },