noumen 0.6.0 → 0.8.0

package/dist/chunk-PDEAJ272.js

@@ -0,0 +1,660 @@
+import {
+  Agent,
+  NoopTracer,
+  SpanStatusCode,
+  Thread
+} from "./chunk-5HY4IYNT.js";
+import {
+  generateUUID
+} from "./chunk-3HEYCV26.js";
+
+// src/presets.ts
+function codingAgent(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  return new Agent({
+    provider: opts.provider,
+    sandbox: opts.sandbox,
+    options: {
+      cwd,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      permissions: { mode: "default" },
+      autoCompact: true,
+      enableSubagents: true,
+      enableTasks: true,
+      enablePlanMode: true,
+      projectContext: { cwd },
+      costTracking: { enabled: true },
+      retry: true,
+      hooks: opts.hooks,
+      mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle
+    }
+  });
+}
+function planningAgent(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  return new Agent({
+    provider: opts.provider,
+    sandbox: opts.sandbox,
+    options: {
+      cwd,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      permissions: { mode: "plan" },
+      autoCompact: true,
+      enableSubagents: false,
+      enableTasks: false,
+      enablePlanMode: true,
+      projectContext: { cwd },
+      costTracking: { enabled: true },
+      retry: true,
+      hooks: opts.hooks,
+      mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle
+    }
+  });
+}
+function reviewAgent(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  return new Agent({
+    provider: opts.provider,
+    sandbox: opts.sandbox,
+    options: {
+      cwd,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      permissions: { mode: "plan" },
+      autoCompact: true,
+      enableSubagents: false,
+      enableTasks: false,
+      enablePlanMode: true,
+      projectContext: { cwd },
+      costTracking: { enabled: true },
+      retry: true,
+      hooks: opts.hooks,
+      mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle,
+      webSearch: {
+        search: async (query) => {
+          try {
+            const res = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`);
+            if (!res.ok) return [];
+            return [{ title: query, url: res.url, snippet: `Search results for: ${query}` }];
+          } catch {
+            return [];
+          }
+        }
+      }
+    }
+  });
+}
+
+// src/swarm/mailbox.ts
+var Mailbox = class {
+  messages = [];
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Send a message from one member to another.
+   */
+  send(from, to, content) {
+    const msg = {
+      from,
+      to,
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.messages.push(msg);
+    const handlers = this.listeners.get(to);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(msg);
+      }
+    }
+  }
+  /**
+   * Broadcast a message to all members except the sender.
+   */
+  broadcast(from, content, memberNames) {
+    for (const name of memberNames) {
+      if (name !== from) {
+        this.send(from, name, content);
+      }
+    }
+  }
+  /**
+   * Get all messages sent to a specific member.
+   */
+  getMessagesFor(memberName) {
+    return this.messages.filter((m) => m.to === memberName);
+  }
+  /**
+   * Get all unread messages for a member since the last check.
+   */
+  getNewMessagesFor(memberName, since) {
+    return this.messages.filter(
+      (m) => m.to === memberName && m.timestamp > since
+    );
+  }
+  /**
+   * Register a listener for incoming messages to a member.
+   */
+  onMessage(memberName, handler) {
+    const existing = this.listeners.get(memberName) ?? [];
+    existing.push(handler);
+    this.listeners.set(memberName, existing);
+    return () => {
+      const handlers = this.listeners.get(memberName);
+      if (handlers) {
+        const idx = handlers.indexOf(handler);
+        if (idx !== -1) handlers.splice(idx, 1);
+      }
+    };
+  }
+  /**
+   * Get all messages in the mailbox.
+   */
+  getAllMessages() {
+    return [...this.messages];
+  }
+};
+
+// src/swarm/manager.ts
+var SwarmManager = class {
+  members = /* @__PURE__ */ new Map();
+  backend;
+  mailbox = new Mailbox();
+  config;
+  runningTasks = /* @__PURE__ */ new Map();
+  eventHandlers = [];
+  constructor(backend, config) {
+    this.backend = backend;
+    this.config = config ?? {};
+  }
+  /**
+   * Register a handler for swarm lifecycle events.
+   */
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+    return () => {
+      const idx = this.eventHandlers.indexOf(handler);
+      if (idx !== -1) this.eventHandlers.splice(idx, 1);
+    };
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      handler(event);
+    }
+  }
+  /**
+   * Spawn a new swarm member. Returns the member ID.
+   */
+  async spawn(config) {
+    const id = generateUUID();
+    const member = {
+      id,
+      name: config.name,
+      status: "pending"
+    };
+    this.members.set(id, member);
+    const maxConcurrent = this.config.maxConcurrent ?? 4;
+    const running = Array.from(this.members.values()).filter(
+      (m) => m.status === "running"
+    ).length;
+    if (running >= maxConcurrent) {
+      await this.waitForSlot(maxConcurrent);
+    }
+    member.status = "running";
+    this.emit({
+      type: "swarm_member_start",
+      memberId: id,
+      memberName: config.name
+    });
+    const task = this.runMember(config, member);
+    this.runningTasks.set(id, task);
+    return id;
+  }
+  async runMember(config, member) {
+    try {
+      const gen = this.backend.spawn(config, member);
+      let next = await gen.next();
+      while (!next.done) {
+        next = await gen.next();
+      }
+      member.result = next.value;
+      member.status = "completed";
+      this.emit({
+        type: "swarm_member_complete",
+        memberId: member.id,
+        memberName: member.name,
+        content: member.result
+      });
+    } catch (err) {
+      member.error = err instanceof Error ? err : new Error(String(err));
+      member.status = "failed";
+      this.emit({
+        type: "swarm_member_failed",
+        memberId: member.id,
+        memberName: member.name,
+        error: member.error
+      });
+    } finally {
+      this.runningTasks.delete(member.id);
+    }
+  }
+  /**
+   * Spawn multiple members concurrently. Returns their IDs.
+   */
+  async spawnAll(configs) {
+    const ids = [];
+    for (const config of configs) {
+      ids.push(await this.spawn(config));
+    }
+    return ids;
+  }
+  /**
+   * Send a message between swarm members.
+   */
+  sendMessage(from, to, content) {
+    this.mailbox.send(from, to, content);
+    this.emit({
+      type: "swarm_message",
+      memberId: to,
+      memberName: this.getMemberName(to),
+      content
+    });
+  }
+  /**
+   * Kill a running member.
+   */
+  async kill(memberId) {
+    const member = this.members.get(memberId);
+    if (!member || member.status !== "running") return;
+    await this.backend.kill(memberId);
+    member.status = "killed";
+    this.runningTasks.delete(memberId);
+  }
+  /**
+   * Wait for all running members to complete.
+   */
+  async waitForAll() {
+    while (this.runningTasks.size > 0) {
+      await Promise.race(this.runningTasks.values());
+    }
+  }
+  /**
+   * Get current swarm status.
+   */
+  getStatus() {
+    return {
+      members: Array.from(this.members.values()),
+      messages: this.mailbox.getAllMessages()
+    };
+  }
+  /**
+   * Get a specific member.
+   */
+  getMember(id) {
+    return this.members.get(id);
+  }
+  /**
+   * Get the mailbox for direct access.
+   */
+  getMailbox() {
+    return this.mailbox;
+  }
+  getMemberName(id) {
+    return this.members.get(id)?.name ?? id;
+  }
+  async waitForSlot(maxConcurrent) {
+    while (true) {
+      const running = Array.from(this.members.values()).filter(
+        (m) => m.status === "running"
+      ).length;
+      if (running < maxConcurrent) return;
+      if (this.runningTasks.size > 0) {
+        await Promise.race(this.runningTasks.values());
+      } else {
+        break;
+      }
+    }
+  }
+};
+
+// src/swarm/backends/in-process.ts
+var InProcessBackend = class {
+  threadConfig;
+  abortControllers = /* @__PURE__ */ new Map();
+  constructor(threadConfig) {
+    this.threadConfig = threadConfig;
+  }
+  async *spawn(config, member) {
+    const ac = new AbortController();
+    this.abortControllers.set(member.id, ac);
+    const childTools = config.allowedTools ? (this.threadConfig.tools ?? []).filter(
+      (t) => config.allowedTools.includes(t.name)
+    ) : this.threadConfig.tools;
+    const thread = new Thread(
+      {
+        ...this.threadConfig,
+        tools: childTools,
+        systemPrompt: config.systemPrompt,
+        model: config.model
+      },
+      { cwd: this.threadConfig.cwd }
+    );
+    member.sessionId = thread.sessionId;
+    let resultText = "";
+    for await (const event of thread.run(config.prompt, {
+      signal: ac.signal
+    })) {
+      yield event;
+      if (event.type === "message_complete" && event.message.content) {
+        resultText += event.message.content;
+      }
+    }
+    this.abortControllers.delete(member.id);
+    return resultText;
+  }
+  async kill(memberId) {
+    const ac = this.abortControllers.get(memberId);
+    if (ac) {
+      ac.abort();
+      this.abortControllers.delete(memberId);
+    }
+  }
+};
+
+// src/permissions/updates.ts
+function applyPermissionUpdate(ctx, update) {
+  switch (update.type) {
+    case "addRules":
+      ctx.rules.push(...update.rules);
+      break;
+    case "removeRules":
+      ctx.rules = ctx.rules.filter((r) => {
+        if (r.toolName !== update.toolName) return true;
+        if (update.behavior && r.behavior !== update.behavior) return true;
+        return false;
+      });
+      break;
+    case "setMode":
+      ctx.mode = update.mode;
+      break;
+    case "addDirectories":
+      for (const dir of update.directories) {
+        if (!ctx.workingDirectories.includes(dir)) {
+          ctx.workingDirectories.push(dir);
+        }
+      }
+      break;
+    case "removeDirectories":
+      ctx.workingDirectories = ctx.workingDirectories.filter(
+        (d) => !update.directories.includes(d)
+      );
+      break;
+  }
+  return ctx;
+}
+function applyPermissionUpdates(ctx, updates) {
+  for (const update of updates) {
+    applyPermissionUpdate(ctx, update);
+  }
+  return ctx;
+}
+
+// src/tracing/otel.ts
+var otelApi = null;
+var otelLoadFailed = false;
+async function loadOTelApi() {
+  if (otelApi) return otelApi;
+  if (otelLoadFailed) return null;
+  try {
+    otelApi = await import("@opentelemetry/api");
+    return otelApi;
+  } catch {
+    otelLoadFailed = true;
+    return null;
+  }
+}
+var OTelSpan = class {
+  name;
+  inner;
+  constructor(name, inner) {
+    this.name = name;
+    this.inner = inner;
+  }
+  setAttribute(key, value) {
+    this.inner.setAttribute(key, value);
+  }
+  addEvent(name, attributes) {
+    this.inner.addEvent(name, attributes);
+  }
+  setStatus(code, message) {
+    const otelCode = code === SpanStatusCode.ERROR ? 2 : 1;
+    this.inner.setStatus({ code: otelCode, message });
+  }
+  end() {
+    this.inner.end();
+  }
+  /** Access the underlying OTEL span for advanced use cases. */
+  getInnerSpan() {
+    return this.inner;
+  }
+};
+var OTelTracer = class _OTelTracer {
+  otelTracer;
+  api;
+  constructor(api, otelTracer) {
+    this.api = api;
+    this.otelTracer = otelTracer;
+  }
+  /**
+   * Create an `OTelTracer`. Falls back to `NoopTracer` if
+   * `@opentelemetry/api` is not available at runtime.
+   */
+  static async create(serviceName = "noumen", version) {
+    const api = await loadOTelApi();
+    if (!api) return new NoopTracer();
+    const tracer = api.trace.getTracer(serviceName, version);
+    return new _OTelTracer(api, tracer);
+  }
+  startSpan(name, options) {
+    const parentCtx = options?.parent instanceof OTelSpan ? this.api.trace.setSpan(this.api.context.active(), options.parent.getInnerSpan()) : this.api.context.active();
+    const otelSpan = this.otelTracer.startSpan(
+      name,
+      options?.attributes ? { attributes: options.attributes } : void 0,
+      parentCtx
+    );
+    return new OTelSpan(name, otelSpan);
+  }
+};
+
+// src/memory/file-provider.ts
+var INDEX_NAME = "MEMORY.md";
+var DEFAULT_MAX_LINES = 200;
+var DEFAULT_MAX_BYTES = 25e3;
+var MEMORY_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "project",
+  "feedback",
+  "reference"
+]);
+function parseFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { rest: raw };
+  }
+  const endIdx = trimmed.indexOf("---", 3);
+  if (endIdx === -1) {
+    return { rest: raw };
+  }
+  const fmBlock = trimmed.slice(3, endIdx).trim();
+  const rest = trimmed.slice(endIdx + 3).trim();
+  let name;
+  let description;
+  let type;
+  for (const line of fmBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "name") name = value;
+    else if (key === "description") description = value;
+    else if (key === "type" && MEMORY_TYPES.has(value)) type = value;
+  }
+  return { name, description, type, rest };
+}
+function serializeEntry(entry) {
+  const lines = [
+    "---",
+    `name: ${entry.name}`,
+    `description: ${entry.description}`,
+    `type: ${entry.type}`,
+    "---",
+    "",
+    entry.content
+  ];
+  return lines.join("\n");
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
+}
+function truncateIndex(raw, maxLines = DEFAULT_MAX_LINES, maxBytes = DEFAULT_MAX_BYTES) {
+  const trimmed = raw.trim();
+  const contentLines = trimmed.split("\n");
+  const lineCount = contentLines.length;
+  const byteCount = trimmed.length;
+  const wasLineTruncated = lineCount > maxLines;
+  const wasByteTruncated = byteCount > maxBytes;
+  if (!wasLineTruncated && !wasByteTruncated) {
+    return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated };
+  }
+  let truncated = wasLineTruncated ? contentLines.slice(0, maxLines).join("\n") : trimmed;
+  if (truncated.length > maxBytes) {
+    const cutAt = truncated.lastIndexOf("\n", maxBytes);
+    truncated = truncated.slice(0, cutAt > 0 ? cutAt : maxBytes);
+  }
+  const reason = wasByteTruncated && !wasLineTruncated ? `${byteCount} bytes (limit: ${maxBytes})` : wasLineTruncated && !wasByteTruncated ? `${lineCount} lines (limit: ${maxLines})` : `${lineCount} lines and ${byteCount} bytes`;
+  return {
+    content: truncated + `
+
+> WARNING: ${INDEX_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
+    lineCount,
+    byteCount,
+    wasLineTruncated,
+    wasByteTruncated
+  };
+}
+var FileMemoryProvider = class {
+  fs;
+  dir;
+  maxIndexLines;
+  constructor(fs, memoryDir, maxIndexLines = DEFAULT_MAX_LINES) {
+    this.fs = fs;
+    this.dir = memoryDir.endsWith("/") ? memoryDir : memoryDir + "/";
+    this.maxIndexLines = maxIndexLines;
+  }
+  indexPath() {
+    return this.dir + INDEX_NAME;
+  }
+  async ensureDir() {
+    const exists = await this.fs.exists(this.dir);
+    if (!exists) {
+      await this.fs.mkdir(this.dir, { recursive: true });
+    }
+  }
+  async loadIndex() {
+    try {
+      const raw = await this.fs.readFile(this.indexPath());
+      return truncateIndex(raw, this.maxIndexLines).content;
+    } catch {
+      return "";
+    }
+  }
+  async loadEntry(path) {
+    const fullPath = path.startsWith(this.dir) ? path : this.dir + path;
+    try {
+      const raw = await this.fs.readFile(fullPath);
+      const fm = parseFrontmatter(raw);
+      const stat = await this.fs.stat(fullPath).catch(() => null);
+      return {
+        name: fm.name ?? pathToName(path),
+        description: fm.description ?? "",
+        type: fm.type ?? "project",
+        content: fm.rest,
+        path: path.startsWith(this.dir) ? path.slice(this.dir.length) : path,
+        updatedAt: stat?.modifiedAt?.toISOString()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async saveEntry(entry) {
+    await this.ensureDir();
+    const relativePath = entry.path ?? slugify(entry.name) + ".md";
+    const fullPath = this.dir + relativePath;
+    const content = serializeEntry({ ...entry, path: relativePath });
+    await this.fs.writeFile(fullPath, content);
+    await this.rebuildIndex();
+  }
+  async removeEntry(path) {
+    const fullPath = path.startsWith(this.dir) ? path : this.dir + path;
+    try {
+      await this.fs.deleteFile(fullPath);
+    } catch {
+    }
+    await this.rebuildIndex();
+  }
+  async listEntries() {
+    try {
+      const files = await this.fs.readdir(this.dir);
+      const entries = [];
+      for (const file of files) {
+        if (!file.isFile || !file.name.endsWith(".md") || file.name === INDEX_NAME) continue;
+        const entry = await this.loadEntry(file.name);
+        if (entry) entries.push(entry);
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+  async search(query) {
+    const entries = await this.listEntries();
+    const lower = query.toLowerCase();
+    return entries.filter(
+      (e) => e.name.toLowerCase().includes(lower) || e.description.toLowerCase().includes(lower) || e.content.toLowerCase().includes(lower)
+    );
+  }
+  async rebuildIndex() {
+    const entries = await this.listEntries();
+    const lines = [];
+    for (const entry of entries) {
+      const relativePath = entry.path ?? slugify(entry.name) + ".md";
+      const desc = entry.description ? ` \u2014 ${entry.description}` : "";
+      lines.push(`- [${entry.name}](${relativePath})${desc}`);
+    }
+    await this.ensureDir();
+    await this.fs.writeFile(this.indexPath(), lines.join("\n") + "\n");
+  }
+};
+function pathToName(p) {
+  const base = p.split("/").pop() ?? p;
+  return base.replace(/\.md$/i, "").replace(/[_-]/g, " ");
+}
+
+export {
+  codingAgent,
+  planningAgent,
+  reviewAgent,
+  Mailbox,
+  SwarmManager,
+  InProcessBackend,
+  applyPermissionUpdate,
+  applyPermissionUpdates,
+  OTelTracer,
+  truncateIndex,
+  FileMemoryProvider
+};
+//# sourceMappingURL=chunk-PDEAJ272.js.map