@oracle-agent/oracle 0.13.1 → 0.14.0

package/src/tui/input.mjs

@@ -0,0 +1,501 @@
+const EMPTY = Buffer.alloc(0);
+
+const SPECIAL_NAMES = new Set([
+  "return",
+  "backspace",
+  "tab",
+  "escape",
+  "up",
+  "down",
+  "left",
+  "right",
+  "home",
+  "end",
+  "delete",
+  "insert",
+  "pageup",
+  "pagedown",
+  "unknown",
+]);
+
+const CSI_FINALS = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  H: "home",
+  F: "end",
+  P: "f1",
+  Q: "f2",
+  R: "f3",
+  S: "f4",
+};
+
+const TILDE_CODES = {
+  1: "home",
+  2: "insert",
+  3: "delete",
+  4: "end",
+  5: "pageup",
+  6: "pagedown",
+  7: "home",
+  8: "end",
+};
+
+function makeKey({ name = null, ctrl = false, meta = false, shift = false, sequence = "" }) {
+  return { name, ctrl, meta, shift, sequence };
+}
+
+function utf8Length(lead) {
+  if (lead < 0x80) return 1;
+  if (lead >= 0xf0) return 4;
+  if (lead >= 0xe0) return 3;
+  if (lead >= 0xc0) return 2;
+  return 1;
+}
+
+function isFinalByte(b) {
+  return b >= 0x40 && b <= 0x7e;
+}
+
+function charKey(text) {
+  const lower = text.toLowerCase();
+  return makeKey({
+    name: lower,
+    shift: text !== lower,
+    sequence: text,
+  });
+}
+
+function controlKey(b) {
+  if (b === 0x0d) return makeKey({ name: "return", sequence: "\r" });
+  if (b === 0x0a) return makeKey({ name: "return", sequence: "\n" });
+  if (b === 0x09) return makeKey({ name: "tab", sequence: "\t" });
+  if (b === 0x7f) return makeKey({ name: "backspace", sequence: "\u007f" });
+  if (b === 0x08) return makeKey({ name: "backspace", sequence: "\b" });
+  if (b >= 0x01 && b <= 0x1a) {
+    return makeKey({
+      name: String.fromCharCode(b + 0x60),
+      ctrl: true,
+      sequence: String.fromCharCode(b),
+    });
+  }
+  return makeKey({ name: "unknown", sequence: String.fromCharCode(b) });
+}
+
+function csiKey(sequence) {
+  const match = /^\u001b[\[O](\d*)(?:;(\d+))?(.)$/s.exec(sequence);
+  if (!match) return makeKey({ name: "unknown", sequence });
+  const first = match[1] === "" ? null : Number(match[1]);
+  const second = match[2] === undefined ? null : Number(match[2]);
+  const final = match[3];
+
+  let name = null;
+  let modifier = second;
+  if (final === "~") {
+    name = TILDE_CODES[first] ?? null;
+  } else {
+    name = CSI_FINALS[final] ?? null;
+    if (modifier === null && first !== null && first > 1) modifier = first;
+  }
+  if (!name) return makeKey({ name: "unknown", sequence });
+
+  const bits = modifier === null ? 0 : Math.max(0, modifier - 1);
+  return makeKey({
+    name,
+    shift: (bits & 1) !== 0,
+    meta: (bits & 2) !== 0,
+    ctrl: (bits & 4) !== 0,
+    sequence,
+  });
+}
+
+function decodeEscape(buf, start, keys, flush) {
+  const escape = () => {
+    keys.push(makeKey({ name: "escape", sequence: "\u001b" }));
+    return 1;
+  };
+  if (start + 1 >= buf.length) return flush ? escape() : 0;
+
+  const next = buf[start + 1];
+  if (next === 0x5b || next === 0x4f) {
+    let j = start + 2;
+    while (j < buf.length && !isFinalByte(buf[j])) j += 1;
+    if (j >= buf.length) return flush ? escape() : 0;
+    keys.push(csiKey(buf.toString("utf8", start, j + 1)));
+    return j + 1 - start;
+  }
+  if (next === 0x1b) return escape();
+
+  const width = utf8Length(next);
+  if (start + 1 + width > buf.length) return flush ? escape() : 0;
+  const text = buf.toString("utf8", start + 1, start + 1 + width);
+  const lower = text.toLowerCase();
+  keys.push(makeKey({
+    name: lower,
+    meta: true,
+    shift: text !== lower,
+    sequence: `\u001b${text}`,
+  }));
+  return 1 + width;
+}
+
+function decodeChunk(buf, flush) {
+  const keys = [];
+  let i = 0;
+  while (i < buf.length) {
+    const b = buf[i];
+    if (b === 0x1b) {
+      const consumed = decodeEscape(buf, i, keys, flush);
+      if (consumed === 0) return { keys, rest: Buffer.from(buf.subarray(i)) };
+      i += consumed;
+      continue;
+    }
+    if (b < 0x20 || b === 0x7f) {
+      keys.push(controlKey(b));
+      i += 1;
+      continue;
+    }
+    const width = utf8Length(b);
+    if (i + width > buf.length) {
+      if (!flush) return { keys, rest: Buffer.from(buf.subarray(i)) };
+      keys.push(charKey(buf.toString("utf8", i)));
+      return { keys, rest: EMPTY };
+    }
+    keys.push(charKey(buf.toString("utf8", i, i + width)));
+    i += width;
+  }
+  return { keys, rest: EMPTY };
+}
+
+function toBuffer(chunk) {
+  if (Buffer.isBuffer(chunk)) return chunk;
+  if (chunk === null || chunk === undefined) return EMPTY;
+  if (typeof chunk === "string") return Buffer.from(chunk, "utf8");
+  return Buffer.from(chunk);
+}
+
+let decodeKeysPending = EMPTY;
+
+export function decodeKeys(chunk) {
+  const buf = decodeKeysPending.length === 0
+    ? toBuffer(chunk)
+    : Buffer.concat([decodeKeysPending, toBuffer(chunk)]);
+  const { keys, rest } = decodeChunk(buf, false);
+  if (rest.length === 1 && rest[0] === 0x1b) {
+    decodeKeysPending = EMPTY;
+    return [...keys, makeKey({ name: "escape", sequence: "\u001b" })];
+  }
+  decodeKeysPending = rest;
+  return keys;
+}
+
+export function createDecoder() {
+  let pending = EMPTY;
+  return {
+    push(chunk) {
+      const buf = pending.length === 0
+        ? toBuffer(chunk)
+        : Buffer.concat([pending, toBuffer(chunk)]);
+      const { keys, rest } = decodeChunk(buf, false);
+      pending = rest;
+      return keys;
+    },
+    flush() {
+      if (pending.length === 0) return [];
+      const { keys } = decodeChunk(pending, true);
+      pending = EMPTY;
+      return keys;
+    },
+    get pending() {
+      return pending.length;
+    },
+  };
+}
+
+export function createEditorState({ history = [] } = {}) {
+  const entries = [...history];
+  return {
+    buffer: "",
+    cursor: 0,
+    history: entries,
+    historyIndex: entries.length,
+    draft: "",
+  };
+}
+
+function stepLeft(text, index) {
+  if (index <= 0) return 0;
+  const prev = index - 1;
+  const code = text.charCodeAt(prev);
+  if (code >= 0xdc00 && code <= 0xdfff && prev > 0) {
+    const lead = text.charCodeAt(prev - 1);
+    if (lead >= 0xd800 && lead <= 0xdbff) return prev - 1;
+  }
+  return prev;
+}
+
+function stepRight(text, index) {
+  if (index >= text.length) return text.length;
+  const code = text.charCodeAt(index);
+  if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) return index + 2;
+  return index + 1;
+}
+
+function next(state, patch) {
+  return { ...state, ...patch };
+}
+
+function live(state, patch) {
+  return next(state, { ...patch, historyIndex: state.history.length, draft: "" });
+}
+
+function isPrintable(key) {
+  if (key.ctrl || key.meta) return false;
+  if (!key.sequence) return false;
+  if (SPECIAL_NAMES.has(key.name)) return false;
+  for (const ch of key.sequence) {
+    const code = ch.codePointAt(0);
+    if (code < 0x20 || code === 0x7f) return false;
+  }
+  return true;
+}
+
+function killPrevWord(text, cursor) {
+  let i = cursor;
+  while (i > 0 && /\s/.test(text[i - 1])) i -= 1;
+  while (i > 0 && !/\s/.test(text[i - 1])) i -= 1;
+  return i;
+}
+
+function historyUp(state) {
+  if (state.historyIndex <= 0) return { state: next(state, {}), action: null };
+  const atLive = state.historyIndex >= state.history.length;
+  const index = state.historyIndex - 1;
+  const buffer = state.history[index] ?? "";
+  return {
+    state: next(state, {
+      buffer,
+      cursor: buffer.length,
+      historyIndex: index,
+      draft: atLive ? state.buffer : state.draft,
+    }),
+    action: null,
+  };
+}
+
+function historyDown(state) {
+  if (state.historyIndex >= state.history.length) return { state: next(state, {}), action: null };
+  const index = state.historyIndex + 1;
+  const restored = index >= state.history.length;
+  const buffer = restored ? state.draft : (state.history[index] ?? "");
+  return {
+    state: next(state, {
+      buffer,
+      cursor: buffer.length,
+      historyIndex: index,
+      draft: restored ? "" : state.draft,
+    }),
+    action: null,
+  };
+}
+
+function submit(state) {
+  const value = state.buffer.trim();
+  if (value === "") {
+    return {
+      state: live(state, { buffer: "", cursor: 0 }),
+      action: null,
+    };
+  }
+  const history = state.history[state.history.length - 1] === value
+    ? [...state.history]
+    : [...state.history, value];
+  return {
+    state: next(state, {
+      buffer: "",
+      cursor: 0,
+      history,
+      historyIndex: history.length,
+      draft: "",
+    }),
+    action: { type: "submit", value },
+  };
+}
+
+export function applyKey(state, key) {
+  if (!key) return { state: next(state, {}), action: null };
+  const { buffer, cursor } = state;
+
+  if (key.ctrl && !key.meta) {
+    switch (key.name) {
+      case "c":
+        return { state: live(state, { buffer: "", cursor: 0 }), action: { type: "cancel" } };
+      case "d":
+        if (buffer === "") return { state: next(state, {}), action: { type: "eof" } };
+        return { state: next(state, {}), action: null };
+      case "l":
+        return { state: next(state, {}), action: { type: "clear" } };
+      case "a":
+        return { state: next(state, { cursor: 0 }), action: null };
+      case "e":
+        return { state: next(state, { cursor: buffer.length }), action: null };
+      case "u":
+        return {
+          state: next(state, { buffer: buffer.slice(cursor), cursor: 0 }),
+          action: null,
+        };
+      case "k":
+        return { state: next(state, { buffer: buffer.slice(0, cursor) }), action: null };
+      case "w": {
+        const start = killPrevWord(buffer, cursor);
+        return {
+          state: next(state, {
+            buffer: buffer.slice(0, start) + buffer.slice(cursor),
+            cursor: start,
+          }),
+          action: null,
+        };
+      }
+      case "b":
+        return { state: next(state, { cursor: stepLeft(buffer, cursor) }), action: null };
+      case "f":
+        return { state: next(state, { cursor: stepRight(buffer, cursor) }), action: null };
+      default:
+        return { state: next(state, {}), action: null };
+    }
+  }
+
+  switch (key.name) {
+    case "return":
+      return submit(state);
+    case "left":
+      return { state: next(state, { cursor: stepLeft(buffer, cursor) }), action: null };
+    case "right":
+      return { state: next(state, { cursor: stepRight(buffer, cursor) }), action: null };
+    case "home":
+      return { state: next(state, { cursor: 0 }), action: null };
+    case "end":
+      return { state: next(state, { cursor: buffer.length }), action: null };
+    case "up":
+      return historyUp(state);
+    case "down":
+      return historyDown(state);
+    case "backspace": {
+      if (cursor === 0) return { state: next(state, {}), action: null };
+      const start = stepLeft(buffer, cursor);
+      return {
+        state: next(state, {
+          buffer: buffer.slice(0, start) + buffer.slice(cursor),
+          cursor: start,
+        }),
+        action: null,
+      };
+    }
+    case "delete": {
+      if (cursor >= buffer.length) return { state: next(state, {}), action: null };
+      const end = stepRight(buffer, cursor);
+      return {
+        state: next(state, { buffer: buffer.slice(0, cursor) + buffer.slice(end) }),
+        action: null,
+      };
+    }
+    default:
+      break;
+  }
+
+  if (isPrintable(key)) {
+    const text = key.sequence;
+    return {
+      state: next(state, {
+        buffer: buffer.slice(0, cursor) + text + buffer.slice(cursor),
+        cursor: cursor + text.length,
+      }),
+      action: null,
+    };
+  }
+
+  return { state: next(state, {}), action: null };
+}
+
+export function createInput(options = {}) {
+  const {
+    stdin,
+    stdout,
+    history = [],
+    onSubmit,
+    onCancel,
+    onEof,
+    onClear,
+    onRender,
+  } = options;
+
+  const input = stdin ?? process.stdin;
+  const output = stdout ?? process.stdout;
+  const decoder = createDecoder();
+  const handlers = {
+    submit: onSubmit,
+    cancel: onCancel,
+    eof: onEof,
+    clear: onClear,
+  };
+
+  let state = createEditorState({ history });
+  let started = false;
+  let rawApplied = false;
+  let priorRaw = false;
+
+  const emit = (action) => {
+    if (!action) return;
+    const handler = handlers[action.type];
+    if (typeof handler === "function") handler(action.value, state);
+  };
+
+  const onData = (chunk) => {
+    for (const key of decoder.push(chunk)) {
+      const result = applyKey(state, key);
+      state = result.state;
+      emit(result.action);
+      if (typeof onRender === "function") onRender(state);
+    }
+  };
+
+  return {
+    start() {
+      if (started) return;
+      started = true;
+      if (input.isTTY && typeof input.setRawMode === "function") {
+        priorRaw = input.isRaw === true;
+        input.setRawMode(true);
+        rawApplied = true;
+      }
+      if (typeof input.resume === "function") input.resume();
+      input.on("data", onData);
+      if (typeof onRender === "function") onRender(state);
+    },
+    stop() {
+      if (!started) return;
+      started = false;
+      if (typeof input.off === "function") input.off("data", onData);
+      else if (typeof input.removeListener === "function") input.removeListener("data", onData);
+      if (rawApplied && typeof input.setRawMode === "function") {
+        input.setRawMode(priorRaw);
+        rawApplied = false;
+      }
+      if (typeof input.pause === "function") input.pause();
+    },
+    getState() {
+      return state;
+    },
+    setState(nextState) {
+      state = nextState;
+      return state;
+    },
+    write(text) {
+      if (output && typeof output.write === "function") output.write(text);
+    },
+    get isRunning() {
+      return started;
+    },
+  };
+}

package/src/tui/memory.mjs

@@ -0,0 +1,105 @@
+/**
+ * Durable cross-session memory for the Oracle standalone agent.
+ * Read/write ~/.config/oracle/memory.json per session.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+
+const CONFIG_DIR = process.env.ORACLE_CONFIG_DIR || path.join(homedir(), ".config", "oracle");
+const MEMORY_FILE = path.join(CONFIG_DIR, "memory.json");
+const CHAR_LIMIT = 2_200;
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadStore() {
+  ensureDir(CONFIG_DIR);
+  try {
+    const raw = fs.readFileSync(MEMORY_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { version: 1, updatedAt: new Date().toISOString(), entries: [] };
+  }
+}
+
+function saveStore(store) {
+  ensureDir(CONFIG_DIR);
+  store.updatedAt = new Date().toISOString();
+  fs.writeFileSync(MEMORY_FILE, JSON.stringify(store, null, 2), { mode: 0o600 });
+}
+
+export function addMemory(key, content) {
+  const store = loadStore();
+  const existing = store.entries.findIndex((e) => e.key === key);
+  if (existing >= 0) {
+    store.entries[existing] = { key, content, addedAt: new Date().toISOString() };
+  } else {
+    store.entries.push({ key, content, addedAt: new Date().toISOString() });
+  }
+  while (JSON.stringify(store.entries).length > CHAR_LIMIT && store.entries.length > 1) {
+    store.entries.shift();
+  }
+  saveStore(store);
+}
+
+export function removeMemory(key) {
+  const store = loadStore();
+  const before = store.entries.length;
+  store.entries = store.entries.filter((e) => e.key !== key);
+  if (store.entries.length < before) {
+    saveStore(store);
+    return { ok: true };
+  }
+  return { ok: false };
+}
+
+export function getMemoryBlock() {
+  const store = loadStore();
+  if (store.entries.length === 0) return "";
+  const total = JSON.stringify(store.entries).length;
+  const pct = Math.round((total / CHAR_LIMIT) * 100);
+  const lines = store.entries.map((e) => `${e.key}: ${e.content}`);
+  return [
+    "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+    `MEMORY [${pct}% \u2014 ${total}/${CHAR_LIMIT} chars]`,
+    "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+    ...lines,
+  ].join("\n");
+}
+
+export const MEMORY_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "memory_add",
+      description: "Save a durable fact to memory for future sessions.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "Short unique key" },
+          content: { type: "string", description: "The fact to remember" },
+        },
+        required: ["key", "content"],
+        additionalProperties: false,
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "memory_remove",
+      description: "Remove a memory entry by key.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "The key to remove" },
+        },
+        required: ["key"],
+        additionalProperties: false,
+      },
+    },
+  },
+];

package/src/tui/meta-learn.mjs

@@ -0,0 +1,85 @@
+/**
+ * Meta-learning: automatically create skills from successful agent workflows.
+ */
+
+import { createSkill, listSkills } from "./skills-loader.mjs";
+
+const HISTORY = [];
+const SKILL_THRESHOLD = 5;
+const ERROR_RECOVERY_THRESHOLD = 1;
+
+export function recordTurn(record) {
+  HISTORY.push(record);
+  if (HISTORY.length > 20) HISTORY.shift();
+}
+
+export function analyzeForSkill() {
+  const recent = HISTORY.slice(-3);
+  if (recent.length < 1) return null;
+
+  const last = recent[recent.length - 1];
+
+  if (last.toolCalls >= SKILL_THRESHOLD && last.errors === 0) {
+    return {
+      shouldCreate: true,
+      suggestion: `You completed a ${last.toolCalls}-step workflow. Save it as a skill with skill_create.`,
+    };
+  }
+
+  const recoveries = recent.filter((t) => t.errors > 0 && t.recovered);
+  if (recoveries.length >= ERROR_RECOVERY_THRESHOLD && last.toolCalls >= 3) {
+    return {
+      shouldCreate: true,
+      suggestion: "You recovered from errors. Save the corrected approach as a skill.",
+    };
+  }
+
+  return { shouldCreate: false, suggestion: "No skill suggestions yet." };
+}
+
+export function generateSkillTemplate(taskDescription, toolNames) {
+  const name = taskDescription
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .trim()
+    .replace(/\s+/g, "-")
+    .slice(0, 48);
+
+  const toolsList = toolNames.map((t) => `  - ${t}`).join("\n");
+
+  return [
+    "---",
+    `name: ${name}`,
+    `description: ${taskDescription}`,
+    "---",
+    "",
+    `# ${taskDescription}`,
+    "",
+    "## Trigger",
+    "Use when: <describe when to use this skill>",
+    "",
+    "## Steps",
+    "1. <first step>",
+    "2. <second step>",
+    "",
+    "## Tools used",
+    toolsList,
+    "",
+    "## Pitfalls",
+    "- <common mistake>",
+    "",
+    "## Verification",
+    "- <how to verify>",
+  ].join("\n");
+}
+
+export const META_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "meta_analyze",
+      description: "Analyze recent interactions and suggest skills to create.",
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+    },
+  },
+];