@steipete/oracle 0.9.0 → 0.10.0

package/dist/scripts/agent-send.js

@@ -12,8 +12,8 @@
  *   --escape                   Send ESC before typing (to interrupt/resume)
  *   --wait-ms N                Extra wait (ms) after typing before Enter
  */
-import { spawnSync } from 'node:child_process';
-import { sleepSync } from 'bun';
+import { spawnSync } from "node:child_process";
+import { sleepSync } from "bun";
 function usage(message) {
     if (message) {
         console.error(`Error: ${message}`);
@@ -29,44 +29,44 @@ Examples:
 }
 function parseArgs(argv) {
     let session;
-    let entry = 'single';
+    let entry = "single";
     let shouldEscape = false;
     let waitMs = 400;
-    const literalSeparator = argv.indexOf('--');
+    const literalSeparator = argv.indexOf("--");
     const optionPart = literalSeparator === -1 ? argv : argv.slice(0, literalSeparator);
     const literalPart = literalSeparator === -1 ? [] : argv.slice(literalSeparator + 1);
     for (let i = 0; i < optionPart.length; i += 1) {
         const token = optionPart[i];
-        if (!token.startsWith('--')) {
+        if (!token.startsWith("--")) {
             usage(`Unexpected argument: ${token}`);
         }
         const key = token.slice(2);
         switch (key) {
-            case 'session': {
+            case "session": {
                 const value = optionPart[i + 1];
                 if (!value)
-                    usage('--session requires a value');
+                    usage("--session requires a value");
                 session = value;
                 i += 1;
                 break;
             }
-            case 'entry': {
+            case "entry": {
                 const value = optionPart[i + 1];
-                if (value !== 'single' && value !== 'double' && value !== 'none') {
+                if (value !== "single" && value !== "double" && value !== "none") {
                     usage(`Unknown entry mode: ${value}`);
                 }
                 entry = value;
                 i += 1;
                 break;
             }
-            case 'escape': {
+            case "escape": {
                 shouldEscape = true;
                 break;
             }
-            case 'wait-ms': {
+            case "wait-ms": {
                 const value = optionPart[i + 1];
                 if (!value || Number.isNaN(Number.parseInt(value, 10))) {
-                    usage('--wait-ms requires an integer value');
+                    usage("--wait-ms requires an integer value");
                 }
                 waitMs = Number.parseInt(value, 10);
                 i += 1;
@@ -76,30 +76,30 @@ function parseArgs(argv) {
                 usage(`Unknown option: --${key}`);
         }
     }
-    const message = literalPart.join(' ').trim();
+    const message = literalPart.join(" ").trim();
     if (!session)
-        usage('Missing --session');
+        usage("Missing --session");
     if (!message)
-        usage('Missing message (provide text after -- separator)');
+        usage("Missing message (provide text after -- separator)");
     return { session, entry, escape: shouldEscape, waitMs, message };
 }
 function runTmux(args, allowFailure = false) {
-    const result = spawnSync('tmux', args, { encoding: 'utf8' });
+    const result = spawnSync("tmux", args, { encoding: "utf8" });
     if (result.error) {
         if (allowFailure)
-            return '';
+            return "";
         throw result.error;
     }
     if (result.status !== 0) {
         if (allowFailure)
-            return result.stderr?.trim() ?? '';
-        throw new Error(`tmux ${args.join(' ')} failed: ${result.stderr?.trim()}`);
+            return result.stderr?.trim() ?? "";
+        throw new Error(`tmux ${args.join(" ")} failed: ${result.stderr?.trim()}`);
     }
-    return result.stdout?.trimEnd() ?? '';
+    return result.stdout?.trimEnd() ?? "";
 }
 function ensureSession(target) {
-    const session = target.split(':')[0] ?? target;
-    const result = spawnSync('tmux', ['has-session', '-t', session]);
+    const session = target.split(":")[0] ?? target;
+    const result = spawnSync("tmux", ["has-session", "-t", session]);
     if (result.status !== 0) {
         usage(`tmux session '${session}' not found. Start it first (e.g., tmux new-session -s ${session} ...)`);
     }
@@ -107,35 +107,35 @@ function ensureSession(target) {
 function sendMessage(options) {
     ensureSession(options.session);
     if (options.escape) {
-        runTmux(['send-keys', '-t', options.session, 'Escape'], true);
+        runTmux(["send-keys", "-t", options.session, "Escape"], true);
         sleepSync(200);
     }
     // Clear existing prompt
-    runTmux(['send-keys', '-t', options.session, 'Escape'], true);
+    runTmux(["send-keys", "-t", options.session, "Escape"], true);
     sleepSync(120);
-    runTmux(['send-keys', '-t', options.session, 'C-u'], true);
+    runTmux(["send-keys", "-t", options.session, "C-u"], true);
     sleepSync(120);
     // Type the message
-    runTmux(['send-keys', '-t', options.session, '-l', options.message], true);
+    runTmux(["send-keys", "-t", options.session, "-l", options.message], true);
     sleepSync(Math.max(120, options.waitMs));
     // Send Enter(s)
-    const pressEnter = () => runTmux(['send-keys', '-t', options.session, 'C-m'], true);
+    const pressEnter = () => runTmux(["send-keys", "-t", options.session, "C-m"], true);
     switch (options.entry) {
-        case 'single':
+        case "single":
             pressEnter();
             break;
-        case 'double':
+        case "double":
             pressEnter();
             sleepSync(200);
             pressEnter();
             break;
-        case 'none':
+        case "none":
             break;
         default:
             usage(`Unsupported entry mode: ${options.entry}`);
     }
     sleepSync(600);
-    const tail = runTmux(['capture-pane', '-pt', options.session, '-S', '-6'], true);
+    const tail = runTmux(["capture-pane", "-pt", options.session, "-S", "-6"], true);
     console.log(tail);
 }
 try {

package/dist/scripts/check.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env bun
-import process from 'node:process';
+import process from "node:process";
 const buildConfig = {
-    entrypoints: ['./bin/oracle-cli.js'],
-    outdir: './.bun-check',
-    target: 'bun',
+    entrypoints: ["./bin/oracle-cli.js"],
+    outdir: "./.bun-check",
+    target: "bun",
     minify: false,
     write: false,
 };
 const result = await Bun.build(buildConfig);
 if (!result.success) {
-    console.error('Build failed while checking syntax:');
+    console.error("Build failed while checking syntax:");
     for (const log of result.logs) {
         console.error(log.message);
         if (log.position) {
@@ -18,4 +18,4 @@ if (!result.success) {
     }
     process.exit(1);
 }
-console.log('Syntax OK');
+console.log("Syntax OK");

package/dist/scripts/debug/extract-chatgpt-response.js

@@ -1,5 +1,5 @@
-import puppeteer from 'puppeteer-core';
-const port = parseInt(process.argv[2] || '52990', 10);
+import puppeteer from "puppeteer-core";
+const port = parseInt(process.argv[2] || "52990", 10);
 async function main() {
     const browser = await puppeteer.connect({
         browserURL: `http://127.0.0.1:${port}`,
@@ -9,24 +9,24 @@ async function main() {
     let targetPage = null;
     for (const page of pages) {
         const url = page.url();
-        if (url.includes('chatgpt.com/c/')) {
+        if (url.includes("chatgpt.com/c/")) {
             targetPage = page;
             break;
         }
     }
     if (!targetPage) {
-        console.error('ChatGPT conversation page not found');
+        console.error("ChatGPT conversation page not found");
         process.exit(1);
     }
-    console.error('Found page:', await targetPage.url());
+    console.error("Found page:", await targetPage.url());
     // Extract the last assistant message
     const content = (await targetPage.evaluate(() => {
         // Try multiple selectors for ChatGPT's assistant messages
         const selectors = [
             '[data-message-author-role="assistant"] .markdown',
             '[data-message-author-role="assistant"]',
-            '.agent-turn .markdown',
-            '.agent-turn',
+            ".agent-turn .markdown",
+            ".agent-turn",
         ];
         for (const selector of selectors) {
             const elements = document.querySelectorAll(selector);
@@ -41,10 +41,10 @@ async function main() {
         }
         // Debug: show what's on the page
         const body = document.body.innerHTML;
-        return { error: 'No messages found', bodyLength: body.length, sample: body.slice(0, 2000) };
+        return { error: "No messages found", bodyLength: body.length, sample: body.slice(0, 2000) };
     }));
-    if ('error' in content) {
-        console.error('Error:', JSON.stringify(content, null, 2));
+    if ("error" in content) {
+        console.error("Error:", JSON.stringify(content, null, 2));
         process.exit(1);
     }
     console.log(content.text);

package/dist/scripts/docs-list.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env tsx
-import { readdirSync, readFileSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { compact } from 'es-toolkit';
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compact } from "es-toolkit";
 const docsListFile = fileURLToPath(import.meta.url);
 const docsListDir = dirname(docsListFile);
-const DOCS_DIR = join(docsListDir, '..', 'docs');
-const EXCLUDED_DIRS = new Set(['archive', 'research']);
+const DOCS_DIR = join(docsListDir, "..", "docs");
+const EXCLUDED_DIRS = new Set(["archive", "research"]);
 function walkMarkdownFiles(dir, base = dir) {
     const entries = readdirSync(dir, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-        if (entry.name.startsWith('.')) {
+        if (entry.name.startsWith(".")) {
             continue;
         }
         const fullPath = join(dir, entry.name);
@@ -21,37 +21,37 @@ function walkMarkdownFiles(dir, base = dir) {
             }
             files.push(...walkMarkdownFiles(fullPath, base));
         }
-        else if (entry.isFile() && entry.name.endsWith('.md')) {
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
             files.push(relative(base, fullPath));
         }
     }
     return files.sort((a, b) => a.localeCompare(b));
 }
 function extractMetadata(fullPath) {
-    const content = readFileSync(fullPath, 'utf8');
-    if (!content.startsWith('---')) {
-        return { summary: null, readWhen: [], error: 'missing front matter' };
+    const content = readFileSync(fullPath, "utf8");
+    if (!content.startsWith("---")) {
+        return { summary: null, readWhen: [], error: "missing front matter" };
     }
-    const endIndex = content.indexOf('\n---', 3);
+    const endIndex = content.indexOf("\n---", 3);
     if (endIndex === -1) {
-        return { summary: null, readWhen: [], error: 'unterminated front matter' };
+        return { summary: null, readWhen: [], error: "unterminated front matter" };
     }
     const frontMatter = content.slice(3, endIndex).trim();
-    const lines = frontMatter.split('\n');
+    const lines = frontMatter.split("\n");
     let summaryLine = null;
     const readWhen = [];
     let collectingField = null;
     for (const rawLine of lines) {
         const line = rawLine.trim();
-        if (line.startsWith('summary:')) {
+        if (line.startsWith("summary:")) {
             summaryLine = line;
             collectingField = null;
             continue;
         }
-        if (line.startsWith('read_when:')) {
-            collectingField = 'read_when';
-            const inline = line.slice('read_when:'.length).trim();
-            if (inline.startsWith('[') && inline.endsWith(']')) {
+        if (line.startsWith("read_when:")) {
+            collectingField = "read_when";
+            const inline = line.slice("read_when:".length).trim();
+            if (inline.startsWith("[") && inline.endsWith("]")) {
                 try {
                     const parsed = JSON.parse(inline.replace(/'/g, '"'));
                     if (Array.isArray(parsed)) {
@@ -64,14 +64,14 @@ function extractMetadata(fullPath) {
             }
             continue;
         }
-        if (collectingField === 'read_when') {
-            if (line.startsWith('- ')) {
+        if (collectingField === "read_when") {
+            if (line.startsWith("- ")) {
                 const hint = line.slice(2).trim();
                 if (hint) {
                     readWhen.push(hint);
                 }
             }
-            else if (line === '') {
+            else if (line === "") {
             }
             else {
                 collectingField = null;
@@ -79,19 +79,19 @@ function extractMetadata(fullPath) {
         }
     }
     if (!summaryLine) {
-        return { summary: null, readWhen, error: 'summary key missing' };
+        return { summary: null, readWhen, error: "summary key missing" };
     }
-    const summaryValue = summaryLine.slice('summary:'.length).trim();
+    const summaryValue = summaryLine.slice("summary:".length).trim();
     const normalized = summaryValue
-        .replace(/^['"]|['"]$/g, '')
-        .replace(/\s+/g, ' ')
+        .replace(/^['"]|['"]$/g, "")
+        .replace(/\s+/g, " ")
         .trim();
     if (!normalized) {
-        return { summary: null, readWhen, error: 'summary is empty' };
+        return { summary: null, readWhen, error: "summary is empty" };
     }
     return { summary: normalized, readWhen };
 }
-console.log('Listing all markdown files in docs folder:');
+console.log("Listing all markdown files in docs folder:");
 const markdownFiles = walkMarkdownFiles(DOCS_DIR);
 for (const relativePath of markdownFiles) {
     const fullPath = join(DOCS_DIR, relativePath);
@@ -99,11 +99,11 @@ for (const relativePath of markdownFiles) {
     if (summary) {
         console.log(`${relativePath} - ${summary}`);
         if (readWhen.length > 0) {
-            console.log(`  Read when: ${readWhen.join('; ')}`);
+            console.log(`  Read when: ${readWhen.join("; ")}`);
         }
     }
     else {
-        const reason = error ? ` - [${error}]` : '';
+        const reason = error ? ` - [${error}]` : "";
         console.log(`${relativePath}${reason}`);
     }
 }

package/dist/scripts/git-policy.js

@@ -1,20 +1,20 @@
-import { resolve } from 'node:path';
-const COMMIT_HELPER_SUBCOMMANDS = new Set(['add', 'commit']);
-const GUARDED_SUBCOMMANDS = new Set(['push', 'pull', 'merge', 'rebase', 'cherry-pick']);
+import { resolve } from "node:path";
+const COMMIT_HELPER_SUBCOMMANDS = new Set(["add", "commit"]);
+const GUARDED_SUBCOMMANDS = new Set(["push", "pull", "merge", "rebase", "cherry-pick"]);
 const DESTRUCTIVE_SUBCOMMANDS = new Set([
-    'reset',
-    'checkout',
-    'clean',
-    'restore',
-    'switch',
-    'stash',
-    'branch',
-    'filter-branch',
-    'fast-import',
+    "reset",
+    "checkout",
+    "clean",
+    "restore",
+    "switch",
+    "stash",
+    "branch",
+    "filter-branch",
+    "fast-import",
 ]);
 export function extractGitInvocation(commandArgs) {
     for (const [index, token] of commandArgs.entries()) {
-        if (token === 'git' || token.endsWith('/git')) {
+        if (token === "git" || token.endsWith("/git")) {
             return { index, argv: commandArgs.slice(index) };
         }
     }
@@ -24,21 +24,21 @@ export function findGitSubcommand(commandArgs) {
     if (commandArgs.length <= 1) {
         return null;
     }
-    const optionsWithValue = new Set(['-C', '--git-dir', '--work-tree', '-c']);
+    const optionsWithValue = new Set(["-C", "--git-dir", "--work-tree", "-c"]);
     let index = 1;
     while (index < commandArgs.length) {
         const token = commandArgs[index];
         if (token === undefined) {
             break;
         }
-        if (token === '--') {
+        if (token === "--") {
             const next = commandArgs[index + 1];
             return next ? { name: next, index: index + 1 } : null;
         }
-        if (!token.startsWith('-')) {
+        if (!token.startsWith("-")) {
             return { name: token, index };
         }
-        if (token.includes('=')) {
+        if (token.includes("=")) {
             index += 1;
             continue;
         }
@@ -59,7 +59,7 @@ export function determineGitWorkdir(baseDir, gitArgs, command) {
         if (token === undefined) {
             break;
         }
-        if (token === '-C') {
+        if (token === "-C") {
             const next = gitArgs[index + 1];
             if (next) {
                 workDir = resolve(workDir, next);
@@ -67,7 +67,7 @@ export function determineGitWorkdir(baseDir, gitArgs, command) {
             index += 2;
             continue;
         }
-        if (token.startsWith('-C')) {
+        if (token.startsWith("-C")) {
             const pathSegment = token.slice(2);
             if (pathSegment.length > 0) {
                 workDir = resolve(workDir, pathSegment);
@@ -80,7 +80,9 @@ export function determineGitWorkdir(baseDir, gitArgs, command) {
 export function analyzeGitExecution(commandArgs, workspaceDir) {
     const invocation = extractGitInvocation(commandArgs);
     const command = invocation ? findGitSubcommand(invocation.argv) : null;
-    const workDir = invocation ? determineGitWorkdir(workspaceDir, invocation.argv, command) : workspaceDir;
+    const workDir = invocation
+        ? determineGitWorkdir(workspaceDir, invocation.argv, command)
+        : workspaceDir;
     return {
         invocation,
         command,
@@ -108,9 +110,9 @@ export function isDestructiveGitSubcommand(command, gitArgv) {
     if (DESTRUCTIVE_SUBCOMMANDS.has(subcommand)) {
         return true;
     }
-    if (subcommand === 'bisect') {
-        const action = gitArgv[command.index + 1] ?? '';
-        return action === 'reset';
+    if (subcommand === "bisect") {
+        const action = gitArgv[command.index + 1] ?? "";
+        return action === "reset";
     }
     return false;
 }

package/dist/scripts/run-cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 const rawArgs = process.argv.slice(2);
-const args = rawArgs[0] === '--' ? rawArgs.slice(1) : rawArgs;
+const args = rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
 const here = path.dirname(fileURLToPath(import.meta.url));
-const cliEntry = path.join(here, '../bin/oracle-cli.js');
-const child = spawn(process.execPath, ['--', cliEntry, ...args], {
-    stdio: 'inherit',
+const cliEntry = path.join(here, "../bin/oracle-cli.js");
+const child = spawn(process.execPath, ["--", cliEntry, ...args], {
+    stdio: "inherit",
 });
-child.on('exit', (code) => {
+child.on("exit", (code) => {
     process.exit(code ?? 0);
 });