@lawrence369/loop-cli 0.1.0

package/dist/ui/renderer.js

@@ -0,0 +1,106 @@
+import { dim, formatBytes } from "./colors.js";
+const TERMINAL_RESET = "\x1b[0m\x1b[?25h\x1b[?2026l\x1b[?1049l\x1b[?1047l\x1b[?47l";
+export class PtyRenderer {
+    color = (s) => s;
+    engineLabel = "";
+    role = "";
+    receivedBytes = 0;
+    started = false;
+    endedWithLineBreak = true;
+    start(engineLabel, role, color) {
+        if (this.started)
+            return;
+        this.started = true;
+        this.color = color;
+        this.engineLabel = engineLabel;
+        this.role = role;
+        this.receivedBytes = 0;
+        const header = this.color(`  \u250C\u2500 \u25A0 ${this.engineLabel} (${this.role}) ${"\u2500".repeat(Math.max(0, 44 - this.engineLabel.length - this.role.length - 3))}\u2510`);
+        console.log(header);
+        console.log(this.color("  \u2502"));
+        this.endedWithLineBreak = true;
+    }
+    write(data) {
+        if (!this.started)
+            return;
+        this.receivedBytes += Buffer.byteLength(data);
+        process.stdout.write(data);
+        this.endedWithLineBreak = /(?:\r\n|\r|\n)$/.test(data);
+    }
+    stop(stats) {
+        if (!this.started)
+            return;
+        this.started = false;
+        // Restore common terminal modes in case the executor CLI was killed mid-TUI
+        process.stdout.write(TERMINAL_RESET);
+        if (!this.endedWithLineBreak) {
+            process.stdout.write("\r\n");
+        }
+        const elapsed = formatElapsed(stats.elapsed_ms);
+        const bytes = formatBytes(stats.bytes);
+        console.log(this.color("  \u2502"));
+        const statsText = `\u2713 done ${dim(`(${elapsed}, ${bytes})`)}`;
+        const footer = this.color(`  \u2514${"\u2500".repeat(42)}`) +
+            ` ${statsText} ` +
+            this.color("\u2500\u2518");
+        console.log(footer);
+    }
+    get totalBytes() {
+        return this.receivedBytes;
+    }
+}
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const sec = ms / 1000;
+    if (sec < 60)
+        return `${sec.toFixed(1)}s`;
+    const min = Math.floor(sec / 60);
+    const remainSec = Math.floor(sec % 60);
+    return `${min}m${remainSec}s`;
+}
+/**
+ * Forward user input to the PTY while reserving a small set of
+ * loop control shortcuts.
+ * Returns a cleanup function.
+ */
+export function startKeystrokeHandler(writeToPty, opts) {
+    const isTTY = !!process.stdin.isTTY;
+    if (isTTY)
+        process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let lastCtrlC = 0;
+    function onData(data) {
+        const str = typeof data === "string" ? data : data.toString("utf8");
+        // Shift+Tab: toggle mode
+        if (str === "\x1b[Z") {
+            opts.onModeToggle();
+            return;
+        }
+        // Ctrl+D: done
+        if (str === "\x04") {
+            opts.onDone();
+            return;
+        }
+        // Ctrl+C: double-tap to cancel, single forwards to PTY
+        if (str === "\x03") {
+            const now = Date.now();
+            if (now - lastCtrlC < 500) {
+                opts.onCancel();
+                return;
+            }
+            lastCtrlC = now;
+            writeToPty(str);
+            return;
+        }
+        writeToPty(str);
+    }
+    process.stdin.on("data", onData);
+    return () => {
+        process.stdin.removeListener("data", onData);
+        if (isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    };
+}
+//# sourceMappingURL=renderer.js.map

package/dist/utils/ansi.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strip all ANSI escape sequences from a string.
+ * Delegates to the battle-tested `strip-ansi` package for robust PTY handling.
+ */
+export declare function stripAnsi(s: string): string;
+/**
+ * Returns true if the string consists entirely of ANSI escape codes
+ * (i.e., stripping them yields an empty string).
+ */
+export declare function isAnsiOnly(s: string): boolean;
+//# sourceMappingURL=ansi.d.ts.map

package/dist/utils/ansi.js

@@ -0,0 +1,16 @@
+import stripAnsiModule from "strip-ansi";
+/**
+ * Strip all ANSI escape sequences from a string.
+ * Delegates to the battle-tested `strip-ansi` package for robust PTY handling.
+ */
+export function stripAnsi(s) {
+    return stripAnsiModule(s);
+}
+/**
+ * Returns true if the string consists entirely of ANSI escape codes
+ * (i.e., stripping them yields an empty string).
+ */
+export function isAnsiOnly(s) {
+    return s.length > 0 && stripAnsiModule(s).length === 0;
+}
+//# sourceMappingURL=ansi.js.map

package/dist/utils/fs.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Ensure a directory exists, creating it recursively if needed.
+ */
+export declare function ensureDir(dir: string): Promise<void>;
+/**
+ * Append a JSON object as a single line to a JSONL file.
+ */
+export declare function appendJsonl(filePath: string, data: unknown): Promise<void>;
+/**
+ * Read all lines from a JSONL file, parsing each as JSON.
+ * Returns an empty array if the file does not exist.
+ */
+export declare function readJsonl<T>(filePath: string): Promise<T[]>;
+/**
+ * Atomically write a file by writing to a temp file then renaming.
+ */
+export declare function safeWriteFile(filePath: string, content: string): Promise<void>;
+/**
+ * Read a file's contents, returning null if it does not exist.
+ */
+export declare function safeReadFile(filePath: string): Promise<string | null>;
+/**
+ * Check if a file exists.
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Truncate a file to empty (or create it if it doesn't exist).
+ */
+export declare function truncateFile(filePath: string): Promise<void>;
+/**
+ * Read the last non-empty line from a file.
+ */
+export declare function readLastLine(filePath: string): Promise<string | null>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/utils/fs.js

@@ -0,0 +1,115 @@
+import { mkdir, appendFile, readFile, writeFile, access, rename, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+/**
+ * Ensure a directory exists, creating it recursively if needed.
+ */
+export async function ensureDir(dir) {
+    await mkdir(dir, { recursive: true });
+}
+/**
+ * Append a JSON object as a single line to a JSONL file.
+ */
+export async function appendJsonl(filePath, data) {
+    await ensureDir(dirname(filePath));
+    const line = JSON.stringify(data) + "\n";
+    await appendFile(filePath, line, "utf8");
+}
+/**
+ * Read all lines from a JSONL file, parsing each as JSON.
+ * Returns an empty array if the file does not exist.
+ */
+export async function readJsonl(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (isNodeError(err) && err.code === "ENOENT") {
+            return [];
+        }
+        throw err;
+    }
+    const lines = content.trim().split("\n").filter(Boolean);
+    const results = [];
+    for (const line of lines) {
+        try {
+            results.push(JSON.parse(line));
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return results;
+}
+/**
+ * Atomically write a file by writing to a temp file then renaming.
+ */
+export async function safeWriteFile(filePath, content) {
+    await ensureDir(dirname(filePath));
+    const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        await writeFile(tmpPath, content, "utf8");
+        await rename(tmpPath, filePath);
+    }
+    catch (err) {
+        // Clean up temp file on failure
+        try {
+            await unlink(tmpPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        throw err;
+    }
+}
+/**
+ * Read a file's contents, returning null if it does not exist.
+ */
+export async function safeReadFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (isNodeError(err) && err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+/**
+ * Check if a file exists.
+ */
+export async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Truncate a file to empty (or create it if it doesn't exist).
+ */
+export async function truncateFile(filePath) {
+    await ensureDir(dirname(filePath));
+    await writeFile(filePath, "", "utf8");
+}
+/**
+ * Read the last non-empty line from a file.
+ */
+export async function readLastLine(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const lines = content.trim().split("\n").filter(Boolean);
+    return lines.length > 0 ? lines[lines.length - 1] : null;
+}
+function isNodeError(err) {
+    return err instanceof Error && "code" in err;
+}
+//# sourceMappingURL=fs.js.map

package/dist/utils/lock.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Acquire a file-based lock, execute a function, then release.
+ * The lock file contains the PID of the holder.
+ * Stale locks (dead PID or older than 30s) are automatically cleaned.
+ */
+export declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, timeout?: number): Promise<T>;
+/**
+ * Atomically increment a counter file under a file lock.
+ * If the counter file is missing or corrupt, attempts to recover from 0.
+ */
+export declare function nextSeq(counterPath: string, lockPath: string): Promise<number>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/utils/lock.js

@@ -0,0 +1,116 @@
+import { openSync, writeSync, closeSync, readFileSync, writeFileSync, unlinkSync, statSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { isProcessAlive } from "./process.js";
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_POLL_MS = 25;
+const LOCK_STALE_MS = 30000;
+function isNodeError(err) {
+    return err instanceof Error && "code" in err;
+}
+function cleanupStaleLock(lockPath) {
+    let shouldRemove = false;
+    try {
+        const raw = readFileSync(lockPath, "utf8").trim();
+        const pid = parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            shouldRemove = true;
+        }
+        else if (!isProcessAlive(pid)) {
+            shouldRemove = true;
+        }
+    }
+    catch {
+        shouldRemove = true;
+    }
+    if (!shouldRemove) {
+        try {
+            const stat = statSync(lockPath);
+            if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                shouldRemove = true;
+            }
+        }
+        catch {
+            shouldRemove = true;
+        }
+    }
+    if (shouldRemove) {
+        try {
+            unlinkSync(lockPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Acquire a file-based lock, execute a function, then release.
+ * The lock file contains the PID of the holder.
+ * Stale locks (dead PID or older than 30s) are automatically cleaned.
+ */
+export async function withFileLock(lockPath, fn, timeout = LOCK_TIMEOUT_MS) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    const deadline = Date.now() + timeout;
+    let lockFd = null;
+    while (Date.now() < deadline) {
+        try {
+            lockFd = openSync(lockPath, "wx");
+            writeSync(lockFd, `${process.pid}\n`);
+            break;
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "EEXIST") {
+                cleanupStaleLock(lockPath);
+                await sleep(LOCK_POLL_MS);
+                continue;
+            }
+            throw err;
+        }
+    }
+    if (lockFd === null) {
+        throw new Error(`Failed to acquire file lock: ${lockPath} (timeout ${timeout}ms)`);
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        try {
+            closeSync(lockFd);
+        }
+        catch {
+            // Ignore
+        }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Atomically increment a counter file under a file lock.
+ * If the counter file is missing or corrupt, attempts to recover from 0.
+ */
+export async function nextSeq(counterPath, lockPath) {
+    return withFileLock(lockPath, async () => {
+        let current = 0;
+        try {
+            const raw = readFileSync(counterPath, "utf8").trim();
+            const parsed = parseInt(raw, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                current = parsed;
+            }
+        }
+        catch {
+            // Counter file missing or unreadable - start from 0
+        }
+        const next = current + 1;
+        mkdirSync(dirname(counterPath), { recursive: true });
+        writeFileSync(counterPath, `${next}\n`, "utf8");
+        return next;
+    });
+}
+//# sourceMappingURL=lock.js.map

package/dist/utils/process.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Check if a process with the given PID is alive.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Set up signal handlers for graceful shutdown.
+ * The cleanup function is called once on the first signal received.
+ */
+export declare function setupSignalHandlers(cleanup: () => Promise<void>): void;
+/**
+ * Daemonize a script by spawning it detached with stdio redirected to a log file.
+ * Returns the PID of the child process.
+ */
+export declare function daemonize(script: string, args: string[], logPath: string): number;
+/**
+ * Write the current process PID to a file.
+ */
+export declare function writePidFile(pidPath: string): void;
+/**
+ * Read a PID from a file, returning null if missing or invalid.
+ */
+export declare function readPidFile(pidPath: string): number | null;
+/**
+ * Remove a PID file.
+ */
+export declare function removePidFile(pidPath: string): void;
+/**
+ * Get the absolute path to a script within this package.
+ */
+export declare function resolveScript(relativePath: string): string;
+//# sourceMappingURL=process.d.ts.map

package/dist/utils/process.js

@@ -0,0 +1,111 @@
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync, unlinkSync, openSync, closeSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { mkdirSync } from "node:fs";
+function isNodeError(err) {
+    return err instanceof Error && "code" in err;
+}
+/**
+ * Check if a process with the given PID is alive.
+ */
+export function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (isNodeError(err) && err.code === "EPERM") {
+            // Process exists but we lack permission to signal it
+            return true;
+        }
+        return false;
+    }
+}
+/**
+ * Set up signal handlers for graceful shutdown.
+ * The cleanup function is called once on the first signal received.
+ */
+export function setupSignalHandlers(cleanup) {
+    let cleaning = false;
+    const handler = () => {
+        if (cleaning)
+            return;
+        cleaning = true;
+        cleanup().finally(() => {
+            process.exit(0);
+        });
+    };
+    process.on("SIGTERM", handler);
+    process.on("SIGINT", handler);
+    process.on("exit", () => {
+        // Synchronous cleanup on exit - best effort
+        if (!cleaning) {
+            cleaning = true;
+            // Can't await here, but we try to be helpful
+        }
+    });
+}
+/**
+ * Daemonize a script by spawning it detached with stdio redirected to a log file.
+ * Returns the PID of the child process.
+ */
+export function daemonize(script, args, logPath) {
+    mkdirSync(dirname(logPath), { recursive: true });
+    const logFd = openSync(logPath, "a");
+    const child = spawn(process.execPath, [script, ...args], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        cwd: process.cwd(),
+    });
+    child.unref();
+    closeSync(logFd);
+    const pid = child.pid;
+    if (pid === undefined) {
+        throw new Error("Failed to spawn daemon process");
+    }
+    return pid;
+}
+/**
+ * Write the current process PID to a file.
+ */
+export function writePidFile(pidPath) {
+    mkdirSync(dirname(pidPath), { recursive: true });
+    writeFileSync(pidPath, `${process.pid}\n`, "utf8");
+}
+/**
+ * Read a PID from a file, returning null if missing or invalid.
+ */
+export function readPidFile(pidPath) {
+    try {
+        const raw = readFileSync(pidPath, "utf8").trim();
+        const pid = parseInt(raw, 10);
+        if (Number.isFinite(pid) && pid > 0) {
+            return pid;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove a PID file.
+ */
+export function removePidFile(pidPath) {
+    try {
+        unlinkSync(pidPath);
+    }
+    catch {
+        // Ignore - file may not exist
+    }
+}
+/**
+ * Get the absolute path to a script within this package.
+ */
+export function resolveScript(relativePath) {
+    return resolve(relativePath);
+}
+//# sourceMappingURL=process.js.map

package/dist/utils/pty-filter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PTY output classification and filtering.
+ *
+ * Ported from iterloop's pty-session.ts — classifies raw terminal output lines
+ * into content, status updates, or ignorable TUI noise so that only meaningful
+ * text reaches the reviewer and transcript.
+ */
+export type LineClass = "content" | "status" | "ignore";
+/**
+ * Classify a single (ANSI-stripped) line of PTY output.
+ *
+ * - `"content"` — meaningful AI output to keep
+ * - `"status"`  — transient status / spinner text
+ * - `"ignore"`  — TUI chrome, empty lines, noise
+ */
+export declare function classifyLine(line: string, engine?: string): LineClass;
+/**
+ * Filter raw PTY output to extract only meaningful content.
+ *
+ * Strips TUI chrome, spinners, box-drawing, update notices, and other noise.
+ * For Claude output, strips the ⏺ content marker prefix.
+ *
+ * Result is capped at ~50 KB (last 50 KB on overflow).
+ */
+export declare function filterOutput(raw: string, _engine?: string): string;
+/**
+ * Remove duplicate consecutive lines (TUI re-renders can emit the same
+ * content multiple times).  Comparison ignores whitespace differences.
+ */
+export declare function deduplicateLines(lines: string[]): string[];
+//# sourceMappingURL=pty-filter.d.ts.map