stagent 0.9.6 → 0.11.0

package/src/lib/chat/__tests__/command-tabs.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import {
+  COMMAND_TABS,
+  GROUP_TO_TAB,
+  partitionCatalogByTab,
+  isCommandTabId,
+  type CommandTabId,
+} from "../command-tabs";
+import type { ToolCatalogEntry, ToolGroup } from "../tool-catalog";
+
+const entry = (name: string, group: ToolGroup): ToolCatalogEntry => ({
+  name,
+  description: name,
+  group,
+});
+
+describe("command-tabs", () => {
+  it("exposes four tabs in canonical order", () => {
+    expect(COMMAND_TABS.map((t) => t.id)).toEqual([
+      "actions",
+      "skills",
+      "tools",
+      "entities",
+    ]);
+  });
+
+  it("maps every ToolGroup to exactly one tab", () => {
+    const groups: ToolGroup[] = [
+      "Session", "Tasks", "Projects", "Workflows", "Schedules", "Documents", "Tables",
+      "Notifications", "Profiles", "Skills", "Usage", "Settings", "Chat",
+      "Browser", "Utility",
+    ];
+    for (const g of groups) {
+      expect(GROUP_TO_TAB[g]).toBeDefined();
+    }
+  });
+
+  it("routes Session group to the Actions tab", () => {
+    expect(GROUP_TO_TAB.Session).toBe("actions");
+  });
+
+  it("routes Skills group to the Skills tab", () => {
+    expect(GROUP_TO_TAB.Skills).toBe("skills");
+  });
+
+  it("routes Browser + Utility to the Tools tab", () => {
+    expect(GROUP_TO_TAB.Browser).toBe("tools");
+    expect(GROUP_TO_TAB.Utility).toBe("tools");
+  });
+
+  it("partitions catalog entries by tab", () => {
+    const catalog: ToolCatalogEntry[] = [
+      entry("list_tasks", "Tasks"),
+      entry("researcher", "Skills"),
+      entry("take_screenshot", "Browser"),
+    ];
+    const part = partitionCatalogByTab(catalog);
+    expect(part.actions.map((e) => e.name)).toEqual(["list_tasks"]);
+    expect(part.skills.map((e) => e.name)).toEqual(["researcher"]);
+    expect(part.tools.map((e) => e.name)).toEqual(["take_screenshot"]);
+    expect(part.entities).toEqual([]);
+  });
+
+  it("isCommandTabId rejects unknown values", () => {
+    expect(isCommandTabId("actions")).toBe(true);
+    expect(isCommandTabId("random")).toBe(false);
+  });
+});

package/src/lib/chat/__tests__/context-builder-files.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockFs } = vi.hoisted(() => ({
+  mockFs: {
+    realpathMap: new Map<string, string>(),
+    files: new Map<string, string>(),
+    statMap: new Map<string, { size: number }>(),
+  },
+}));
+
+vi.mock("node:fs", () => {
+  const realpathSync = (p: string) => {
+    const real = mockFs.realpathMap.get(p);
+    if (real === undefined) throw new Error(`ENOENT: realpath ${p}`);
+    return real;
+  };
+  const statSync = (p: string) => {
+    const s = mockFs.statMap.get(p);
+    if (!s) throw new Error(`ENOENT: stat ${p}`);
+    return s;
+  };
+  const readFileSync = (p: string) => {
+    const content = mockFs.files.get(p);
+    if (content === undefined) throw new Error(`ENOENT: read ${p}`);
+    return content;
+  };
+  return {
+    default: { realpathSync, statSync, readFileSync },
+    realpathSync,
+    statSync,
+    readFileSync,
+  };
+});
+
+import { expandFileMention } from "../files/expand-mention";
+
+const CWD = "/repo";
+
+beforeEach(() => {
+  mockFs.realpathMap.clear();
+  mockFs.files.clear();
+  mockFs.statMap.clear();
+  mockFs.realpathMap.set(CWD, CWD);
+});
+
+function registerFile(relPath: string, content: string) {
+  const abs = `${CWD}/${relPath}`;
+  mockFs.files.set(abs, content);
+  mockFs.statMap.set(abs, { size: Buffer.byteLength(content, "utf8") });
+}
+
+describe("expandFileMention", () => {
+  it("inlines files under 8 KB with a path header and fenced code block", () => {
+    registerFile("src/a.ts", "export const x = 1;\n");
+    const out = expandFileMention("src/a.ts", CWD).join("\n");
+    expect(out).toContain("### File: src/a.ts");
+    expect(out).toContain("```ts");
+    expect(out).toContain("export const x = 1;");
+    expect(out).toContain("```");
+  });
+
+  it("references files >= 8 KB without inlining their content", () => {
+    const big = "A".repeat(10 * 1024);
+    registerFile("docs/large.md", big);
+    const out = expandFileMention("docs/large.md", CWD).join("\n");
+    expect(out).toContain("File (by reference): docs/large.md");
+    expect(out).toContain("KB)"); // size hint
+    expect(out).toContain("Use the Read tool");
+    expect(out).not.toContain(big); // content not inlined
+  });
+
+  it("emits a not-found note when the file no longer exists", () => {
+    const out = expandFileMention("src/gone.ts", CWD).join("\n");
+    expect(out).toContain("### File: src/gone.ts");
+    expect(out).toContain("(file not found at context-build time)");
+  });
+
+  it("rejects paths that resolve outside cwd (security guardrail)", () => {
+    const out = expandFileMention("../escape.ts", CWD).join("\n");
+    expect(out).toContain("(invalid path — escapes working directory)");
+    expect(out).not.toContain("(file not found"); // did not even try to read
+  });
+
+  it("skips pathological files >= 50 MB silently (returns empty)", () => {
+    const abs = `${CWD}/huge.bin`;
+    mockFs.statMap.set(abs, { size: 60 * 1024 * 1024 });
+    // readFileSync is never reached
+    const out = expandFileMention("huge.bin", CWD);
+    expect(out).toEqual([]);
+  });
+
+  it("picks an 'unknown' code-fence language for files without an extension", () => {
+    const abs = `${CWD}/Makefile`;
+    mockFs.files.set(abs, "all:\n\techo ok\n");
+    mockFs.statMap.set(abs, { size: 16 });
+    const out = expandFileMention("Makefile", CWD).join("\n");
+    // .split(".").pop() on a name with no dot returns the whole name,
+    // which is the best we can do without a language map. We just
+    // assert a header + a closing fence are present.
+    expect(out).toContain("### File: Makefile");
+    expect(out).toMatch(/```[\w]*/);
+    expect(out).toContain("all:");
+  });
+
+  it("emits a read-failure note if the file stats OK but reads throw", () => {
+    const abs = `${CWD}/src/binary.ico`;
+    mockFs.statMap.set(abs, { size: 100 });
+    // Do NOT register contents — readFileSync will throw
+    const out = expandFileMention("src/binary.ico", CWD).join("\n");
+    expect(out).toContain("(file could not be read as UTF-8)");
+  });
+});

package/src/lib/chat/__tests__/dismissals.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import {
+  loadDismissals,
+  saveDismissal,
+  activeDismissedIds,
+  DISMISSAL_TTL_MS,
+} from "../dismissals";
+
+type Store = { read: () => string | null; write: (v: string) => void };
+
+function mockStore(initial: string | null = null): Store {
+  let v = initial;
+  return {
+    read: () => v,
+    write: (next) => {
+      v = next;
+    },
+  };
+}
+
+describe("dismissals", () => {
+  const NOW = 1_700_000_000_000;
+
+  it("returns empty when store is null", () => {
+    const store = mockStore();
+    const all = loadDismissals(store);
+    expect(all).toEqual({});
+  });
+
+  it("saves dismissals keyed by conversation + skill", () => {
+    const store = mockStore();
+    saveDismissal(store, "conv-1", "skill-a", NOW);
+    const all = loadDismissals(store);
+    expect(all["conv-1"]["skill-a"]).toBe(NOW);
+  });
+
+  it("activeDismissedIds excludes expired entries", () => {
+    const store = mockStore();
+    saveDismissal(store, "c1", "fresh", NOW);
+    saveDismissal(store, "c1", "old", NOW - DISMISSAL_TTL_MS - 1000);
+    const ids = activeDismissedIds(store, "c1", NOW);
+    expect(ids.has("fresh")).toBe(true);
+    expect(ids.has("old")).toBe(false);
+  });
+
+  it("returns empty set when conversation has no dismissals", () => {
+    const store = mockStore();
+    expect(activeDismissedIds(store, "never-seen", NOW).size).toBe(0);
+  });
+
+  it("silently tolerates store write errors", () => {
+    const store: Store = {
+      read: () => null,
+      write: () => {
+        throw new Error("quota");
+      },
+    };
+    expect(() => saveDismissal(store, "c1", "s1", NOW)).not.toThrow();
+  });
+
+  it("silently tolerates corrupt JSON on read", () => {
+    const store = mockStore("not-json");
+    expect(loadDismissals(store)).toEqual({});
+  });
+});

package/src/lib/chat/__tests__/engine-sdk-options.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import {
+  CLAUDE_SDK_ALLOWED_TOOLS,
+  CLAUDE_SDK_SETTING_SOURCES,
+  CLAUDE_SDK_READ_ONLY_FS_TOOLS,
+} from "@/lib/chat/engine";
+
+describe("Claude SDK options (Phase 1a)", () => {
+  it("declares settingSources loading user and project config", () => {
+    expect(CLAUDE_SDK_SETTING_SOURCES).toEqual(["user", "project"]);
+  });
+
+  it("includes Skill, filesystem tools, Bash, and TodoWrite in allowedTools", () => {
+    expect(CLAUDE_SDK_ALLOWED_TOOLS).toEqual(
+      expect.arrayContaining([
+        "Skill",
+        "Read",
+        "Grep",
+        "Glob",
+        "Edit",
+        "Write",
+        "Bash",
+        "TodoWrite",
+      ])
+    );
+  });
+
+  it("does NOT include Task (subagent delegation replaced by Stagent primitives)", () => {
+    expect(CLAUDE_SDK_ALLOWED_TOOLS).not.toContain("Task");
+  });
+
+  it("declares Read, Grep, Glob as read-only filesystem tools", () => {
+    expect(CLAUDE_SDK_READ_ONLY_FS_TOOLS).toEqual(
+      new Set(["Read", "Grep", "Glob"])
+    );
+  });
+
+  it("does NOT treat Edit, Write, Bash, or TodoWrite as read-only", () => {
+    for (const tool of ["Edit", "Write", "Bash", "TodoWrite"]) {
+      expect(CLAUDE_SDK_READ_ONLY_FS_TOOLS.has(tool)).toBe(false);
+    }
+  });
+});
+
+import { canUseToolForTest } from "@/lib/chat/engine";
+
+describe("canUseTool auto-allow policy for SDK filesystem tools", () => {
+  it("auto-allows Read without a permission request", async () => {
+    const result = await canUseToolForTest("Read", { file_path: "/tmp/x" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Grep without a permission request", async () => {
+    const result = await canUseToolForTest("Grep", { pattern: "foo" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Glob without a permission request", async () => {
+    const result = await canUseToolForTest("Glob", { pattern: "**/*.ts" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Skill tool invocation", async () => {
+    const result = await canUseToolForTest("Skill", { skill: "code-reviewer" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("does NOT auto-allow Edit (must go through permission flow)", async () => {
+    const result = await canUseToolForTest("Edit", { file_path: "/tmp/x", content: "y" });
+    expect(result.behavior).not.toBe("allow");
+  });
+
+  it("does NOT auto-allow Bash", async () => {
+    const result = await canUseToolForTest("Bash", { command: "ls" });
+    expect(result.behavior).not.toBe("allow");
+  });
+});
+
+describe("hooks excluded per Q2", () => {
+  it("does not declare a hooks field alongside settingSources", async () => {
+    const fs = await import("fs");
+    const path = await import("path");
+    const enginePath = path.resolve(__dirname, "../engine.ts");
+    const source = fs.readFileSync(enginePath, "utf8");
+    // Assert that within the query() options block, there is no `hooks:` field.
+    // This is a regex-level check because the options object is inline literals.
+    const optionsBlock = source.match(/query\(\s*\{[\s\S]*?\}\s*\)/)?.[0] ?? "";
+    expect(optionsBlock).toContain("settingSources");
+    expect(optionsBlock).not.toMatch(/\bhooks\s*:/);
+  });
+});
+
+describe("CLAUDE_SDK_* constants source-of-truth", () => {
+  it("exports CLAUDE_SDK_ALLOWED_TOOLS from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_ALLOWED_TOOLS).toEqual([
+      "Skill",
+      "Read",
+      "Grep",
+      "Glob",
+      "Edit",
+      "Write",
+      "Bash",
+      "TodoWrite",
+    ]);
+  });
+
+  it("exports CLAUDE_SDK_SETTING_SOURCES from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_SETTING_SOURCES).toEqual(["user", "project"]);
+  });
+
+  it("exports CLAUDE_SDK_READ_ONLY_FS_TOOLS from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_READ_ONLY_FS_TOOLS).toEqual(new Set(["Read", "Grep", "Glob"]));
+  });
+});

package/src/lib/chat/__tests__/finalize-safety-net.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { conversations, chatMessages } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { finalizeStreamingMessage } from "../reconcile";
+
+function seedConversation(): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(conversations)
+    .values({
+      id,
+      runtimeId: "test-runtime",
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+function seedStreaming(convId: string, content: string): string {
+  const id = randomUUID();
+  db.insert(chatMessages)
+    .values({
+      id,
+      conversationId: convId,
+      role: "assistant",
+      content,
+      status: "streaming",
+      createdAt: new Date(),
+    })
+    .run();
+  return id;
+}
+
+describe("finalizeStreamingMessage", () => {
+  beforeEach(() => {
+    db.delete(chatMessages).run();
+    db.delete(conversations).run();
+  });
+
+  it("is a no-op when the message is already complete", async () => {
+    const convId = seedConversation();
+    const id = randomUUID();
+    db.insert(chatMessages)
+      .values({
+        id,
+        conversationId: convId,
+        role: "assistant",
+        content: "Already finished",
+        status: "complete",
+        createdAt: new Date(),
+      })
+      .run();
+
+    await finalizeStreamingMessage(id, "ignored salvage text");
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, id))
+      .get();
+    expect(row?.status).toBe("complete");
+    expect(row?.content).toBe("Already finished");
+  });
+
+  it("salvages streaming row with substantial content as complete", async () => {
+    const convId = seedConversation();
+    const id = seedStreaming(convId, "");
+    const partialText =
+      "I searched the web and found three relevant articles about the topic. Here are the highlights of what I learned...";
+
+    await finalizeStreamingMessage(id, partialText);
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, id))
+      .get();
+    expect(row?.status).toBe("complete");
+    expect(row?.content).toBe(partialText);
+  });
+
+  it("marks streaming row with no content as error with fallback string", async () => {
+    const convId = seedConversation();
+    const id = seedStreaming(convId, "");
+
+    await finalizeStreamingMessage(id, "");
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, id))
+      .get();
+    expect(row?.status).toBe("error");
+    expect(row?.content).toMatch(/interrupted/i);
+    expect(row?.content.length).toBeGreaterThan(0);
+  });
+
+  it("marks streaming row with very short content as error, not complete", async () => {
+    const convId = seedConversation();
+    const id = seedStreaming(convId, "");
+
+    // 20 chars — not substantial enough to call "complete"
+    await finalizeStreamingMessage(id, "Just a short reply.");
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, id))
+      .get();
+    expect(row?.status).toBe("error");
+    expect(row?.content).toBe("Just a short reply.");
+  });
+
+  it("marks streaming row with whitespace-only fullText as error with fallback", async () => {
+    const convId = seedConversation();
+    const id = seedStreaming(convId, "");
+
+    await finalizeStreamingMessage(id, "   \n\n  \t ");
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, id))
+      .get();
+    expect(row?.status).toBe("error");
+    expect(row?.content).toMatch(/interrupted/i);
+  });
+
+  it("is a no-op when the message does not exist", async () => {
+    // Should not throw — defensive null check
+    await expect(
+      finalizeStreamingMessage("nonexistent-id", "some text"),
+    ).resolves.not.toThrow();
+  });
+});

package/src/lib/chat/__tests__/reconcile.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { conversations, chatMessages } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { reconcileStreamingMessages } from "../reconcile";
+
+function seedConversation(): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(conversations)
+    .values({
+      id,
+      runtimeId: "test-runtime",
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+function seedMessage(opts: {
+  conversationId: string;
+  status: "streaming" | "complete" | "error";
+  content: string;
+  createdAt: Date;
+}): string {
+  const id = randomUUID();
+  db.insert(chatMessages)
+    .values({
+      id,
+      conversationId: opts.conversationId,
+      role: "assistant",
+      content: opts.content,
+      status: opts.status,
+      createdAt: opts.createdAt,
+    })
+    .run();
+  return id;
+}
+
+describe("reconcileStreamingMessages", () => {
+  beforeEach(() => {
+    // Isolate each test
+    db.delete(chatMessages).run();
+    db.delete(conversations).run();
+  });
+
+  it("sweeps a 20-min-old streaming row with empty content to error state with fallback", async () => {
+    const convId = seedConversation();
+    const twentyMinAgo = new Date(Date.now() - 20 * 60 * 1000);
+    const msgId = seedMessage({
+      conversationId: convId,
+      status: "streaming",
+      content: "",
+      createdAt: twentyMinAgo,
+    });
+
+    const swept = await reconcileStreamingMessages();
+
+    expect(swept).toBe(1);
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, msgId))
+      .get();
+    expect(row?.status).toBe("error");
+    expect(row?.content).toMatch(/Interrupted/i);
+    expect(row?.content.length).toBeGreaterThan(0);
+  });
+
+  it("leaves a 30-second-old streaming row untouched", async () => {
+    const convId = seedConversation();
+    const thirtySecAgo = new Date(Date.now() - 30 * 1000);
+    const msgId = seedMessage({
+      conversationId: convId,
+      status: "streaming",
+      content: "",
+      createdAt: thirtySecAgo,
+    });
+
+    const swept = await reconcileStreamingMessages();
+
+    expect(swept).toBe(0);
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, msgId))
+      .get();
+    expect(row?.status).toBe("streaming");
+    expect(row?.content).toBe("");
+  });
+
+  it("preserves partial content when sweeping old streaming row", async () => {
+    const convId = seedConversation();
+    const twentyMinAgo = new Date(Date.now() - 20 * 60 * 1000);
+    const msgId = seedMessage({
+      conversationId: convId,
+      status: "streaming",
+      content: "Here is what I found so",
+      createdAt: twentyMinAgo,
+    });
+
+    await reconcileStreamingMessages();
+
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, msgId))
+      .get();
+    expect(row?.status).toBe("error");
+    expect(row?.content).toBe("Here is what I found so");
+  });
+
+  it("leaves complete messages untouched regardless of age", async () => {
+    const convId = seedConversation();
+    const twentyMinAgo = new Date(Date.now() - 20 * 60 * 1000);
+    const msgId = seedMessage({
+      conversationId: convId,
+      status: "complete",
+      content: "Finished response",
+      createdAt: twentyMinAgo,
+    });
+
+    const swept = await reconcileStreamingMessages();
+
+    expect(swept).toBe(0);
+    const row = db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.id, msgId))
+      .get();
+    expect(row?.status).toBe("complete");
+    expect(row?.content).toBe("Finished response");
+  });
+});

package/src/lib/chat/__tests__/skill-conflict.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { detectSkillConflicts } from "../skill-conflict";
+
+describe("detectSkillConflicts", () => {
+  it("returns no conflicts for two unrelated skills", () => {
+    const a = { id: "a", name: "code-reviewer", content: "Always run ESLint before reviewing code." };
+    const b = { id: "b", name: "haiku-poet", content: "Use 5-7-5 syllable structure." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+
+  it("flags directive divergence on a shared topic", () => {
+    const a = { id: "a", name: "tdd", content: "Always write the test first. Never write production code without a failing test." };
+    const b = { id: "b", name: "spike", content: "Never write tests during a spike. Prefer exploratory code." };
+    const conflicts = detectSkillConflicts(a, b);
+    expect(conflicts.length).toBeGreaterThan(0);
+    expect(conflicts[0]).toMatchObject({
+      skillA: "tdd",
+      skillB: "spike",
+    });
+    expect(conflicts[0].excerptA).toMatch(/test/i);
+    expect(conflicts[0].excerptB).toMatch(/test/i);
+  });
+
+  it("returns no conflicts when both skills agree on a topic", () => {
+    const a = { id: "a", name: "tdd", content: "Always write tests first." };
+    const b = { id: "b", name: "qa-strict", content: "Always write tests first and add coverage gates." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+
+  it("ignores non-directive lines", () => {
+    const a = { id: "a", name: "x", content: "This skill is for documentation tasks." };
+    const b = { id: "b", name: "y", content: "Documentation is important context." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+});