@aetherwing/fcp-core 0.1.0 → 0.1.2

package/tests/event-log.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { EventLog } from "../src/event-log.js";
-
-describe("EventLog", () => {
-  it("appends events and advances cursor", () => {
-    const log = new EventLog<string>();
-    log.append("a");
-    log.append("b");
-    expect(log.cursor).toBe(2);
-    expect(log.length).toBe(2);
-  });
-
-  it("returns recent events in chronological order", () => {
-    const log = new EventLog<string>();
-    log.append("a");
-    log.append("b");
-    log.append("c");
-    expect(log.recent(2)).toEqual(["b", "c"]);
-    expect(log.recent()).toEqual(["a", "b", "c"]);
-  });
-
-  describe("undo", () => {
-    it("returns most recent event", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      const undone = log.undo();
-      expect(undone).toEqual(["b"]);
-      expect(log.cursor).toBe(1);
-    });
-
-    it("returns multiple events in reverse order", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      log.append("c");
-      const undone = log.undo(2);
-      expect(undone).toEqual(["c", "b"]);
-      expect(log.cursor).toBe(1);
-    });
-
-    it("returns empty array when nothing to undo", () => {
-      const log = new EventLog<string>();
-      expect(log.undo()).toEqual([]);
-    });
-
-    it("skips checkpoint sentinels", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.checkpoint("cp1");
-      log.append("b");
-      const undone = log.undo(2);
-      expect(undone).toEqual(["b", "a"]);
-    });
-  });
-
-  describe("redo", () => {
-    it("re-applies undone events in forward order", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      log.undo(2);
-      const redone = log.redo(2);
-      expect(redone).toEqual(["a", "b"]);
-      expect(log.cursor).toBe(2);
-    });
-
-    it("returns empty array when nothing to redo", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      expect(log.redo()).toEqual([]);
-    });
-
-    it("skips checkpoint sentinels during redo", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.checkpoint("cp1");
-      log.append("b");
-      log.undo(2);
-      const redone = log.redo(2);
-      expect(redone).toEqual(["a", "b"]);
-    });
-  });
-
-  describe("redo tail truncation", () => {
-    it("truncates redo history on new append", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      log.undo(); // cursor at 1, "b" is in redo tail
-      log.append("c"); // should truncate "b"
-      expect(log.length).toBe(2); // "a", "c"
-      expect(log.redo()).toEqual([]); // no redo available
-      expect(log.recent()).toEqual(["a", "c"]);
-    });
-  });
-
-  describe("checkpoint", () => {
-    it("creates a checkpoint that can be undone to", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.checkpoint("v1");
-      log.append("b");
-      log.append("c");
-      const undone = log.undoTo("v1");
-      expect(undone).toEqual(["c", "b"]);
-      // cursor should be at checkpoint position
-      expect(log.recent()).toEqual(["a"]);
-    });
-
-    it("returns null for unknown checkpoint", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      expect(log.undoTo("nonexistent")).toBeNull();
-    });
-
-    it("returns null if checkpoint is at/beyond cursor", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.checkpoint("v1");
-      // Undo past the checkpoint
-      log.undo(); // undo "a" (checkpoint is skipped)
-      // Now cursor is before the checkpoint, so undoTo should still work
-      // Actually: checkpoint is at position 1, cursor after undo of "a" is at 0
-      // So target(1) >= cursor(0) is false, it should work
-      // Let me test a different scenario where checkpoint IS at cursor
-      const log2 = new EventLog<string>();
-      log2.checkpoint("v1"); // checkpoint at position 0
-      log2.append("a");
-      // cursor is 2, checkpoint is 0 — should work
-      const result = log2.undoTo("v1");
-      expect(result).toEqual(["a"]);
-    });
-
-    it("removes checkpoints beyond cursor on truncation", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.checkpoint("v1");
-      log.append("b");
-      log.undo(2); // undo b and a, cursor before checkpoint
-      log.append("x"); // truncates everything including checkpoint
-      expect(log.undoTo("v1")).toBeNull(); // checkpoint gone
-    });
-  });
-
-  describe("cursor management", () => {
-    it("starts at 0", () => {
-      const log = new EventLog<string>();
-      expect(log.cursor).toBe(0);
-    });
-
-    it("advances on append", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      expect(log.cursor).toBe(1);
-      log.append("b");
-      expect(log.cursor).toBe(2);
-    });
-
-    it("moves back on undo", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      log.undo();
-      expect(log.cursor).toBe(1);
-    });
-
-    it("moves forward on redo", () => {
-      const log = new EventLog<string>();
-      log.append("a");
-      log.append("b");
-      log.undo();
-      log.redo();
-      expect(log.cursor).toBe(2);
-    });
-  });
-});

package/tests/formatter.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatResult, suggest } from "../src/formatter.js";
-
-describe("formatResult", () => {
-  it("formats success with prefix", () => {
-    expect(formatResult(true, "svc AuthService", "+")).toBe("+ svc AuthService");
-  });
-
-  it("formats success without prefix", () => {
-    expect(formatResult(true, "done")).toBe("done");
-  });
-
-  it("formats error", () => {
-    expect(formatResult(false, "something broke")).toBe("ERROR: something broke");
-  });
-
-  it("formats error ignoring prefix", () => {
-    expect(formatResult(false, "bad input", "+")).toBe("ERROR: bad input");
-  });
-
-  it("handles standard prefix conventions", () => {
-    expect(formatResult(true, "AuthService", "+")).toBe("+ AuthService"); // created
-    expect(formatResult(true, "edge A->B", "~")).toBe("~ edge A->B");   // modified
-    expect(formatResult(true, "styled A", "*")).toBe("* styled A");     // changed
-    expect(formatResult(true, "A", "-")).toBe("- A");                    // removed
-    expect(formatResult(true, "group Backend", "!")).toBe("! group Backend"); // meta
-    expect(formatResult(true, "layout", "@")).toBe("@ layout");          // bulk
-  });
-});
-
-describe("suggest", () => {
-  const candidates = ["add", "remove", "connect", "style", "label", "badge"];
-
-  it("suggests exact match", () => {
-    expect(suggest("add", candidates)).toBe("add");
-  });
-
-  it("suggests for single-char typo", () => {
-    expect(suggest("ad", candidates)).toBe("add");
-  });
-
-  it("suggests for transposition", () => {
-    expect(suggest("styel", candidates)).toBe("style");
-  });
-
-  it("suggests for substitution", () => {
-    expect(suggest("labek", candidates)).toBe("label");
-  });
-
-  it("returns null for distant strings", () => {
-    expect(suggest("zzzzzzz", candidates)).toBeNull();
-  });
-
-  it("returns null for empty candidates", () => {
-    expect(suggest("test", [])).toBeNull();
-  });
-
-  it("picks closest when multiple are close", () => {
-    expect(suggest("bade", candidates)).toBe("badge");
-  });
-});

package/tests/parsed-op.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseOp, isParseError } from "../src/parsed-op.js";
-
-describe("parseOp", () => {
-  it("parses a simple verb with positionals", () => {
-    const result = parseOp("add svc AuthService");
-    expect(isParseError(result)).toBe(false);
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("add");
-    expect(result.positionals).toEqual(["svc", "AuthService"]);
-    expect(result.params).toEqual({});
-    expect(result.selectors).toEqual([]);
-  });
-
-  it("extracts key:value params", () => {
-    const result = parseOp("add svc AuthService theme:blue near:Gateway");
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("add");
-    expect(result.positionals).toEqual(["svc", "AuthService"]);
-    expect(result.params).toEqual({ theme: "blue", near: "Gateway" });
-  });
-
-  it("extracts selectors", () => {
-    const result = parseOp("remove @type:db @recent:3");
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("remove");
-    expect(result.selectors).toEqual(["@type:db", "@recent:3"]);
-    expect(result.positionals).toEqual([]);
-  });
-
-  it("handles mixed token types", () => {
-    const result = parseOp("style @type:svc fill:#ff0000 bold");
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("style");
-    expect(result.selectors).toEqual(["@type:svc"]);
-    expect(result.params).toEqual({ fill: "#ff0000" });
-    expect(result.positionals).toEqual(["bold"]);
-  });
-
-  it("lowercases the verb", () => {
-    const result = parseOp("ADD svc Test");
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("add");
-  });
-
-  it("preserves original input as raw", () => {
-    const result = parseOp("  add svc Test  ");
-    if (isParseError(result)) return;
-    expect(result.raw).toBe("add svc Test");
-  });
-
-  it("handles quoted positionals", () => {
-    const result = parseOp('label Gateway "API Gateway v2"');
-    if (isParseError(result)) return;
-    expect(result.positionals).toEqual(["Gateway", "API Gateway v2"]);
-  });
-
-  it("returns error for empty input", () => {
-    const result = parseOp("");
-    expect(isParseError(result)).toBe(true);
-    if (!isParseError(result)) return;
-    expect(result.error).toBe("empty operation");
-  });
-
-  it("returns error for whitespace-only input", () => {
-    const result = parseOp("   ");
-    expect(isParseError(result)).toBe(true);
-  });
-
-  it("handles arrows as positionals", () => {
-    const result = parseOp("connect A -> B");
-    if (isParseError(result)) return;
-    expect(result.positionals).toEqual(["A", "->", "B"]);
-  });
-
-  it("handles verb-only input", () => {
-    const result = parseOp("undo");
-    if (isParseError(result)) return;
-    expect(result.verb).toBe("undo");
-    expect(result.positionals).toEqual([]);
-    expect(result.params).toEqual({});
-    expect(result.selectors).toEqual([]);
-  });
-});
-
-describe("isParseError", () => {
-  it("returns true for errors", () => {
-    expect(isParseError({ success: false, error: "test", raw: "" })).toBe(true);
-  });
-
-  it("returns false for valid ops", () => {
-    const result = parseOp("add test");
-    expect(isParseError(result)).toBe(false);
-  });
-});

package/tests/server.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createFcpServer, type FcpDomainAdapter, type OpResult } from "../src/server.js";
-import { EventLog } from "../src/event-log.js";
-import type { ParsedOp } from "../src/parsed-op.js";
-import type { VerbSpec } from "../src/verb-registry.js";
-
-// A minimal test domain
-interface TestModel {
-  title: string;
-  items: string[];
-}
-
-type TestEvent = { type: "add"; item: string } | { type: "remove"; item: string };
-
-const testVerbs: VerbSpec[] = [
-  { verb: "add", syntax: "add ITEM", category: "create", description: "Add an item" },
-  { verb: "remove", syntax: "remove ITEM", category: "modify", description: "Remove an item" },
-  { verb: "list", syntax: "list", category: "query", description: "List all items" },
-];
-
-const testAdapter: FcpDomainAdapter<TestModel, TestEvent> = {
-  createEmpty(title) {
-    return { title, items: [] };
-  },
-  serialize(model) {
-    return JSON.stringify(model);
-  },
-  deserialize(data) {
-    return JSON.parse(typeof data === "string" ? data : data.toString());
-  },
-  rebuildIndices() {},
-  getDigest(model) {
-    return `[${model.title}: ${model.items.length} items]`;
-  },
-  dispatchOp(op: ParsedOp, model: TestModel, log: EventLog<TestEvent>): OpResult {
-    switch (op.verb) {
-      case "add": {
-        const item = op.positionals[0];
-        if (!item) return { success: false, message: "add requires an item" };
-        model.items.push(item);
-        log.append({ type: "add", item });
-        return { success: true, message: item, prefix: "+" };
-      }
-      case "remove": {
-        const item = op.positionals[0];
-        if (!item) return { success: false, message: "remove requires an item" };
-        const idx = model.items.indexOf(item);
-        if (idx === -1) return { success: false, message: `"${item}" not found` };
-        model.items.splice(idx, 1);
-        log.append({ type: "remove", item });
-        return { success: true, message: item, prefix: "-" };
-      }
-      default:
-        return { success: false, message: `unhandled verb "${op.verb}"` };
-    }
-  },
-  dispatchQuery(query: string, model: TestModel) {
-    if (query === "list") {
-      return model.items.length === 0 ? "empty" : model.items.join(", ");
-    }
-    return `unknown query: ${query}`;
-  },
-  reverseEvent(event: TestEvent, model: TestModel) {
-    if (event.type === "add") {
-      const idx = model.items.indexOf(event.item);
-      if (idx !== -1) model.items.splice(idx, 1);
-    } else if (event.type === "remove") {
-      model.items.push(event.item);
-    }
-  },
-};
-
-describe("createFcpServer", () => {
-  it("creates an MCP server without errors", () => {
-    const server = createFcpServer({
-      domain: "test",
-      adapter: testAdapter,
-      verbs: testVerbs,
-    });
-    expect(server).toBeDefined();
-  });
-
-  it("creates a server with reference card sections", () => {
-    const server = createFcpServer({
-      domain: "test",
-      adapter: testAdapter,
-      verbs: testVerbs,
-      referenceCard: {
-        sections: { "Notes": "Some additional notes" },
-      },
-    });
-    expect(server).toBeDefined();
-  });
-});

package/tests/session.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { SessionDispatcher, type SessionHooks } from "../src/session.js";
-import { EventLog } from "../src/event-log.js";
-
-interface MockModel {
-  title: string;
-  data: string[];
-}
-
-function createMockSession() {
-  const eventLog = new EventLog<string>();
-  const hooks: SessionHooks<MockModel> = {
-    onNew: vi.fn((params) => ({
-      title: params["title"] ?? "Untitled",
-      data: [],
-    })),
-    onOpen: vi.fn(async (path) => ({
-      title: path,
-      data: ["loaded"],
-    })),
-    onSave: vi.fn(async () => {}),
-    onRebuildIndices: vi.fn(),
-    getDigest: vi.fn((model) => `[${model.title}: ${model.data.length} items]`),
-  };
-  const reverseEvent = vi.fn();
-  const replayEvent = vi.fn();
-  const session = new SessionDispatcher<MockModel, string>(hooks, eventLog, {
-    reverseEvent,
-    replayEvent,
-  });
-  return { session, hooks, eventLog, reverseEvent, replayEvent };
-}
-
-describe("SessionDispatcher", () => {
-  describe("new", () => {
-    it("creates a new model with title", async () => {
-      const { session, hooks } = createMockSession();
-      const result = await session.dispatch('new "My Song"');
-      expect(result).toBe('new "My Song" created');
-      expect(session.model).not.toBeNull();
-      expect(session.model?.title).toBe("My Song");
-      expect(hooks.onNew).toHaveBeenCalledWith({ title: "My Song" });
-    });
-
-    it("creates a new model with params", async () => {
-      const { session, hooks } = createMockSession();
-      await session.dispatch('new "Test" tempo:120');
-      expect(hooks.onNew).toHaveBeenCalledWith({ title: "Test", tempo: "120" });
-    });
-
-    it("defaults to Untitled", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("new");
-      expect(result).toBe('new "Untitled" created');
-    });
-
-    it("clears file path", async () => {
-      const { session } = createMockSession();
-      await session.dispatch("new Test");
-      expect(session.filePath).toBeNull();
-    });
-  });
-
-  describe("open", () => {
-    it("opens a file and sets model", async () => {
-      const { session, hooks } = createMockSession();
-      const result = await session.dispatch("open ./test.mid");
-      expect(result).toBe('opened "./test.mid"');
-      expect(session.model).not.toBeNull();
-      expect(session.filePath).toBe("./test.mid");
-      expect(hooks.onOpen).toHaveBeenCalledWith("./test.mid");
-    });
-
-    it("returns error when no path given", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("open");
-      expect(result).toBe("open requires a file path");
-    });
-
-    it("returns error message on failure", async () => {
-      const { session, hooks } = createMockSession();
-      (hooks.onOpen as ReturnType<typeof vi.fn>).mockRejectedValue(new Error("file not found"));
-      const result = await session.dispatch("open ./missing.mid");
-      expect(result).toBe("error: file not found");
-    });
-  });
-
-  describe("save", () => {
-    it("saves to the open file path", async () => {
-      const { session, hooks } = createMockSession();
-      await session.dispatch("open ./test.mid");
-      const result = await session.dispatch("save");
-      expect(result).toBe('saved "./test.mid"');
-      expect(hooks.onSave).toHaveBeenCalled();
-    });
-
-    it("saves to a new path with as:", async () => {
-      const { session } = createMockSession();
-      await session.dispatch("new Test");
-      const result = await session.dispatch("save as:./output.mid");
-      expect(result).toBe('saved "./output.mid"');
-      expect(session.filePath).toBe("./output.mid");
-    });
-
-    it("returns error when no model", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("save");
-      expect(result).toBe("error: no model to save");
-    });
-
-    it("returns error when no path", async () => {
-      const { session } = createMockSession();
-      await session.dispatch("new Test");
-      const result = await session.dispatch("save");
-      expect(result).toBe("error: no file path. Use save as:./file");
-    });
-  });
-
-  describe("checkpoint", () => {
-    it("creates a checkpoint", async () => {
-      const { session, eventLog } = createMockSession();
-      const result = await session.dispatch("checkpoint v1");
-      expect(result).toBe('checkpoint "v1" created');
-      expect(eventLog.cursor).toBeGreaterThan(0);
-    });
-
-    it("requires a name", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("checkpoint");
-      expect(result).toBe("checkpoint requires a name");
-    });
-  });
-
-  describe("undo", () => {
-    it("undoes events", async () => {
-      const { session, eventLog } = createMockSession();
-      await session.dispatch("new Test");
-      eventLog.append("event1");
-      eventLog.append("event2");
-      const result = await session.dispatch("undo");
-      expect(result).toBe("undone 1 event");
-    });
-
-    it("returns nothing to undo when empty", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("undo");
-      expect(result).toBe("nothing to undo");
-    });
-
-    it("undoes to a checkpoint", async () => {
-      const { session, eventLog } = createMockSession();
-      await session.dispatch("new Test");
-      eventLog.append("event1");
-      await session.dispatch("checkpoint v1");
-      eventLog.append("event2");
-      eventLog.append("event3");
-      const result = await session.dispatch("undo to:v1");
-      expect(result).toContain("undone");
-      expect(result).toContain("checkpoint");
-    });
-
-    it("calls onRebuildIndices after undo", async () => {
-      const { session, hooks, eventLog } = createMockSession();
-      await session.dispatch("new Test");
-      eventLog.append("event1");
-      await session.dispatch("undo");
-      expect(hooks.onRebuildIndices).toHaveBeenCalled();
-    });
-  });
-
-  describe("redo", () => {
-    it("redoes events", async () => {
-      const { session, eventLog } = createMockSession();
-      await session.dispatch("new Test");
-      eventLog.append("event1");
-      eventLog.undo();
-      const result = await session.dispatch("redo");
-      expect(result).toBe("redone 1 event");
-    });
-
-    it("returns nothing to redo when at end", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("redo");
-      expect(result).toBe("nothing to redo");
-    });
-
-    it("calls onRebuildIndices after redo", async () => {
-      const { session, hooks, eventLog } = createMockSession();
-      await session.dispatch("new Test");
-      eventLog.append("event1");
-      eventLog.undo();
-      await session.dispatch("redo");
-      expect(hooks.onRebuildIndices).toHaveBeenCalled();
-    });
-  });
-
-  describe("unknown commands", () => {
-    it("returns error for unknown actions", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("explode");
-      expect(result).toBe('unknown session action "explode"');
-    });
-
-    it("returns error for empty action", async () => {
-      const { session } = createMockSession();
-      const result = await session.dispatch("");
-      expect(result).toBe("empty action");
-    });
-  });
-});