recallnest 3.0.0 → 3.0.1

package/src/__tests__/workflow-observation-skill-outcome.test.ts

@@ -1,352 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { persistSkill, recordSkillOutcome } from "../skill-engine.js";
-import { WorkflowObservationInputSchema } from "../workflow-observation-schema.js";
-import type { MemoryEntry } from "../store.js";
-
-const TEST_SCOPE = "project:test";
-
-function createMockStore() {
-  const entries: MemoryEntry[] = [];
-  let seq = 1;
-
-  return {
-    entries,
-    store: {
-      async store(entry: Omit<MemoryEntry, "id" | "timestamp"> & { id?: string }): Promise<MemoryEntry> {
-        const stored: MemoryEntry = {
-          ...entry,
-          id: entry.id || `auto-${String(seq).padStart(12, "0")}`,
-          timestamp: 1_700_000_000_000 + seq,
-          metadata: entry.metadata || "{}",
-        };
-        seq += 1;
-        entries.push(stored);
-        return stored;
-      },
-      async update(id: string, updates: Partial<MemoryEntry>): Promise<MemoryEntry | null> {
-        const index = entries.findIndex((e) => e.id === id);
-        if (index < 0) return null;
-        entries[index] = {
-          ...entries[index],
-          ...updates,
-          timestamp: updates.timestamp ?? entries[index].timestamp,
-        };
-        return entries[index];
-      },
-      async getById(id: string): Promise<MemoryEntry | null> {
-        // Match real store.getById behavior: support full UUID + 8+ hex prefix,
-        // return null on ambiguous prefix (matches >1).
-        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-        const prefixRegex = /^[0-9a-f]{8,}$/i;
-        const isFullId = uuidRegex.test(id);
-        const isPrefix = !isFullId && prefixRegex.test(id);
-        if (!isFullId && !isPrefix) return null;
-        if (isFullId) return entries.find((e) => e.id === id) || null;
-        const matches = entries.filter((e) => e.id.toLowerCase().startsWith(id.toLowerCase()));
-        if (matches.length === 0) return null;
-        if (matches.length > 1) return null; // ambiguous prefix
-        return matches[0];
-      },
-      async vectorSearch(): Promise<never[]> {
-        return [];
-      },
-    },
-  };
-}
-
-function createMockEmbedder() {
-  return {
-    async embedPassage(text: string): Promise<number[]> {
-      return [text.length, 1, 0];
-    },
-  };
-}
-
-function validSkillInput(overrides: Record<string, unknown> = {}) {
-  return {
-    name: "deploy_production",
-    description: "Deploy to production environment with safety checks",
-    triggerPattern: "When user says 'deploy to prod' or 'release'",
-    implementationType: "instruction_sequence" as const,
-    implementation: "1. Confirm production target. 2. Run pre-deploy checks. 3. Tag release. 4. Notify channel.",
-    scope: TEST_SCOPE,
-    source: "agent" as const,
-    tags: ["deploy", "production"],
-    ...overrides,
-  };
-}
-
-function getSkillMeta(entry: MemoryEntry): Record<string, unknown> {
-  const meta = JSON.parse(entry.metadata || "{}");
-  return (meta.skill || {}) as Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// WorkflowObservationInputSchema accepts skillId
-// ---------------------------------------------------------------------------
-
-describe("WorkflowObservationInputSchema skillId field", () => {
-  it("accepts optional skillId on input", () => {
-    const parsed = WorkflowObservationInputSchema.parse({
-      workflowId: "skill_run",
-      summary: "ran deploy_production",
-      skillId: "a1b2c3d4-deadbeef-0000-0000-000000000000",
-    });
-    expect(parsed.skillId).toBe("a1b2c3d4-deadbeef-0000-0000-000000000000");
-  });
-
-  it("allows omission of skillId (backward-compatible)", () => {
-    const parsed = WorkflowObservationInputSchema.parse({
-      workflowId: "resume_context",
-      summary: "fresh window recovered continuity",
-    });
-    expect(parsed.skillId).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// recordSkillOutcome — outcome mapping
-// ---------------------------------------------------------------------------
-
-describe("recordSkillOutcome outcome mapping", () => {
-  it("success outcome bumps successCount and leaves failureCount unchanged", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput());
-
-    const result = await recordSkillOutcome(mock.store, stored.id, "success");
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    expect(result.successCount).toBe(1);
-    expect(result.failureCount).toBe(0);
-    expect(result.lastRefinedAt).toBeTypeOf("string");
-
-    const skill = getSkillMeta(mock.entries[0]);
-    expect(skill.successCount).toBe(1);
-    expect(skill.failureCount).toBe(0);
-  });
-
-  it("failure outcome bumps failureCount and leaves successCount unchanged", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_fail" }));
-
-    const result = await recordSkillOutcome(mock.store, stored.id, "failure");
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    expect(result.successCount).toBe(0);
-    expect(result.failureCount).toBe(1);
-  });
-
-  it("corrected outcome maps to failureCount +1 (counts as failure in binary mapping)", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_corrected" }));
-
-    const result = await recordSkillOutcome(mock.store, stored.id, "corrected");
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    expect(result.successCount).toBe(0);
-    expect(result.failureCount).toBe(1);
-  });
-
-  it("missed outcome maps to failureCount +1 (counts as failure in binary mapping)", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_missed" }));
-
-    const result = await recordSkillOutcome(mock.store, stored.id, "missed");
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    expect(result.successCount).toBe(0);
-    expect(result.failureCount).toBe(1);
-  });
-
-  it("accumulates counts across multiple outcomes on the same skill", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_accumulate" }));
-
-    await recordSkillOutcome(mock.store, stored.id, "success");
-    await recordSkillOutcome(mock.store, stored.id, "success");
-    await recordSkillOutcome(mock.store, stored.id, "failure");
-    await recordSkillOutcome(mock.store, stored.id, "corrected");
-    const final = await recordSkillOutcome(mock.store, stored.id, "success");
-
-    expect(final.updated).toBe(true);
-    if (!final.updated) throw new Error("guard");
-    expect(final.successCount).toBe(3);
-    expect(final.failureCount).toBe(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// recordSkillOutcome — error handling
-// ---------------------------------------------------------------------------
-
-describe("recordSkillOutcome prefix lookup (v2.5.1)", () => {
-  it("resolves 8+ hex prefix to full UUID and bumps successCount", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_prefix_ok" }));
-
-    // store_skill returns full UUID — agent might paste back only the 8-char short alias
-    // (as displayed in the legacy `Stored skill xxx` line). recordSkillOutcome must resolve.
-    const prefix = stored.id.slice(0, 8);
-    expect(prefix.length).toBe(8);
-    expect(prefix).not.toBe(stored.id); // sanity: prefix is shorter
-
-    const result = await recordSkillOutcome(mock.store, prefix, "success");
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    expect(result.successCount).toBe(1);
-    expect(result.failureCount).toBe(0);
-
-    const skill = getSkillMeta(mock.entries[0]);
-    expect(skill.successCount).toBe(1);
-  });
-
-  it("returns skill_not_found for ambiguous prefix (matches >1 skill)", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-
-    // Force two skills with same 8-char prefix by injecting explicit collision into mock.
-    // We seed entries directly so we can control IDs.
-    mock.entries.push({
-      id: "deadbeef-aaaa-bbbb-cccc-000000000001",
-      text: "skill A",
-      vector: [1, 1, 0],
-      category: "patterns",
-      scope: "project:test",
-      importance: 0.85,
-      timestamp: 1_700_000_000_000,
-      metadata: JSON.stringify({ skill: { name: "skill_a", implementation: "...", successCount: 0, failureCount: 0 } }),
-    });
-    mock.entries.push({
-      id: "deadbeef-aaaa-bbbb-cccc-000000000002",
-      text: "skill B",
-      vector: [1, 1, 0],
-      category: "patterns",
-      scope: "project:test",
-      importance: 0.85,
-      timestamp: 1_700_000_000_001,
-      metadata: JSON.stringify({ skill: { name: "skill_b", implementation: "...", successCount: 0, failureCount: 0 } }),
-    });
-
-    const result = await recordSkillOutcome(mock.store, "deadbeef", "success");
-
-    // Ambiguous prefix → getById returns null → recordSkillOutcome returns skill_not_found
-    expect(result.updated).toBe(false);
-    if (result.updated) throw new Error("guard");
-    expect(result.reason).toBe("skill_not_found");
-  });
-});
-
-describe("recordSkillOutcome error handling", () => {
-  it("returns skill_not_found when skillId does not exist (does not throw)", async () => {
-    const mock = createMockStore();
-    const result = await recordSkillOutcome(mock.store, "nonexistent-skill-id", "success");
-    expect(result.updated).toBe(false);
-    if (result.updated) throw new Error("guard");
-    expect(result.reason).toBe("skill_not_found");
-  });
-
-  it("returns not_a_skill when entry exists but category is not 'patterns'", async () => {
-    const mock = createMockStore();
-    // Use a valid UUID format — v2.5.1 getById rejects non-hex IDs (matches real store behavior).
-    const eventId = "aaaaaaaa-bbbb-cccc-dddd-000000000001";
-    await mock.store.store({
-      id: eventId,
-      text: "ordinary event memory",
-      vector: [1, 2, 3],
-      category: "events",
-      scope: TEST_SCOPE,
-      importance: 0.5,
-      metadata: JSON.stringify({ skill: { name: "ghost", implementation: "..." } }),
-    });
-
-    const result = await recordSkillOutcome(mock.store, eventId, "success");
-    expect(result.updated).toBe(false);
-    if (result.updated) throw new Error("guard");
-    expect(result.reason).toBe("not_a_skill");
-  });
-
-  it("returns skill_metadata_missing when category is 'patterns' but skill metadata is absent", async () => {
-    const mock = createMockStore();
-    // Use a valid UUID format — v2.5.1 getById rejects non-hex IDs.
-    const patternId = "bbbbbbbb-cccc-dddd-eeee-000000000002";
-    await mock.store.store({
-      id: patternId,
-      text: "generic pattern",
-      vector: [1, 2, 3],
-      category: "patterns",
-      scope: TEST_SCOPE,
-      importance: 0.5,
-      metadata: JSON.stringify({ tags: ["generic"] }),
-    });
-
-    const result = await recordSkillOutcome(mock.store, patternId, "success");
-    expect(result.updated).toBe(false);
-    if (result.updated) throw new Error("guard");
-    expect(result.reason).toBe("skill_metadata_missing");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// recordSkillOutcome — metadata integrity
-// ---------------------------------------------------------------------------
-
-describe("recordSkillOutcome metadata integrity", () => {
-  it("preserves all other skill fields when updating counts", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const input = validSkillInput({ name: "skill_integrity", verification: "check exit code is 0" });
-    const stored = await persistSkill(mock.store, embedder, input);
-
-    await recordSkillOutcome(mock.store, stored.id, "success");
-
-    const skill = getSkillMeta(mock.entries[0]);
-    expect(skill.name).toBe("skill_integrity");
-    expect(skill.description).toBe(input.description);
-    expect(skill.triggerPattern).toBe(input.triggerPattern);
-    expect(skill.implementationType).toBe("instruction_sequence");
-    expect(skill.implementation).toBe(input.implementation);
-    expect(skill.verification).toBe("check exit code is 0");
-  });
-
-  it("preserves top-level metadata fields (tags, source, evolution) when updating counts", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_top_meta" }));
-
-    await recordSkillOutcome(mock.store, stored.id, "failure");
-
-    const meta = JSON.parse(mock.entries[0].metadata || "{}");
-    expect(meta.source).toBe("agent");
-    expect(meta.tags).toEqual(["deploy", "production"]);
-    expect(meta.evolution).toBeDefined();
-    expect(meta.canonicalKey).toBe("patterns:skill:skill_top_meta");
-  });
-
-  it("sets lastRefinedAt to an ISO-8601 timestamp on each update", async () => {
-    const mock = createMockStore();
-    const embedder = createMockEmbedder();
-    const stored = await persistSkill(mock.store, embedder, validSkillInput({ name: "skill_timestamp" }));
-
-    const before = Date.now();
-    const result = await recordSkillOutcome(mock.store, stored.id, "success");
-    const after = Date.now();
-
-    expect(result.updated).toBe(true);
-    if (!result.updated) throw new Error("guard");
-    const refinedAt = Date.parse(result.lastRefinedAt);
-    expect(refinedAt).toBeGreaterThanOrEqual(before);
-    expect(refinedAt).toBeLessThanOrEqual(after);
-  });
-});