decision-os-mcp 0.3.2 → 0.4.0

package/test/hierarchical-storage.test.ts

@@ -1,223 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { existsSync } from "fs";
-import { rm, mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { tmpdir } from "os";
-import YAML from "yaml";
-import { HierarchicalDecisionOSStorage } from "../src/hierarchical-storage.js";
-
-let projectDir: string;
-let globalDir: string;
-let baseDir: string;
-
-/**
- * Helper to set up a project + global .decision-os structure in a temp dir.
- * We can't rely on ~ for tests, so we structure it manually.
- */
-async function setupLayers(): Promise<{
-  storage: HierarchicalDecisionOSStorage;
-  projectDosPath: string;
-  globalDosPath: string;
-}> {
-  baseDir = join(tmpdir(), `dos-hier-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  projectDir = join(baseDir, "myproject");
-  const projectDosPath = join(projectDir, ".decision-os");
-  globalDir = join(baseDir, "global");
-  const globalDosPath = join(globalDir, ".decision-os");
-
-  // Create project .decision-os
-  await mkdir(join(projectDosPath, "cases"), { recursive: true });
-  await mkdir(join(projectDosPath, "defaults"), { recursive: true });
-  await writeFile(
-    join(projectDosPath, "config.yaml"),
-    YAML.stringify({ project: "test-project", version: 1, scope: "PROJECT" })
-  );
-  await writeFile(
-    join(projectDosPath, "defaults", "foundations.yaml"),
-    YAML.stringify({ foundations: [] })
-  );
-
-  // Create global .decision-os (in a parent dir, not ~)
-  await mkdir(join(globalDosPath, "cases"), { recursive: true });
-  await mkdir(join(globalDosPath, "defaults"), { recursive: true });
-  await writeFile(
-    join(globalDosPath, "config.yaml"),
-    YAML.stringify({ project: "_global", version: 1, scope: "GLOBAL" })
-  );
-  await writeFile(
-    join(globalDosPath, "defaults", "foundations.yaml"),
-    YAML.stringify({ foundations: [] })
-  );
-
-  // HierarchicalDecisionOSStorage discovers layers by walking up.
-  // We test with just the project layer since global discovery uses homedir().
-  const storage = new HierarchicalDecisionOSStorage(projectDir);
-  await storage.initialize();
-
-  return { storage, projectDosPath, globalDosPath };
-}
-
-afterEach(async () => {
-  if (baseDir && existsSync(baseDir)) {
-    await rm(baseDir, { recursive: true, force: true });
-  }
-});
-
-// ============================================================================
-// LAYER DISCOVERY
-// ============================================================================
-
-describe("layer discovery", () => {
-  it("discovers project .decision-os from workspace path", async () => {
-    const { storage, projectDosPath } = await setupLayers();
-    expect(storage.getProjectPath()).toBe(projectDosPath);
-  });
-
-  it("throws when no .decision-os found", async () => {
-    const emptyDir = join(tmpdir(), `dos-empty-${Date.now()}`);
-    await mkdir(emptyDir, { recursive: true });
-
-    // This should throw since there's no .decision-os anywhere
-    // (unless user has ~/.decision-os which we can't control in tests)
-    try {
-      const s = new HierarchicalDecisionOSStorage(emptyDir);
-      // If it didn't throw, it found ~/.decision-os — that's fine
-      await s.initialize();
-    } catch (e) {
-      expect((e as Error).message).toContain("No .decision-os found");
-    }
-
-    await rm(emptyDir, { recursive: true, force: true });
-  });
-});
-
-// ============================================================================
-// FOUNDATION RELEVANCE RANKING
-// ============================================================================
-
-describe("foundation relevance ranking", () => {
-  it("ranks foundations matching active case tags first", async () => {
-    const { storage } = await setupLayers();
-
-    // Create a case with specific affected_surface
-    const c = await storage.createCase({
-      title: "Database migration",
-      signals: {
-        context: {
-          affected_surface: ["DATA_MODEL", "BACKEND"],
-        },
-      },
-    });
-
-    // Create two foundations — one relevant, one general
-    const pe1 = await storage.logPressure({
-      expected: "x", actual: "y", adaptation: "z", remember: "w",
-    });
-    const pe2 = await storage.logPressure({
-      expected: "a", actual: "b", adaptation: "c", remember: "d",
-    });
-
-    await storage.promoteToFoundation({
-      title: "UI pattern",
-      default_behavior: "Use this UI pattern",
-      context_tags: ["UI_UX", "FRONTEND"],
-      source_pressures: [pe1.id],
-    });
-    await storage.promoteToFoundation({
-      title: "Data modeling pattern",
-      default_behavior: "Model data this way",
-      context_tags: ["DATA_MODEL", "BACKEND"],
-      source_pressures: [pe2.id],
-    });
-
-    const context = await storage.getContext();
-
-    // Data model foundation should come first (matches case tags)
-    expect(context.relevant_foundations[0].title).toBe("Data modeling pattern");
-    expect((context.relevant_foundations[0] as any)._relevance).toBe("directly_relevant");
-    expect((context.relevant_foundations[1] as any)._relevance).toBe("general");
-  });
-
-  it("returns all foundations when no active case", async () => {
-    const { storage } = await setupLayers();
-
-    const c = await storage.createCase({ title: "temp" });
-    const pe = await storage.logPressure({
-      expected: "x", actual: "y", adaptation: "z", remember: "w",
-    });
-    await storage.promoteToFoundation({
-      title: "Some foundation",
-      default_behavior: "Do it",
-      context_tags: ["TEST"],
-      source_pressures: [pe.id],
-    });
-    await storage.closeCase(c.id, { regret: 1 });
-
-    // No active case now
-    const context = await storage.getContext();
-    expect(context.active_case).toBeNull();
-    expect(context.relevant_foundations.length).toBeGreaterThanOrEqual(1);
-  });
-});
-
-// ============================================================================
-// CLOSE CASE WITH FORGETTING (through hierarchical layer)
-// ============================================================================
-
-describe("close case with forgetting", () => {
-  it("returns forgotten flag through hierarchical storage", async () => {
-    const { storage } = await setupLayers();
-
-    const c = await storage.createCase({ title: "clean task" });
-    const result = await storage.closeCase(c.id, { regret: 0 });
-
-    expect(result.forgotten).toBe(true);
-  });
-
-  it("preserves case with unpromoted PEs", async () => {
-    const { storage } = await setupLayers();
-
-    const c = await storage.createCase({ title: "has lessons" });
-    await storage.logPressure({
-      expected: "x", actual: "y", adaptation: "z", remember: "w",
-    });
-    const result = await storage.closeCase(c.id, { regret: 0 });
-
-    expect(result.forgotten).toBe(false);
-  });
-});
-
-// ============================================================================
-// SUGGEST REVIEW (through hierarchical layer)
-// ============================================================================
-
-describe("suggest review", () => {
-  it("delegates suggest_review to project layer", async () => {
-    const { storage } = await setupLayers();
-
-    const c = await storage.createCase({ title: "test" });
-    await storage.logPressure({
-      expected: "x", actual: "y", adaptation: "z", remember: "w",
-    });
-    await storage.closeCase(c.id, { regret: 0 });
-
-    const review = await storage.suggestReview();
-    expect(review.blocking_forgetting).toHaveLength(1);
-  });
-});
-
-// ============================================================================
-// ACTIVE CASE PERSISTENCE (through hierarchical layer)
-// ============================================================================
-
-describe("active case persistence via hierarchical storage", () => {
-  it("persists active case through setActiveCase", async () => {
-    const { storage } = await setupLayers();
-
-    const c = await storage.createCase({ title: "test" });
-    expect(storage.getActiveCase()).toBe(c.id);
-
-    await storage.setActiveCase(null);
-    expect(storage.getActiveCase()).toBeNull();
-  });
-});