@oxbit/cli 0.10.1 → 0.11.0

package/agent/dist/assets/memory-Bdy8hvTl.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { mkdirSync, appendFileSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { w as walkFiles } from "../index.js";
+import "node:util";
+import "node:readline";
+import "node:fs/promises";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+const FILE_LIST_TTL_MS = 1e4;
+const FILE_MATCHES = 2e3;
+const HISTORY_LIMIT = 500;
+const subsequence = (query, path) => {
+  let at = 0;
+  for (const char of query) {
+    at = path.indexOf(char, at) + 1;
+    if (!at) return false;
+  }
+  return true;
+};
+function memoryTuiConnection(initial, options = {}) {
+  let connection = initial;
+  let info = { provider: options.provider, usingChatGPTPlan: options.usingChatGPTPlan };
+  let mode = options.mode;
+  const listeners = /* @__PURE__ */ new Set();
+  let permission;
+  const attach = (target) => [
+    target.onUpdate((sessionId, update) => {
+      for (const listener of [...listeners]) {
+        try {
+          listener(sessionId, update);
+        } catch {
+        }
+      }
+    }),
+    target.onPermission(async (request) => permission ? (await permission(request)).outcome : { outcome: "cancelled" })
+  ];
+  let detach = attach(connection);
+  const listed = /* @__PURE__ */ new Map();
+  const files = (cwd) => {
+    const cached = listed.get(cwd);
+    if (cached && Date.now() - cached.at < FILE_LIST_TTL_MS) return cached.files;
+    const entry = { at: Date.now(), files: walkFiles(cwd).catch(() => []) };
+    listed.set(cwd, entry);
+    return entry.files;
+  };
+  const settings = options.settings;
+  return {
+    get connection() {
+      return connection;
+    },
+    async replace(next, nextInfo) {
+      const previous = connection;
+      for (const stop of detach) stop();
+      connection = next;
+      detach = attach(next);
+      info = { ...nextInfo };
+      await previous.close();
+    },
+    info: () => ({ ...info }),
+    async newSession(cwd) {
+      const state = await connection.newSession({ cwd });
+      if (!mode || !state.modes || state.modes.currentModeId === mode) return state;
+      await connection.setMode(state.sessionId, mode);
+      return { ...state, modes: { ...state.modes, currentModeId: mode } };
+    },
+    loadSession: async (sessionId, cwd) => await connection.loadSession(sessionId, { cwd }),
+    listSessions: async (cwd) => (await connection.listSessions(cwd)).sessions,
+    prompt: (sessionId, prompt) => connection.prompt(sessionId, prompt),
+    cancel: (sessionId) => connection.cancel(sessionId),
+    setMode: (sessionId, modeId) => connection.setMode(sessionId, modeId),
+    setModel: async (sessionId, modelId) => await connection.setModel(sessionId, modelId),
+    setConfigOption: async (sessionId, configId, value) => await connection.setConfigOption(sessionId, configId, value),
+    onUpdate(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    onPermission(handler) {
+      permission = handler;
+      return () => {
+        if (permission === handler) permission = void 0;
+      };
+    },
+    async listFiles(query, cwd) {
+      const term = query.toLowerCase();
+      return (await files(cwd)).filter((path) => subsequence(term, path.toLowerCase())).slice(0, FILE_MATCHES);
+    },
+    ...settings ? { settings: {
+      panel: (id, context) => settings.panel(id, context),
+      toggle: (id, rowId, enabled, context) => settings.toggle(id, rowId, enabled, context),
+      async choose(id, rowId, value, context) {
+        const change = await settings.choose(id, rowId, value, context);
+        if (change.mode) mode = change.mode;
+        return change;
+      },
+      act: (id, rowId, actionId, inputs, context) => settings.act(id, rowId, actionId, inputs, context)
+    } } : {}
+  };
+}
+function fileHistory(path) {
+  return {
+    load() {
+      try {
+        return readFileSync(path, "utf8").split("\n").flatMap((line) => {
+          try {
+            const entry = JSON.parse(line);
+            return typeof entry === "string" ? [entry] : [];
+          } catch {
+            return [];
+          }
+        }).slice(-HISTORY_LIMIT);
+      } catch {
+        return [];
+      }
+    },
+    save(entry) {
+      try {
+        mkdirSync(dirname(path), { recursive: true, mode: 448 });
+        appendFileSync(path, `${JSON.stringify(entry)}
+`, { mode: 384 });
+        const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+        if (lines.length > HISTORY_LIMIT * 2) writeFileSync(path, `${lines.slice(-HISTORY_LIMIT).join("\n")}
+`, { mode: 384 });
+      } catch {
+      }
+    }
+  };
+}
+export {
+  fileHistory,
+  memoryTuiConnection
+};
+//# sourceMappingURL=memory-Bdy8hvTl.js.map