@princetheprogrammerbtw/husk 0.1.1 → 0.3.0

package/dist/index.js

@@ -235,6 +235,138 @@ function sanitize(sessionId) {
   return sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 
+// src/memory/vector-inmemory.ts
+var InMemoryVectorStore = class {
+  items = /* @__PURE__ */ new Map();
+  async upsert(item) {
+    this.items.set(item.id, item);
+  }
+  async search(queryEmbedding, topK) {
+    if (this.items.size === 0) return [];
+    if (topK <= 0) return [];
+    const scored = [];
+    for (const item of this.items.values()) {
+      const score = cosineSimilarity(queryEmbedding, item.embedding);
+      scored.push({
+        id: item.id,
+        content: item.content,
+        score,
+        ...item.metadata ? { metadata: item.metadata } : {}
+      });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK);
+  }
+  async remove(id) {
+    this.items.delete(id);
+  }
+  async list() {
+    return [...this.items.keys()];
+  }
+  async clear() {
+    this.items.clear();
+  }
+  async count() {
+    return this.items.size;
+  }
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    dot += ai * bi;
+    normA += ai * ai;
+    normB += bi * bi;
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0) return 0;
+  return dot / denom;
+}
+
+// src/memory/embedder-hash.ts
+var HashEmbedder = class {
+  dimensions;
+  ngramSize;
+  constructor(options = {}) {
+    this.dimensions = options.dimensions ?? 256;
+    this.ngramSize = options.ngramSize ?? 3;
+  }
+  async embed(text) {
+    const vec = new Array(this.dimensions).fill(0);
+    const normalized = text.toLowerCase();
+    for (let i = 0; i <= normalized.length - this.ngramSize; i++) {
+      const ngram = normalized.slice(i, i + this.ngramSize);
+      const hash = simpleHash(ngram);
+      const idx = hash % this.dimensions;
+      vec[idx] = (vec[idx] ?? 0) + (hash % 2 === 0 ? 1 : -1);
+    }
+    const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+    if (norm === 0) return vec;
+    return vec.map((v) => v / norm);
+  }
+};
+function simpleHash(s) {
+  let hash = 5381;
+  for (let i = 0; i < s.length; i++) {
+    hash = hash * 33 ^ s.charCodeAt(i);
+  }
+  return hash >>> 0;
+}
+
+// src/memory/vector.ts
+function defineMemorySearchTool(options) {
+  const { store, embedder, defaultTopK = 5 } = options;
+  return {
+    name: "MemorySearch",
+    description: "Search long-term memory for past interactions. Use this when the user references something you might have seen before, or when you need context that is not in the current conversation.",
+    inputSchema: makeMemorySearchSchema(),
+    execute: async (input) => {
+      const embedding = await embedder.embed(input.query);
+      const topK = input.topK ?? defaultTopK;
+      const results = await store.search(embedding, topK);
+      if (results.length === 0) {
+        return { output: "No matching memories found." };
+      }
+      return {
+        output: results.map((r) => `[score=${r.score.toFixed(3)}] ${r.content}`).join("\n")
+      };
+    }
+  };
+}
+function defineRememberTool(options) {
+  const { store, embedder } = options;
+  return {
+    name: "Remember",
+    description: "Save a piece of information to long-term memory. The next time you (or another agent) need this, call MemorySearch to recall it. Use this for user preferences, important decisions, or any fact that should survive across sessions.",
+    inputSchema: makeRememberSchema(),
+    execute: async (input) => {
+      const embedding = await embedder.embed(input.content);
+      await store.upsert({ id: input.id, content: input.content, embedding });
+      return { output: `Remembered: ${input.content.slice(0, 80)}` };
+    }
+  };
+}
+function makeMemorySearchSchema() {
+  const properties = {
+    query: { type: "string", description: "Natural-language search query." },
+    topK: { type: "integer", description: "Number of results to return. Default: 5." }
+  };
+  return { type: "object", properties, required: ["query"] };
+}
+function makeRememberSchema() {
+  const properties = {
+    id: { type: "string", description: "Unique identifier for this memory (caller-provided)." },
+    content: { type: "string", description: "The text to remember." }
+  };
+  return { type: "object", properties, required: ["id", "content"] };
+}
+
 // src/core/steering.ts
 function buildSystemPrompt(steering) {
   const parts = [];
@@ -821,6 +953,27 @@ function mapStopReason2(reason) {
   }
 }
 
+// src/providers/ollama.ts
+var DEFAULT_BASE_URL = "http://localhost:11434/v1";
+var DEFAULT_MODEL = "llama3.2";
+var PLACEHOLDER_API_KEY = "ollama";
+var OllamaProvider = class {
+  name = "ollama";
+  model;
+  inner;
+  constructor(options = {}) {
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.inner = new OpenAIProvider({
+      apiKey: options.apiKey ?? PLACEHOLDER_API_KEY,
+      model: this.model,
+      baseURL: options.baseURL ?? DEFAULT_BASE_URL
+    });
+  }
+  chat(request) {
+    return this.inner.chat(request);
+  }
+};
+
 // src/tools/registry.ts
 function defineTool(tool) {
   return {
@@ -1103,9 +1256,293 @@ function truncateOutput(output, limit) {
 ... (${lines.length - limit} more matches truncated)`;
 }
 
+// src/evals/types.ts
+function equals(expected) {
+  return (result) => {
+    const pass = result.output === expected;
+    return pass ? { name: `equals(${JSON.stringify(expected).slice(0, 40)})`, pass: true } : {
+      name: `equals(${JSON.stringify(expected).slice(0, 40)})`,
+      pass: false,
+      message: `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function contains(needle) {
+  return (result) => {
+    const pass = result.output.includes(needle);
+    return pass ? { name: `contains(${JSON.stringify(needle).slice(0, 40)})`, pass: true } : {
+      name: `contains(${JSON.stringify(needle).slice(0, 40)})`,
+      pass: false,
+      message: `Expected output to contain ${JSON.stringify(needle)}, got ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function matches(pattern) {
+  return (result) => {
+    const m = pattern.exec(result.output);
+    return {
+      name: `matches(${pattern})`,
+      pass: m !== null,
+      ...m === null ? {
+        message: `Output did not match ${pattern}: ${JSON.stringify(result.output).slice(0, 200)}`
+      } : {}
+    };
+  };
+}
+function fn(name, predicate, message) {
+  return (result) => {
+    const pass = predicate(result.output);
+    return {
+      name,
+      pass,
+      ...pass ? {} : { message: message ?? `Predicate ${name} failed` }
+    };
+  };
+}
+function notContains(needle) {
+  return (result) => {
+    const pass = !result.output.includes(needle);
+    return pass ? { name: `notContains(${JSON.stringify(needle).slice(0, 40)})`, pass: true } : {
+      name: `notContains(${JSON.stringify(needle).slice(0, 40)})`,
+      pass: false,
+      message: `Output should not contain ${JSON.stringify(needle)} but did: ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function lengthBetween(min, max) {
+  return (result) => {
+    const len = result.output.length;
+    const pass = len >= min && len <= max;
+    return pass ? { name: `lengthBetween(${min}, ${max})`, pass: true } : {
+      name: `lengthBetween(${min}, ${max})`,
+      pass: false,
+      message: `Output length ${len} not in [${min}, ${max}]`
+    };
+  };
+}
+
+// src/evals/runner.ts
+async function runSuite(suite, factory, options = {}) {
+  const start = Date.now();
+  const results = [];
+  let passed = 0;
+  for (const c of suite.cases) {
+    options.onCaseStart?.(c.name);
+    const caseResult = await runCase(c, factory);
+    results.push(caseResult);
+    if (caseResult.passed) passed += 1;
+    options.onCaseEnd?.(caseResult);
+    if (options.failFast && !caseResult.passed) {
+      break;
+    }
+  }
+  return {
+    suiteName: suite.name,
+    results,
+    passed,
+    total: suite.cases.length,
+    durationMs: Date.now() - start
+  };
+}
+async function runCase(c, factory) {
+  const start = Date.now();
+  const agent = await factory();
+  let agentResult;
+  try {
+    agentResult = await agent.run(c.input);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const errorAssertionResult = {
+      pass: false,
+      name: "agent.run",
+      message: `agent.run threw: ${message}`
+    };
+    return {
+      caseName: c.name,
+      passed: false,
+      assertionResults: [errorAssertionResult],
+      agentResult: {
+        output: "",
+        messages: [],
+        iterations: 0,
+        usage: { inputTokens: 0, outputTokens: 0 },
+        durationMs: Date.now() - start
+      },
+      durationMs: Date.now() - start
+    };
+  }
+  const assertionResults = [];
+  for (const a of c.assertions) {
+    const r = await a(agentResult);
+    assertionResults.push(r);
+  }
+  const allPassed = assertionResults.every((r) => r.pass);
+  return {
+    caseName: c.name,
+    passed: allPassed,
+    assertionResults,
+    agentResult,
+    durationMs: Date.now() - start
+  };
+}
+function defineSuite(suite) {
+  return {
+    name: suite.name,
+    cases: suite.cases
+  };
+}
+
+// src/obs/tracer.ts
+var NoopTracer = class {
+  startSpan(_options, _parent) {
+    const ctx = {
+      traceId: "0",
+      spanId: "0"
+    };
+    return {
+      context: ctx,
+      addEvent: () => {
+      },
+      setAttribute: () => {
+      },
+      recordException: () => {
+      },
+      setStatus: () => {
+      },
+      end: () => {
+      }
+    };
+  }
+};
+
+// src/obs/mapper.ts
+var EventTracer = class {
+  tracer;
+  traceSpan = null;
+  iterationSpan = null;
+  toolSpans = /* @__PURE__ */ new Map();
+  constructor(tracer) {
+    this.tracer = tracer;
+  }
+  /**
+   * Bind as an event handler: `agent.onAny(tracer.onEvent.bind(tracer))`
+   */
+  onEvent = (event) => {
+    switch (event.type) {
+      case "agent:start": {
+        this.traceSpan = this.tracer.startSpan({
+          name: "agent.run",
+          kind: "internal",
+          attributes: {
+            "husk.input": event.input,
+            "husk.session_id": event.sessionId
+          }
+        });
+        break;
+      }
+      case "agent:iteration": {
+        this.iterationSpan?.end();
+        this.iterationSpan = this.tracer.startSpan(
+          {
+            name: `iteration.${event.iteration}`,
+            kind: "internal",
+            attributes: { "husk.iteration": event.iteration }
+          },
+          this.traceSpan?.context
+        );
+        break;
+      }
+      case "provider:request": {
+        this.iterationSpan?.addEvent("provider.request", {
+          "provider.model": event.request.model
+        });
+        break;
+      }
+      case "provider:response": {
+        if (this.iterationSpan) {
+          this.iterationSpan.setAttribute(
+            "provider.input_tokens",
+            event.response.usage.inputTokens
+          );
+          this.iterationSpan.setAttribute(
+            "provider.output_tokens",
+            event.response.usage.outputTokens
+          );
+          this.iterationSpan.setAttribute("provider.stop_reason", event.response.stopReason);
+          this.iterationSpan.setAttribute("provider.duration_ms", event.durationMs);
+        }
+        break;
+      }
+      case "tool:call": {
+        const span = this.tracer.startSpan(
+          {
+            name: `tool.${event.name}`,
+            kind: "internal",
+            attributes: {
+              "tool.name": event.name,
+              "tool.input": JSON.stringify(event.input)
+            }
+          },
+          this.iterationSpan?.context ?? this.traceSpan?.context
+        );
+        this.toolSpans.set(event.id, span);
+        break;
+      }
+      case "tool:result": {
+        const span = this.toolSpans.get(event.id);
+        if (span) {
+          span.setAttribute("tool.is_error", event.result.isError ?? false);
+          span.setAttribute("tool.duration_ms", event.durationMs);
+          if (event.result.isError) {
+            span.setStatus("error", event.result.output);
+          } else {
+            span.setStatus("ok");
+          }
+          span.end();
+          this.toolSpans.delete(event.id);
+        }
+        break;
+      }
+      case "agent:end": {
+        this.iterationSpan?.end();
+        this.iterationSpan = null;
+        if (this.traceSpan) {
+          this.traceSpan.setAttribute("husk.iterations", event.iterations);
+          this.traceSpan.setAttribute("husk.duration_ms", event.durationMs);
+          this.traceSpan.setStatus("ok");
+          this.traceSpan.end();
+          this.traceSpan = null;
+        }
+        break;
+      }
+      case "agent:error": {
+        if (this.traceSpan) {
+          this.traceSpan.recordException(event.error);
+          this.traceSpan.setStatus("error", event.error.message);
+          this.traceSpan.end();
+          this.traceSpan = null;
+        }
+        this.iterationSpan?.end();
+        this.iterationSpan = null;
+        for (const span of this.toolSpans.values()) {
+          span.end();
+        }
+        this.toolSpans.clear();
+        break;
+      }
+      case "agent:message": {
+        this.iterationSpan?.addEvent("message", {
+          "message.role": event.message.role
+        });
+        break;
+      }
+    }
+  };
+};
+
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { Agent, AgentEventEmitter, AnthropicProvider, Bash, ConsoleLogger, Edit, FileStore, Grep, InMemoryStore, OpenAIProvider, Read, VERSION, Write, arrayField, booleanField, buildExampleMessages, buildSystemPrompt, defineTool, integerField, logEventsTo, numberField, objectField, objectSchema, stringField };
+export { Agent, AgentEventEmitter, AnthropicProvider, Bash, ConsoleLogger, Edit, EventTracer, FileStore, Grep, HashEmbedder, InMemoryStore, InMemoryVectorStore, NoopTracer, OllamaProvider, OpenAIProvider, Read, VERSION, Write, arrayField, booleanField, buildExampleMessages, buildSystemPrompt, contains, cosineSimilarity, defineMemorySearchTool, defineRememberTool, defineSuite, defineTool, equals, fn, integerField, lengthBetween, logEventsTo, matches, notContains, numberField, objectField, objectSchema, runSuite, stringField };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map