augure 0.8.0 → 0.9.0

package/dist/chunk-M63XRSRV.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+// ../memory/dist/store.js
+import { readFile, writeFile, mkdir, readdir, access } from "fs/promises";
+import { join, dirname, relative } from "path";
+var FileMemoryStore = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  async read(path) {
+    return readFile(this.resolve(path), "utf-8");
+  }
+  async write(path, content) {
+    const full = this.resolve(path);
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, content, "utf-8");
+  }
+  async append(path, content) {
+    const full = this.resolve(path);
+    try {
+      const existing = await readFile(full, "utf-8");
+      await writeFile(full, existing + content, "utf-8");
+    } catch {
+      await this.write(path, content);
+    }
+  }
+  async list(directory) {
+    const dir = directory ? this.resolve(directory) : this.basePath;
+    return this.listRecursive(dir);
+  }
+  async exists(path) {
+    try {
+      await access(this.resolve(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolve(path) {
+    return join(this.basePath, path);
+  }
+  async listRecursive(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await this.listRecursive(full));
+      } else {
+        files.push(relative(this.basePath, full));
+      }
+    }
+    return files;
+  }
+};
+
+// ../memory/dist/ingest.js
+var EXTRACTION_PROMPT = `You are a memory extraction agent. Given a conversation, extract key factual observations about the user.
+
+Rules:
+- Return a markdown bullet list of observations (one per line, starting with "- ")
+- Only extract facts, preferences, decisions, plans, and personal details
+- Be concise: one fact per bullet
+- If there are no notable observations, return exactly "No notable observations."
+- Do not include greetings, small talk, or meta-conversation
+- Use present tense ("User prefers X", not "User said they prefer X")
+
+Example output:
+- User prefers TypeScript over JavaScript
+- User is building a project called Augure
+- User lives in Bordeaux, France`;
+var MemoryIngester = class {
+  llm;
+  store;
+  constructor(llm, store) {
+    this.llm = llm;
+    this.store = store;
+  }
+  async ingest(conversation) {
+    if (conversation.length === 0)
+      return;
+    const conversationText = conversation.filter((m) => m.role === "user" || m.role === "assistant").map((m) => `${m.role}: ${m.content}`).join("\n");
+    const messages = [
+      { role: "system", content: EXTRACTION_PROMPT },
+      { role: "user", content: conversationText }
+    ];
+    const response = await this.llm.chat(messages);
+    const observations = this.parseObservations(response.content);
+    if (observations.length === 0)
+      return;
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const block = `## ${date}
+${observations.map((o) => `- ${o}`).join("\n")}
+
+`;
+    await this.store.append("observations.md", block);
+  }
+  parseObservations(content) {
+    const lines = content.split("\n");
+    return lines.filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().slice(2).trim()).filter((line) => line.length > 0);
+  }
+};
+
+// ../memory/dist/retrieve.js
+var PRIORITY_FILES = ["identity.md", "observations.md"];
+var CHARS_PER_TOKEN = 4;
+var MemoryRetriever = class {
+  store;
+  maxChars;
+  constructor(store, options = {}) {
+    this.store = store;
+    const maxTokens = options.maxTokens ?? 1e4;
+    this.maxChars = maxTokens * CHARS_PER_TOKEN;
+  }
+  async retrieve() {
+    const allFiles = await this.safeList();
+    if (allFiles.length === 0)
+      return "";
+    const prioritySet = new Set(PRIORITY_FILES);
+    const orderedFiles = [
+      ...PRIORITY_FILES.filter((f) => allFiles.includes(f)),
+      ...allFiles.filter((f) => !prioritySet.has(f)).sort()
+    ];
+    const sections = [];
+    let totalChars = 0;
+    for (const file of orderedFiles) {
+      if (totalChars >= this.maxChars)
+        break;
+      try {
+        const content = await this.store.read(file);
+        const header = `### ${file}`;
+        const section = `${header}
+${content}`;
+        const sectionChars = section.length;
+        if (totalChars + sectionChars > this.maxChars) {
+          const remaining = this.maxChars - totalChars;
+          if (remaining > header.length + 50) {
+            sections.push(section.slice(0, remaining) + "\n[...truncated]");
+            totalChars = this.maxChars;
+          }
+          break;
+        }
+        sections.push(section);
+        totalChars += sectionChars;
+      } catch {
+      }
+    }
+    return sections.join("\n\n");
+  }
+  async safeList() {
+    try {
+      return await this.store.list();
+    } catch {
+      return [];
+    }
+  }
+};
+
+export {
+  FileMemoryStore,
+  MemoryIngester,
+  MemoryRetriever
+};

package/dist/chunk-TP6A6GFU.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import {
+  noopLogger
+} from "./chunk-62OPINAX.js";
+
+// ../sandbox/dist/container.js
+import { PassThrough } from "stream";
+var MAX_OUTPUT_BYTES = 1024 * 1024;
+var DockerContainer = class {
+  id;
+  _status = "idle";
+  raw;
+  demux;
+  constructor(raw, demux) {
+    this.raw = raw;
+    this.id = raw.id;
+    this.demux = demux;
+  }
+  get status() {
+    return this._status;
+  }
+  async exec(command, opts) {
+    this._status = "busy";
+    try {
+      return await this._exec(command, opts);
+    } finally {
+      if (this._status !== "stopped") {
+        this._status = "idle";
+      }
+    }
+  }
+  async stop() {
+    if (this._status === "stopped")
+      return;
+    try {
+      await this.raw.stop({ t: 5 });
+    } catch {
+    }
+    try {
+      await this.raw.remove({ force: true });
+    } catch {
+    }
+    this._status = "stopped";
+  }
+  /* ------------------------------------------------------------------ */
+  async _exec(command, opts) {
+    const createOpts = {
+      Cmd: ["sh", "-c", command],
+      AttachStdout: true,
+      AttachStderr: true
+    };
+    if (opts?.cwd) {
+      createOpts.WorkingDir = opts.cwd;
+    }
+    if (opts?.env) {
+      createOpts.Env = Object.entries(opts.env).map(([k, v]) => `${k}=${v}`);
+    }
+    const exec = await this.raw.exec(createOpts);
+    const stream = await exec.start({ hijack: true, stdin: false });
+    return new Promise((resolve, reject) => {
+      const stdoutPT = new PassThrough();
+      const stderrPT = new PassThrough();
+      const stdoutBufs = [];
+      const stderrBufs = [];
+      let stdoutLen = 0;
+      let stderrLen = 0;
+      stdoutPT.on("data", (chunk) => {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const remaining = MAX_OUTPUT_BYTES - stdoutLen;
+        if (remaining > 0) {
+          stdoutBufs.push(buf.subarray(0, remaining));
+          stdoutLen += Math.min(buf.length, remaining);
+        }
+      });
+      stderrPT.on("data", (chunk) => {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const remaining = MAX_OUTPUT_BYTES - stderrLen;
+        if (remaining > 0) {
+          stderrBufs.push(buf.subarray(0, remaining));
+          stderrLen += Math.min(buf.length, remaining);
+        }
+      });
+      let timer;
+      let settled = false;
+      let stdoutEnded = false;
+      let stderrEnded = false;
+      const cleanup = () => {
+        if (timer)
+          clearTimeout(timer);
+      };
+      if (opts?.timeout && opts.timeout > 0) {
+        const timeoutMs = opts.timeout * 1e3;
+        timer = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            stream.destroy();
+            reject(new Error(`Exec timed out after ${opts.timeout}s`));
+          }
+        }, timeoutMs);
+      }
+      const tryResolve = async () => {
+        if (!stdoutEnded || !stderrEnded)
+          return;
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        try {
+          const info = await exec.inspect();
+          resolve({
+            exitCode: info.ExitCode ?? 1,
+            stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
+            stderr: Buffer.concat(stderrBufs).toString("utf-8")
+          });
+        } catch (err) {
+          reject(err);
+        }
+      };
+      stdoutPT.on("end", () => {
+        stdoutEnded = true;
+        tryResolve();
+      });
+      stderrPT.on("end", () => {
+        stderrEnded = true;
+        tryResolve();
+      });
+      stream.on("error", (err) => {
+        if (!settled) {
+          settled = true;
+          cleanup();
+          reject(err);
+        }
+      });
+      this.demux(stream, stdoutPT, stderrPT);
+      stream.on("end", () => {
+        stdoutPT.end();
+        stderrPT.end();
+      });
+    });
+  }
+};
+
+// ../sandbox/dist/pool.js
+function parseMemory(mem) {
+  const match = mem.match(/^(\d+(?:\.\d+)?)\s*([mg])$/i);
+  if (!match)
+    throw new Error(`Invalid memory value: ${mem}`);
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  if (unit === "m")
+    return Math.round(value * 1024 * 1024);
+  return Math.round(value * 1024 * 1024 * 1024);
+}
+function parseCpu(cpu) {
+  const value = parseFloat(cpu);
+  if (Number.isNaN(value))
+    throw new Error(`Invalid cpu value: ${cpu}`);
+  return Math.round(value * 1e9);
+}
+var DockerContainerPool = class {
+  docker;
+  image;
+  maxTotal;
+  log;
+  // C3: idle cache keyed by trust level to prevent cross-trust reuse
+  idle = /* @__PURE__ */ new Map([
+    ["sandboxed", /* @__PURE__ */ new Set()],
+    ["trusted", /* @__PURE__ */ new Set()]
+  ]);
+  busy = /* @__PURE__ */ new Set();
+  containerTrust = /* @__PURE__ */ new Map();
+  constructor(docker, config) {
+    this.docker = docker;
+    this.image = config.image;
+    this.maxTotal = config.maxTotal;
+    this.log = config.logger ?? noopLogger;
+  }
+  get idleCount() {
+    let count = 0;
+    for (const set of this.idle.values())
+      count += set.size;
+    return count;
+  }
+  /* ---- acquire ---- */
+  async acquire(opts) {
+    this.log.debug(`Acquiring container: trust=${opts.trust} memory=${opts.memory} cpu=${opts.cpu}`);
+    const trustIdle = this.idle.get(opts.trust);
+    const cached = trustIdle.values().next();
+    if (!cached.done) {
+      const container2 = cached.value;
+      trustIdle.delete(container2);
+      this.busy.add(container2);
+      this.log.debug(`Reusing cached container: ${container2.id.slice(0, 12)}`);
+      return container2;
+    }
+    const total = this.idleCount + this.busy.size;
+    if (total >= this.maxTotal) {
+      this.log.error(`Pool limit reached: ${total}/${this.maxTotal}`);
+      throw new Error("Pool limit reached");
+    }
+    this.log.debug("Creating new container...");
+    const raw = await this.docker.createContainer(this.buildCreateOpts(opts));
+    await raw.start();
+    const modem = this.docker.modem;
+    const demux = modem.demuxStream.bind(modem);
+    const container = new DockerContainer(raw, demux);
+    this.containerTrust.set(container.id, opts.trust);
+    this.busy.add(container);
+    this.log.debug(`Container created: ${container.id.slice(0, 12)}`);
+    return container;
+  }
+  /* ---- release ---- */
+  async release(container) {
+    this.busy.delete(container);
+    if (container.status === "stopped") {
+      this.containerTrust.delete(container.id);
+      return;
+    }
+    const trust = this.containerTrust.get(container.id) ?? "sandboxed";
+    this.idle.get(trust).add(container);
+    this.log.debug(`Container released: ${container.id.slice(0, 12)} \u2192 idle (${trust})`);
+  }
+  /* ---- destroy ---- */
+  async destroy(container) {
+    this.busy.delete(container);
+    for (const set of this.idle.values())
+      set.delete(container);
+    this.containerTrust.delete(container.id);
+    await container.stop();
+  }
+  /* ---- destroyAll ---- */
+  async destroyAll() {
+    const all = [...this.busy];
+    for (const set of this.idle.values()) {
+      all.push(...set);
+      set.clear();
+    }
+    this.busy.clear();
+    this.containerTrust.clear();
+    await Promise.allSettled(all.map((c) => c.stop()));
+  }
+  /* ---- stats ---- */
+  stats() {
+    const idle = this.idleCount;
+    return {
+      idle,
+      busy: this.busy.size,
+      total: idle + this.busy.size,
+      maxTotal: this.maxTotal
+    };
+  }
+  /* ---- internal ---- */
+  buildCreateOpts(opts) {
+    const isSandboxed = opts.trust === "sandboxed";
+    const hostConfig = {
+      Memory: parseMemory(opts.memory),
+      NanoCpus: parseCpu(opts.cpu),
+      PidsLimit: 512
+      // I6: prevent fork bombs
+    };
+    if (!isSandboxed) {
+      hostConfig.NetworkMode = "host";
+    }
+    if (opts.mounts?.length) {
+      hostConfig.Binds = opts.mounts.map((m) => `${m.host}:${m.container}${m.readonly ? ":ro" : ""}`);
+    }
+    const createOpts = {
+      Image: this.image,
+      Cmd: ["sleep", "infinity"],
+      WorkingDir: "/workspace",
+      NetworkDisabled: isSandboxed,
+      HostConfig: hostConfig
+    };
+    if (opts.env) {
+      createOpts.Env = Object.entries(opts.env).map(([k, v]) => `${k}=${v}`);
+    }
+    return createOpts;
+  }
+};
+
+// ../sandbox/dist/ensure-image.js
+import { Readable } from "stream";
+var DOCKERFILE = `FROM node:22-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    python3 curl jq git \\
+  && rm -rf /var/lib/apt/lists/*
+WORKDIR /workspace
+`;
+function buildTar(content) {
+  const data = Buffer.from(content, "utf-8");
+  const name = "Dockerfile";
+  const header = Buffer.alloc(512, 0);
+  header.write(name, 0, 100, "utf-8");
+  header.write("0000644\0", 100, 8, "utf-8");
+  header.write("0000000\0", 108, 8, "utf-8");
+  header.write("0000000\0", 116, 8, "utf-8");
+  header.write(data.length.toString(8).padStart(11, "0") + "\0", 124, 12, "utf-8");
+  header.write(Math.floor(Date.now() / 1e3).toString(8).padStart(11, "0") + "\0", 136, 12, "utf-8");
+  header.write("0", 156, 1, "utf-8");
+  header.fill(32, 148, 156);
+  let checksum = 0;
+  for (let i = 0; i < 512; i++)
+    checksum += header[i];
+  header.write(checksum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "utf-8");
+  const padding = 512 - (data.length % 512 || 512);
+  const dataPadded = padding > 0 && padding < 512 ? Buffer.concat([data, Buffer.alloc(padding, 0)]) : data;
+  const end = Buffer.alloc(1024, 0);
+  return Buffer.concat([header, dataPadded, end]);
+}
+async function ensureImage(docker, imageName, logger) {
+  const log = logger ?? noopLogger;
+  log.debug(`Checking image: ${imageName}`);
+  try {
+    await docker.getImage(imageName).inspect();
+    log.debug("Image exists");
+    return;
+  } catch (err) {
+    const statusCode = err.statusCode;
+    if (statusCode !== void 0 && statusCode !== 404)
+      throw err;
+  }
+  log.info(`Image "${imageName}" not found, building...`);
+  const tar = buildTar(DOCKERFILE);
+  const stream = await docker.buildImage(Readable.from(tar), {
+    t: imageName
+  });
+  await new Promise((resolve, reject) => {
+    docker.modem.followProgress(stream, (err) => {
+      if (err)
+        reject(err);
+      else
+        resolve();
+    }, (event) => {
+      if (event.stream) {
+        const line = event.stream.trim();
+        if (line)
+          log.debug(line);
+      }
+    });
+  });
+  log.info(`Image "${imageName}" built`);
+}
+
+export {
+  DockerContainer,
+  DockerContainerPool,
+  ensureImage
+};