@ai2070/memex 0.9.0

package/tests/serialization.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import { toJSON, fromJSON, stringify, parse } from "../src/serialization.js";
+import { createGraphState } from "../src/graph.js";
+import { applyCommand } from "../src/reducer.js";
+import type { MemoryItem, Edge } from "../src/types.js";
+
+const makeItem = (id: string): MemoryItem => ({
+  id,
+  scope: "test",
+  kind: "observation",
+  content: { key: "value" },
+  author: "user:laz",
+  source_kind: "observed",
+  authority: 0.9,
+  conviction: 0.8,
+  importance: 0.7,
+  meta: { agent_id: "agent:x" },
+});
+
+const makeEdge = (id: string): Edge => ({
+  edge_id: id,
+  from: "m1",
+  to: "m2",
+  kind: "SUPPORTS",
+  author: "system:rule",
+  source_kind: "derived_deterministic",
+  authority: 0.8,
+  active: true,
+  weight: 0.5,
+});
+
+function buildState() {
+  let state = createGraphState();
+  state = applyCommand(state, {
+    type: "memory.create",
+    item: makeItem("m1"),
+  }).state;
+  state = applyCommand(state, {
+    type: "memory.create",
+    item: makeItem("m2"),
+  }).state;
+  state = applyCommand(state, {
+    type: "edge.create",
+    edge: makeEdge("e1"),
+  }).state;
+  return state;
+}
+
+describe("toJSON / fromJSON", () => {
+  it("round-trips a graph state", () => {
+    const state = buildState();
+    const json = toJSON(state);
+    const restored = fromJSON(json);
+
+    expect(restored.items.size).toBe(2);
+    expect(restored.edges.size).toBe(1);
+    expect(restored.items.get("m1")!.content).toEqual({ key: "value" });
+    expect(restored.items.get("m1")!.meta?.agent_id).toBe("agent:x");
+    expect(restored.edges.get("e1")!.kind).toBe("SUPPORTS");
+  });
+
+  it("serialized format has items and edges as arrays", () => {
+    const state = buildState();
+    const json = toJSON(state);
+    expect(Array.isArray(json.items)).toBe(true);
+    expect(Array.isArray(json.edges)).toBe(true);
+    expect(json.items).toHaveLength(2);
+    expect(json.edges).toHaveLength(1);
+    expect(json.items[0][0]).toBe("m1"); // [key, value] tuple
+  });
+
+  it("empty state round-trips", () => {
+    const state = createGraphState();
+    const restored = fromJSON(toJSON(state));
+    expect(restored.items.size).toBe(0);
+    expect(restored.edges.size).toBe(0);
+  });
+});
+
+describe("stringify / parse", () => {
+  it("round-trips through JSON string", () => {
+    const state = buildState();
+    const jsonStr = stringify(state);
+    const restored = parse(jsonStr);
+
+    expect(restored.items.size).toBe(2);
+    expect(restored.edges.size).toBe(1);
+    expect(restored.items.get("m2")!.authority).toBe(0.9);
+  });
+
+  it("produces valid JSON", () => {
+    const state = buildState();
+    const jsonStr = stringify(state);
+    expect(() => JSON.parse(jsonStr)).not.toThrow();
+  });
+
+  it("pretty mode produces formatted output", () => {
+    const state = buildState();
+    const compact = stringify(state);
+    const pretty = stringify(state, true);
+    expect(pretty.length).toBeGreaterThan(compact.length);
+    expect(pretty).toContain("\n");
+  });
+
+  it("preserves all fields through stringify/parse", () => {
+    const state = buildState();
+    const restored = parse(stringify(state));
+    const item = restored.items.get("m1")!;
+    expect(item.scope).toBe("test");
+    expect(item.kind).toBe("observation");
+    expect(item.conviction).toBe(0.8);
+    expect(item.importance).toBe(0.7);
+    expect(item.meta?.agent_id).toBe("agent:x");
+    const edge = restored.edges.get("e1")!;
+    expect(edge.weight).toBe(0.5);
+    expect(edge.active).toBe(true);
+  });
+});

package/tests/setup.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from "vitest";
+
+describe("scaffold", () => {
+  it("toolchain works", () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/stats.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from "vitest";
+import { getStats } from "../src/stats.js";
+import { createGraphState } from "../src/graph.js";
+import type { MemoryItem, Edge, GraphState } from "../src/types.js";
+
+const makeItem = (
+  id: string,
+  overrides: Partial<MemoryItem> = {},
+): MemoryItem => ({
+  id,
+  scope: "test",
+  kind: "observation",
+  content: {},
+  author: "agent:a",
+  source_kind: "observed",
+  authority: 0.5,
+  ...overrides,
+});
+
+function buildState(): GraphState {
+  const state: GraphState = { items: new Map(), edges: new Map() };
+  const items: MemoryItem[] = [
+    makeItem("m1", {
+      kind: "observation",
+      source_kind: "observed",
+      author: "agent:a",
+      scope: "project:x",
+    }),
+    makeItem("m2", {
+      kind: "observation",
+      source_kind: "observed",
+      author: "agent:a",
+      scope: "project:x",
+    }),
+    makeItem("m3", {
+      kind: "assertion",
+      source_kind: "user_explicit",
+      author: "user:laz",
+      scope: "project:x",
+    }),
+    makeItem("m4", {
+      kind: "hypothesis",
+      source_kind: "agent_inferred",
+      author: "agent:b",
+      scope: "project:y",
+      parents: ["m1"],
+    }),
+    makeItem("m5", {
+      kind: "derivation",
+      source_kind: "derived_deterministic",
+      author: "system:rule",
+      scope: "project:y",
+      parents: ["m2", "m3"],
+    }),
+  ];
+  const edges: Edge[] = [
+    {
+      edge_id: "e1",
+      from: "m1",
+      to: "m2",
+      kind: "SUPPORTS",
+      author: "system:rule",
+      source_kind: "derived_deterministic",
+      authority: 0.8,
+      active: true,
+    },
+    {
+      edge_id: "e2",
+      from: "m3",
+      to: "m4",
+      kind: "CONTRADICTS",
+      author: "system:detector",
+      source_kind: "derived_deterministic",
+      authority: 1,
+      active: true,
+    },
+    {
+      edge_id: "e3",
+      from: "m1",
+      to: "m3",
+      kind: "ABOUT",
+      author: "agent:a",
+      source_kind: "agent_inferred",
+      authority: 0.5,
+      active: false,
+    },
+  ];
+  for (const i of items) state.items.set(i.id, i);
+  for (const e of edges) state.edges.set(e.edge_id, e);
+  return state;
+}
+
+describe("getStats", () => {
+  it("returns correct item totals", () => {
+    const stats = getStats(buildState());
+    expect(stats.items.total).toBe(5);
+    expect(stats.items.root).toBe(3);
+    expect(stats.items.with_parents).toBe(2);
+  });
+
+  it("counts items by kind", () => {
+    const stats = getStats(buildState());
+    expect(stats.items.by_kind).toEqual({
+      observation: 2,
+      assertion: 1,
+      hypothesis: 1,
+      derivation: 1,
+    });
+  });
+
+  it("counts items by source_kind", () => {
+    const stats = getStats(buildState());
+    expect(stats.items.by_source_kind).toEqual({
+      observed: 2,
+      user_explicit: 1,
+      agent_inferred: 1,
+      derived_deterministic: 1,
+    });
+  });
+
+  it("counts items by author", () => {
+    const stats = getStats(buildState());
+    expect(stats.items.by_author).toEqual({
+      "agent:a": 2,
+      "user:laz": 1,
+      "agent:b": 1,
+      "system:rule": 1,
+    });
+  });
+
+  it("counts items by scope", () => {
+    const stats = getStats(buildState());
+    expect(stats.items.by_scope).toEqual({
+      "project:x": 3,
+      "project:y": 2,
+    });
+  });
+
+  it("returns correct edge totals", () => {
+    const stats = getStats(buildState());
+    expect(stats.edges.total).toBe(3);
+    expect(stats.edges.active).toBe(2);
+  });
+
+  it("counts edges by kind", () => {
+    const stats = getStats(buildState());
+    expect(stats.edges.by_kind).toEqual({
+      SUPPORTS: 1,
+      CONTRADICTS: 1,
+      ABOUT: 1,
+    });
+  });
+
+  it("handles empty state", () => {
+    const stats = getStats(createGraphState());
+    expect(stats.items.total).toBe(0);
+    expect(stats.items.root).toBe(0);
+    expect(stats.items.with_parents).toBe(0);
+    expect(stats.items.by_kind).toEqual({});
+    expect(stats.edges.total).toBe(0);
+    expect(stats.edges.active).toBe(0);
+  });
+});

package/tests/task.test.ts

@@ -0,0 +1,322 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createTaskState,
+  createTask,
+  applyTaskCommand,
+  getTasks,
+  getTaskById,
+  getTasksByIntent,
+  TaskNotFoundError,
+  DuplicateTaskError,
+  InvalidTaskTransitionError,
+} from "../src/task.js";
+import type { Task, TaskState } from "../src/task.js";
+
+const makeTask = (overrides: Partial<Task> = {}): Task => ({
+  id: "t1",
+  intent_id: "i1",
+  action: "search_linkedin",
+  status: "pending",
+  priority: 0.7,
+  attempt: 0,
+  ...overrides,
+});
+
+describe("task.create", () => {
+  it("creates a task", () => {
+    const task = makeTask();
+    const { state, events } = applyTaskCommand(createTaskState(), {
+      type: "task.create",
+      task,
+    });
+    expect(state.tasks.get("t1")).toEqual(task);
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("task.created");
+    expect(events[0].namespace).toBe("task");
+  });
+
+  it("throws DuplicateTaskError", () => {
+    let state = createTaskState();
+    state = applyTaskCommand(state, {
+      type: "task.create",
+      task: makeTask(),
+    }).state;
+    expect(() =>
+      applyTaskCommand(state, { type: "task.create", task: makeTask() }),
+    ).toThrow(DuplicateTaskError);
+  });
+
+  it("does not mutate original state", () => {
+    const state = createTaskState();
+    applyTaskCommand(state, { type: "task.create", task: makeTask() });
+    expect(state.tasks.size).toBe(0);
+  });
+});
+
+describe("task.update", () => {
+  it("updates priority", () => {
+    let state = createTaskState();
+    state = applyTaskCommand(state, {
+      type: "task.create",
+      task: makeTask(),
+    }).state;
+    const { state: next } = applyTaskCommand(state, {
+      type: "task.update",
+      task_id: "t1",
+      partial: { priority: 0.2 },
+      author: "test",
+    });
+    expect(next.tasks.get("t1")!.priority).toBe(0.2);
+  });
+
+  it("throws TaskNotFoundError", () => {
+    expect(() =>
+      applyTaskCommand(createTaskState(), {
+        type: "task.update",
+        task_id: "nope",
+        partial: {},
+        author: "test",
+      }),
+    ).toThrow(TaskNotFoundError);
+  });
+});
+
+describe("task lifecycle", () => {
+  let state: TaskState;
+  beforeEach(() => {
+    state = applyTaskCommand(createTaskState(), {
+      type: "task.create",
+      task: makeTask(),
+    }).state;
+  });
+
+  it("pending -> running (start)", () => {
+    const { state: next, events } = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+      agent_id: "agent:worker",
+    });
+    expect(next.tasks.get("t1")!.status).toBe("running");
+    expect(next.tasks.get("t1")!.agent_id).toBe("agent:worker");
+    expect(next.tasks.get("t1")!.attempt).toBe(1);
+    expect(events[0].type).toBe("task.started");
+  });
+
+  it("running -> completed", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    const { state: next, events } = applyTaskCommand(state, {
+      type: "task.complete",
+      task_id: "t1",
+      result: { found: true },
+      output_memory_ids: ["m5"],
+    });
+    expect(next.tasks.get("t1")!.status).toBe("completed");
+    expect(next.tasks.get("t1")!.result).toEqual({ found: true });
+    expect(next.tasks.get("t1")!.output_memory_ids).toEqual(["m5"]);
+    expect(events[0].type).toBe("task.completed");
+  });
+
+  it("running -> failed", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    const { state: next, events } = applyTaskCommand(state, {
+      type: "task.fail",
+      task_id: "t1",
+      error: "timeout",
+    });
+    expect(next.tasks.get("t1")!.status).toBe("failed");
+    expect(next.tasks.get("t1")!.error).toBe("timeout");
+    expect(events[0].type).toBe("task.failed");
+  });
+
+  it("failed -> running (retry)", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    state = applyTaskCommand(state, {
+      type: "task.fail",
+      task_id: "t1",
+      error: "timeout",
+    }).state;
+    const { state: next } = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    });
+    expect(next.tasks.get("t1")!.status).toBe("running");
+    expect(next.tasks.get("t1")!.attempt).toBe(2);
+  });
+
+  it("pending -> cancelled", () => {
+    const { state: next, events } = applyTaskCommand(state, {
+      type: "task.cancel",
+      task_id: "t1",
+      reason: "no longer needed",
+    });
+    expect(next.tasks.get("t1")!.status).toBe("cancelled");
+    expect(events[0].type).toBe("task.cancelled");
+  });
+
+  it("running -> cancelled", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    const { state: next } = applyTaskCommand(state, {
+      type: "task.cancel",
+      task_id: "t1",
+    });
+    expect(next.tasks.get("t1")!.status).toBe("cancelled");
+  });
+
+  it("completed -> start throws InvalidTaskTransitionError", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    state = applyTaskCommand(state, {
+      type: "task.complete",
+      task_id: "t1",
+    }).state;
+    expect(() =>
+      applyTaskCommand(state, { type: "task.start", task_id: "t1" }),
+    ).toThrow(InvalidTaskTransitionError);
+  });
+
+  it("completed -> cancel throws InvalidTaskTransitionError", () => {
+    state = applyTaskCommand(state, {
+      type: "task.start",
+      task_id: "t1",
+    }).state;
+    state = applyTaskCommand(state, {
+      type: "task.complete",
+      task_id: "t1",
+    }).state;
+    expect(() =>
+      applyTaskCommand(state, { type: "task.cancel", task_id: "t1" }),
+    ).toThrow(InvalidTaskTransitionError);
+  });
+
+  it("pending -> complete throws InvalidTaskTransitionError", () => {
+    expect(() =>
+      applyTaskCommand(state, { type: "task.complete", task_id: "t1" }),
+    ).toThrow(InvalidTaskTransitionError);
+  });
+});
+
+describe("createTask factory", () => {
+  it("generates id and defaults status/attempt", () => {
+    const task = createTask({
+      intent_id: "i1",
+      action: "search",
+      priority: 0.5,
+    });
+    expect(task.id).toBeDefined();
+    expect(task.status).toBe("pending");
+    expect(task.attempt).toBe(0);
+  });
+});
+
+describe("task queries", () => {
+  let state: TaskState;
+  beforeEach(() => {
+    state = createTaskState();
+    state = applyTaskCommand(state, {
+      type: "task.create",
+      task: makeTask({
+        id: "t1",
+        intent_id: "i1",
+        action: "search",
+        status: "pending",
+        priority: 0.9,
+        agent_id: "agent:a",
+        input_memory_ids: ["m1"],
+      }),
+    }).state;
+    state = applyTaskCommand(state, {
+      type: "task.create",
+      task: makeTask({
+        id: "t2",
+        intent_id: "i1",
+        action: "summarize",
+        status: "running",
+        priority: 0.5,
+        agent_id: "agent:b",
+      }),
+    }).state;
+    state = applyTaskCommand(state, {
+      type: "task.create",
+      task: makeTask({
+        id: "t3",
+        intent_id: "i2",
+        action: "search",
+        status: "completed",
+        priority: 0.3,
+        output_memory_ids: ["m5"],
+      }),
+    }).state;
+  });
+
+  it("returns all tasks with no filter", () => {
+    expect(getTasks(state)).toHaveLength(3);
+  });
+
+  it("filters by intent_id", () => {
+    const result = getTasks(state, { intent_id: "i1" });
+    expect(result).toHaveLength(2);
+  });
+
+  it("filters by action", () => {
+    const result = getTasks(state, { action: "search" });
+    expect(result).toHaveLength(2);
+  });
+
+  it("filters by status", () => {
+    const result = getTasks(state, { status: "running" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("t2");
+  });
+
+  it("filters by statuses array", () => {
+    const result = getTasks(state, { statuses: ["pending", "running"] });
+    expect(result).toHaveLength(2);
+  });
+
+  it("filters by agent_id", () => {
+    const result = getTasks(state, { agent_id: "agent:a" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("t1");
+  });
+
+  it("filters by min_priority", () => {
+    const result = getTasks(state, { min_priority: 0.5 });
+    expect(result).toHaveLength(2);
+  });
+
+  it("filters by has_input_memory_id", () => {
+    const result = getTasks(state, { has_input_memory_id: "m1" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("t1");
+  });
+
+  it("filters by has_output_memory_id", () => {
+    const result = getTasks(state, { has_output_memory_id: "m5" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("t3");
+  });
+
+  it("getTaskById works", () => {
+    expect(getTaskById(state, "t2")?.action).toBe("summarize");
+    expect(getTaskById(state, "nope")).toBeUndefined();
+  });
+
+  it("getTasksByIntent works", () => {
+    const result = getTasksByIntent(state, "i1");
+    expect(result).toHaveLength(2);
+  });
+});