@vellumai/assistant 0.5.2 → 0.5.4

package/src/__tests__/skills-inline-command-expansions.test.ts

@@ -0,0 +1,301 @@
+import { describe, expect, test } from "bun:test";
+
+import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
+
+// ─── Basic parsing ────────────────────────────────────────────────────────────
+
+describe("parseInlineCommandExpansions", () => {
+  test("parses a single inline command expansion", () => {
+    const body = "Run this: !`gh pr diff`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.errors).toHaveLength(0);
+
+    const exp = result.expansions[0];
+    expect(exp.command).toBe("gh pr diff");
+    expect(exp.placeholderId).toBe(0);
+    expect(exp.startOffset).toBe(10);
+    expect(exp.endOffset).toBe(23);
+  });
+
+  test("parses multiple inline command expansions in order", () => {
+    const body = "First: !`ls -la` and second: !`echo hello`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.errors).toHaveLength(0);
+
+    expect(result.expansions[0].command).toBe("ls -la");
+    expect(result.expansions[0].placeholderId).toBe(0);
+
+    expect(result.expansions[1].command).toBe("echo hello");
+    expect(result.expansions[1].placeholderId).toBe(1);
+  });
+
+  test("preserves literal command text including internal spaces", () => {
+    const body = "!`git log --oneline -n 10`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("git log --oneline -n 10");
+  });
+
+  test("trims whitespace from command text", () => {
+    const body = "!`  gh pr diff  `";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("gh pr diff");
+  });
+
+  test("returns empty expansions for body with no tokens", () => {
+    const body = "Just a normal skill body with no inline commands.";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test("returns empty expansions for empty body", () => {
+    const result = parseInlineCommandExpansions("");
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // ─── Byte offsets ───────────────────────────────────────────────────────────
+
+  test("startOffset and endOffset match the token positions", () => {
+    const body = "abc !`cmd` def";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    const exp = result.expansions[0];
+    // "abc " = 4 chars, then !`cmd` = 6 chars
+    expect(exp.startOffset).toBe(4);
+    expect(exp.endOffset).toBe(10);
+    expect(body.slice(exp.startOffset, exp.endOffset)).toBe("!`cmd`");
+  });
+
+  // ─── Fenced code block handling ─────────────────────────────────────────────
+
+  test("ignores tokens inside fenced code blocks with backtick fence", () => {
+    const body = [
+      "Normal text with !`real command`",
+      "",
+      "```",
+      "Example: !`gh pr diff`",
+      "```",
+      "",
+      "More text with !`another real command`",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.expansions[0].command).toBe("real command");
+    expect(result.expansions[1].command).toBe("another real command");
+  });
+
+  test("ignores tokens inside fenced code blocks with tilde fence", () => {
+    const body = [
+      "~~~",
+      "!`should be ignored`",
+      "~~~",
+      "",
+      "!`should be found`",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("should be found");
+  });
+
+  test("ignores tokens inside fenced code blocks with info string", () => {
+    const body = [
+      "```markdown",
+      "Use !`gh pr diff` to view changes",
+      "```",
+      "",
+      "!`real command`",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("real command");
+  });
+
+  test("handles nested-like fence delimiters (longer opening fence)", () => {
+    const body = [
+      "````",
+      "```",
+      "!`inside nested`",
+      "```",
+      "````",
+      "",
+      "!`outside`",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("outside");
+  });
+
+  test("treats unclosed fenced code block as extending to EOF", () => {
+    const body = [
+      "```",
+      "!`inside unclosed fence`",
+      "This code block is never closed",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // ─── Fail-closed on malformed tokens ────────────────────────────────────────
+
+  test("rejects empty command text", () => {
+    const body = "!``";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].reason).toBe("Empty command text");
+    expect(result.errors[0].raw).toBe("!``");
+    expect(result.errors[0].offset).toBe(0);
+  });
+
+  test("rejects whitespace-only command text", () => {
+    const body = "!`   `";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].reason).toBe("Empty command text");
+  });
+
+  test("reports unmatched opening backtick", () => {
+    const body = "Some text !`unmatched";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].reason).toContain("Unmatched opening backtick");
+    expect(result.errors[0].offset).toBe(10);
+  });
+
+  test("valid and malformed tokens can coexist", () => {
+    const body = "!`good command` and !`` and !`another good`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.expansions[0].command).toBe("good command");
+    expect(result.expansions[0].placeholderId).toBe(0);
+    expect(result.expansions[1].command).toBe("another good");
+    expect(result.expansions[1].placeholderId).toBe(1);
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].reason).toBe("Empty command text");
+  });
+
+  // ─── Placeholder ID stability ───────────────────────────────────────────────
+
+  test("placeholder IDs are sequential by encounter order", () => {
+    const body = "!`first` then !`second` and !`third`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(3);
+    expect(result.expansions[0].placeholderId).toBe(0);
+    expect(result.expansions[1].placeholderId).toBe(1);
+    expect(result.expansions[2].placeholderId).toBe(2);
+  });
+
+  test("malformed tokens do not consume placeholder IDs", () => {
+    const body = "!`first` then !`` then !`second`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.expansions[0].placeholderId).toBe(0);
+    expect(result.expansions[1].placeholderId).toBe(1);
+  });
+
+  // ─── List items and paragraphs ──────────────────────────────────────────────
+
+  test("detects tokens in list items", () => {
+    const body = [
+      "- Step 1: !`git fetch`",
+      "- Step 2: !`git rebase origin/main`",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.expansions[0].command).toBe("git fetch");
+    expect(result.expansions[1].command).toBe("git rebase origin/main");
+  });
+
+  test("detects tokens across multiple paragraphs", () => {
+    const body = [
+      "First paragraph with !`cmd1`.",
+      "",
+      "Second paragraph with !`cmd2`.",
+    ].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(2);
+    expect(result.expansions[0].command).toBe("cmd1");
+    expect(result.expansions[1].command).toBe("cmd2");
+  });
+
+  // ─── Edge cases ─────────────────────────────────────────────────────────────
+
+  test("does not match regular backtick code spans", () => {
+    const body = "Use `gh pr diff` to view changes";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test("does not match bare exclamation marks", () => {
+    const body = "This is exciting! And `code` too!";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test("handles token at start of body", () => {
+    const body = "!`first thing`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("first thing");
+    expect(result.expansions[0].startOffset).toBe(0);
+  });
+
+  test("handles token at end of body", () => {
+    const body = "Do this: !`last thing`";
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(1);
+    expect(result.expansions[0].command).toBe("last thing");
+    expect(result.expansions[0].endOffset).toBe(body.length);
+  });
+
+  test("unmatched backtick inside fenced code block is not an error", () => {
+    const body = ["```", "!`unmatched inside fence", "```"].join("\n");
+
+    const result = parseInlineCommandExpansions(body);
+
+    expect(result.expansions).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+});

package/src/__tests__/skills-transitive-hash.test.ts

@@ -0,0 +1,333 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { SkillSummary } from "../config/skills.js";
+import { indexCatalogById } from "../skills/include-graph.js";
+import {
+  computeTransitiveSkillVersionHash,
+  TransitiveHashError,
+} from "../skills/transitive-version-hash.js";
+
+const testDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "transitive-hash-test-"));
+  testDirs.push(dir);
+  return dir;
+}
+
+/** Create a minimal SkillSummary with just the fields we need. */
+function makeSkill(
+  id: string,
+  directoryPath: string,
+  includes?: string[],
+): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: `Test skill ${id}`,
+    directoryPath,
+    skillFilePath: join(directoryPath, "SKILL.md"),
+    source: "managed",
+    includes,
+  };
+}
+
+afterEach(() => {
+  for (const dir of testDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("computeTransitiveSkillVersionHash", () => {
+  test("returns a tv1: prefixed sha256 hash for a single skill", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Root Skill\n");
+
+    const catalog = [makeSkill("root", dir)];
+    const index = indexCatalogById(catalog);
+
+    const hash = computeTransitiveSkillVersionHash("root", index);
+    expect(hash).toMatch(/^tv1:[0-9a-f]{64}$/);
+  });
+
+  test("is deterministic for same content", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Root Skill\n");
+
+    const catalog = [makeSkill("root", dir)];
+    const index = indexCatalogById(catalog);
+
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+    expect(hash1).toBe(hash2);
+  });
+
+  test("is stable across separate index builds with unchanged content", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Root Skill\n");
+
+    const catalog1 = [makeSkill("root", dir)];
+    const index1 = indexCatalogById(catalog1);
+    const hash1 = computeTransitiveSkillVersionHash("root", index1);
+
+    // Build a fresh catalog and index from the same directory
+    const catalog2 = [makeSkill("root", dir)];
+    const index2 = indexCatalogById(catalog2);
+    const hash2 = computeTransitiveSkillVersionHash("root", index2);
+
+    expect(hash1).toBe(hash2);
+  });
+
+  test("changes when root skill content changes", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Root v1\n");
+
+    const catalog = [makeSkill("root", dir)];
+    const index = indexCatalogById(catalog);
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+
+    writeFileSync(join(dir, "SKILL.md"), "# Root v2\n");
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("changes when an included child skill content changes", () => {
+    const rootDir = makeTempDir();
+    const childDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+    writeFileSync(join(childDir, "SKILL.md"), "# Child v1\n");
+
+    const catalog = [
+      makeSkill("root", rootDir, ["child"]),
+      makeSkill("child", childDir),
+    ];
+    const index = indexCatalogById(catalog);
+
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+
+    // Modify child
+    writeFileSync(join(childDir, "SKILL.md"), "# Child v2\n");
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("changes when a deeply nested child skill changes", () => {
+    const rootDir = makeTempDir();
+    const childDir = makeTempDir();
+    const grandchildDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+    writeFileSync(join(childDir, "SKILL.md"), "# Child\n");
+    writeFileSync(join(grandchildDir, "SKILL.md"), "# Grandchild v1\n");
+
+    const catalog = [
+      makeSkill("root", rootDir, ["child"]),
+      makeSkill("child", childDir, ["grandchild"]),
+      makeSkill("grandchild", grandchildDir),
+    ];
+    const index = indexCatalogById(catalog);
+
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+
+    writeFileSync(join(grandchildDir, "SKILL.md"), "# Grandchild v2\n");
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("includes all children in a diamond dependency graph", () => {
+    const rootDir = makeTempDir();
+    const leftDir = makeTempDir();
+    const rightDir = makeTempDir();
+    const bottomDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+    writeFileSync(join(leftDir, "SKILL.md"), "# Left\n");
+    writeFileSync(join(rightDir, "SKILL.md"), "# Right\n");
+    writeFileSync(join(bottomDir, "SKILL.md"), "# Bottom v1\n");
+
+    // Diamond: root -> [left, right], left -> [bottom], right -> [bottom]
+    const catalog = [
+      makeSkill("root", rootDir, ["left", "right"]),
+      makeSkill("left", leftDir, ["bottom"]),
+      makeSkill("right", rightDir, ["bottom"]),
+      makeSkill("bottom", bottomDir),
+    ];
+    const index = indexCatalogById(catalog);
+
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+
+    // Changing the shared bottom skill must change the root's transitive hash
+    writeFileSync(join(bottomDir, "SKILL.md"), "# Bottom v2\n");
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("throws TransitiveHashError with code 'missing' for missing child", () => {
+    const rootDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+
+    // Root references "missing-child" which is not in the catalog
+    const catalog = [makeSkill("root", rootDir, ["missing-child"])];
+    const index = indexCatalogById(catalog);
+
+    expect(() => computeTransitiveSkillVersionHash("root", index)).toThrow(
+      TransitiveHashError,
+    );
+
+    try {
+      computeTransitiveSkillVersionHash("root", index);
+    } catch (err) {
+      expect(err).toBeInstanceOf(TransitiveHashError);
+      expect((err as TransitiveHashError).code).toBe("missing");
+      expect((err as TransitiveHashError).message).toContain("missing-child");
+    }
+  });
+
+  test("throws TransitiveHashError with code 'cycle' for cyclic includes", () => {
+    const dirA = makeTempDir();
+    const dirB = makeTempDir();
+    writeFileSync(join(dirA, "SKILL.md"), "# A\n");
+    writeFileSync(join(dirB, "SKILL.md"), "# B\n");
+
+    // Cycle: a -> b -> a
+    const catalog = [makeSkill("a", dirA, ["b"]), makeSkill("b", dirB, ["a"])];
+    const index = indexCatalogById(catalog);
+
+    expect(() => computeTransitiveSkillVersionHash("a", index)).toThrow(
+      TransitiveHashError,
+    );
+
+    try {
+      computeTransitiveSkillVersionHash("a", index);
+    } catch (err) {
+      expect(err).toBeInstanceOf(TransitiveHashError);
+      expect((err as TransitiveHashError).code).toBe("cycle");
+    }
+  });
+
+  test("throws for a self-referencing cycle", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Self\n");
+
+    const catalog = [makeSkill("self-ref", dir, ["self-ref"])];
+    const index = indexCatalogById(catalog);
+
+    expect(() => computeTransitiveSkillVersionHash("self-ref", index)).toThrow(
+      TransitiveHashError,
+    );
+
+    try {
+      computeTransitiveSkillVersionHash("self-ref", index);
+    } catch (err) {
+      expect((err as TransitiveHashError).code).toBe("cycle");
+    }
+  });
+
+  test("throws for missing deeply nested child", () => {
+    const rootDir = makeTempDir();
+    const childDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+    writeFileSync(join(childDir, "SKILL.md"), "# Child\n");
+
+    // child references "ghost" which doesn't exist
+    const catalog = [
+      makeSkill("root", rootDir, ["child"]),
+      makeSkill("child", childDir, ["ghost"]),
+    ];
+    const index = indexCatalogById(catalog);
+
+    expect(() => computeTransitiveSkillVersionHash("root", index)).toThrow(
+      TransitiveHashError,
+    );
+
+    try {
+      computeTransitiveSkillVersionHash("root", index);
+    } catch (err) {
+      expect((err as TransitiveHashError).code).toBe("missing");
+      expect((err as TransitiveHashError).message).toContain("ghost");
+    }
+  });
+
+  test("skill with no includes behaves like a leaf", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Leaf Skill\n");
+
+    const catalog = [makeSkill("leaf", dir)];
+    const index = indexCatalogById(catalog);
+
+    // Should succeed with no errors
+    const hash = computeTransitiveSkillVersionHash("leaf", index);
+    expect(hash).toMatch(/^tv1:[0-9a-f]{64}$/);
+  });
+
+  test("skill with empty includes array behaves like a leaf", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "SKILL.md"), "# Leaf Skill\n");
+
+    const catalog = [makeSkill("leaf", dir, [])];
+    const index = indexCatalogById(catalog);
+
+    const hash = computeTransitiveSkillVersionHash("leaf", index);
+    expect(hash).toMatch(/^tv1:[0-9a-f]{64}$/);
+  });
+
+  test("adding a new file to a child changes the parent transitive hash", () => {
+    const rootDir = makeTempDir();
+    const childDir = makeTempDir();
+    writeFileSync(join(rootDir, "SKILL.md"), "# Root\n");
+    writeFileSync(join(childDir, "SKILL.md"), "# Child\n");
+
+    const catalog = [
+      makeSkill("root", rootDir, ["child"]),
+      makeSkill("child", childDir),
+    ];
+    const index = indexCatalogById(catalog);
+
+    const hash1 = computeTransitiveSkillVersionHash("root", index);
+
+    // Add a new file to child
+    writeFileSync(join(childDir, "helper.ts"), "export {};");
+    const hash2 = computeTransitiveSkillVersionHash("root", index);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("different include orderings produce different hashes", () => {
+    // The include graph structure is encoded by the DFS visit order,
+    // so different graphs must produce different hashes.
+    const rootDir1 = makeTempDir();
+    const rootDir2 = makeTempDir();
+    const childADir = makeTempDir();
+    const childBDir = makeTempDir();
+    writeFileSync(join(rootDir1, "SKILL.md"), "# Root\n");
+    writeFileSync(join(rootDir2, "SKILL.md"), "# Root\n");
+    writeFileSync(join(childADir, "SKILL.md"), "# A\n");
+    writeFileSync(join(childBDir, "SKILL.md"), "# B\n");
+
+    // Graph 1: root includes only A
+    const catalog1 = [
+      makeSkill("root", rootDir1, ["a"]),
+      makeSkill("a", childADir),
+      makeSkill("b", childBDir),
+    ];
+    const index1 = indexCatalogById(catalog1);
+    const hash1 = computeTransitiveSkillVersionHash("root", index1);
+
+    // Graph 2: root includes A and B
+    const catalog2 = [
+      makeSkill("root", rootDir2, ["a", "b"]),
+      makeSkill("a", childADir),
+      makeSkill("b", childBDir),
+    ];
+    const index2 = indexCatalogById(catalog2);
+    const hash2 = computeTransitiveSkillVersionHash("root", index2);
+
+    expect(hash1).not.toBe(hash2);
+  });
+});