@gswangg/duncan-cc 0.1.0

package/tests/self-exclusion.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Tests for self-exclusion — finding and excluding the calling session
+ * by scanning for toolUseId in session file tails.
+ */
+
+import { join } from "node:path";
+import { mkdirSync, writeFileSync, rmSync, statSync, existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import {
+  findCallingSession,
+  resolveSessionFilesExcludingSelf,
+  listSessionFiles,
+  type SessionFileInfo,
+} from "../src/discovery.js";
+
+const TESTDATA = join(import.meta.dirname, "..", "testdata", "projects");
+const TMPDIR = join(import.meta.dirname, "..", "testdata", ".tmp-self-exclusion");
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/** Create a minimal JSONL session file with a tool_use block near the end. */
+function createSessionFile(dir: string, sessionId: string, toolUseId: string, paddingKB = 0): string {
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${sessionId}.jsonl`);
+
+  const lines: string[] = [];
+
+  // Optional padding to push the tool_use away from file start
+  if (paddingKB > 0) {
+    const padding = "x".repeat(1024);
+    for (let i = 0; i < paddingKB; i++) {
+      lines.push(JSON.stringify({
+        type: "user", uuid: randomUUID(), parentUuid: null,
+        session_id: sessionId, timestamp: new Date().toISOString(),
+        message: { role: "user", content: [{ type: "text", text: padding }] },
+      }));
+    }
+  }
+
+  // User message
+  lines.push(JSON.stringify({
+    type: "user", uuid: randomUUID(), parentUuid: null,
+    session_id: sessionId, timestamp: new Date().toISOString(),
+    message: { role: "user", content: [{ type: "text", text: "query something" }] },
+  }));
+
+  // Assistant message with tool_use
+  lines.push(JSON.stringify({
+    type: "assistant", uuid: randomUUID(), parentUuid: null,
+    session_id: sessionId, timestamp: new Date().toISOString(),
+    message: {
+      role: "assistant",
+      content: [{
+        type: "tool_use", id: toolUseId, name: "duncan_query",
+        input: { question: "test", mode: "project" },
+      }],
+    },
+  }));
+
+  writeFileSync(path, lines.join("\n") + "\n");
+  return path;
+}
+
+function fileInfo(path: string, sessionId: string, projectDir: string): SessionFileInfo {
+  const stat = statSync(path);
+  return { path, sessionId, mtime: stat.mtime, size: stat.size, projectDir };
+}
+
+// ============================================================================
+// Setup / Teardown
+// ============================================================================
+
+rmSync(TMPDIR, { recursive: true, force: true });
+
+// ============================================================================
+// Tests: findCallingSession
+// ============================================================================
+
+console.log("\n--- findCallingSession: basic ---");
+{
+  const dir = join(TMPDIR, "basic");
+  const toolUseId = "toolu_01TestBasicId0000000000";
+  const callingPath = createSessionFile(dir, "calling-session", toolUseId);
+  const otherPath = createSessionFile(dir, "other-session", "toolu_01OtherToolId0000000000");
+
+  const candidates = [
+    fileInfo(callingPath, "calling-session", dir),
+    fileInfo(otherPath, "other-session", dir),
+  ];
+
+  const result = findCallingSession(toolUseId, candidates);
+  assert(result === "calling-session", `found calling session: ${result}`);
+  ok("identifies correct session by toolUseId");
+}
+
+console.log("\n--- findCallingSession: not found ---");
+{
+  const dir = join(TMPDIR, "notfound");
+  const otherPath = createSessionFile(dir, "other-session", "toolu_01OtherToolId1111111111");
+
+  const candidates = [fileInfo(otherPath, "other-session", dir)];
+
+  const result = findCallingSession("toolu_01NonexistentId999999999", candidates);
+  assert(result === null, `returns null when not found: ${result}`);
+  ok("returns null for missing toolUseId");
+}
+
+console.log("\n--- findCallingSession: empty toolUseId ---");
+{
+  const result = findCallingSession("", []);
+  assert(result === null, `returns null for empty ID: ${result}`);
+  ok("returns null for empty toolUseId");
+}
+
+console.log("\n--- findCallingSession: large file (tail scan) ---");
+{
+  const dir = join(TMPDIR, "largefile");
+  const toolUseId = "toolu_01LargeFileTest000000000";
+  // Create a ~40KB file — tool_use at the end, within 32KB tail window
+  const callingPath = createSessionFile(dir, "large-session", toolUseId, 40);
+
+  const candidates = [fileInfo(callingPath, "large-session", dir)];
+
+  const result = findCallingSession(toolUseId, candidates);
+  assert(result === "large-session", `found in large file: ${result}`);
+  ok("finds toolUseId in tail of large file");
+}
+
+console.log("\n--- findCallingSession: tool_use beyond tail scan window ---");
+{
+  const dir = join(TMPDIR, "beyond-tail");
+  // The tool_use is at ~40KB but we only scan last 32KB
+  // However, the tool_use entry itself is near the END (after padding)
+  // So this should still work — the padding is before the tool_use
+  const toolUseId = "toolu_01BeyondTailTest00000000";
+  const callingPath = createSessionFile(dir, "far-session", toolUseId, 50);
+
+  const candidates = [fileInfo(callingPath, "far-session", dir)];
+
+  const result = findCallingSession(toolUseId, candidates);
+  // The tool_use is the last entry, so it's within the 32KB tail window
+  // even though the file is 50KB+ total
+  assert(result === "far-session", `found despite large file: ${result}`);
+  ok("tool_use at end of large file is within tail scan window");
+}
+
+console.log("\n--- findCallingSession: multiple sessions, correct one identified ---");
+{
+  const dir = join(TMPDIR, "multi");
+  const targetId = "toolu_01MultiTargetId000000000";
+
+  const paths = [];
+  for (let i = 0; i < 5; i++) {
+    const sid = `session-${i}`;
+    const tid = i === 3 ? targetId : `toolu_01Other${i}Pad00000000000`;
+    paths.push({ path: createSessionFile(dir, sid, tid), sid });
+  }
+
+  const candidates = paths.map((p) => fileInfo(p.path, p.sid, dir));
+
+  const result = findCallingSession(targetId, candidates);
+  assert(result === "session-3", `found session-3 among 5: ${result}`);
+  ok("finds correct session among multiple candidates");
+}
+
+// ============================================================================
+// Tests: findCallingSession on real test data
+// ============================================================================
+
+if (existsSync(TESTDATA)) {
+  console.log("\n--- findCallingSession: real session data ---");
+  {
+    const codexDir = join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex");
+    const sessions = listSessionFiles(codexDir);
+    assert(sessions.length > 0, `have codex sessions: ${sessions.length}`);
+
+    // Pick a real tool_use ID from the test data
+    const targetId = "toolu_01ApH1X3AiGqZw7C9QjUXeGp";
+    const sourceDir = join(TESTDATA, "-Users-wednesdayniemeyer--claude-skills-inspect-claude-source");
+    const sourceSessions = listSessionFiles(sourceDir);
+
+    // Search all test sessions — should find it in the inspect-claude-source project
+    const allCandidates = [...sessions, ...sourceSessions];
+    const result = findCallingSession(targetId, allCandidates);
+    assert(result === "28e532ae-cb50-4f6f-9f08-914cbf6563b7", `found real session: ${result}`);
+    ok("finds toolUseId in real CC session data");
+  }
+} else {
+  console.log("\n--- findCallingSession: real session data (skipped, no corpus) ---");
+}
+
+// ============================================================================
+// Tests: resolveSessionFilesExcludingSelf
+// ============================================================================
+
+console.log("\n--- resolveSessionFilesExcludingSelf: excludes calling session ---");
+{
+  const dir = join(TMPDIR, "resolve-exclude");
+  const toolUseId = "toolu_01ResolveExclude000000000";
+
+  createSessionFile(dir, "active-session", toolUseId);
+  createSessionFile(dir, "dormant-session-1", "toolu_01Dormant1Pad0000000000");
+  createSessionFile(dir, "dormant-session-2", "toolu_01Dormant2Pad0000000000");
+
+  const result = resolveSessionFilesExcludingSelf({
+    mode: "project",
+    projectDir: dir,
+    toolUseId,
+  });
+
+  assert(result.excludedSessionId === "active-session", `excluded: ${result.excludedSessionId}`);
+  assert(result.sessions.length === 2, `2 sessions remain: ${result.sessions.length}`);
+  assert(result.totalCount === 2, `totalCount adjusted: ${result.totalCount}`);
+  assert(
+    result.sessions.every((s) => s.sessionId !== "active-session"),
+    "active session not in results",
+  );
+  ok("excludes calling session, returns others");
+}
+
+console.log("\n--- resolveSessionFilesExcludingSelf: no toolUseId → no exclusion ---");
+{
+  const dir = join(TMPDIR, "resolve-no-id");
+  createSessionFile(dir, "session-a", "toolu_01SessionA000000000000");
+  createSessionFile(dir, "session-b", "toolu_01SessionB000000000000");
+
+  const result = resolveSessionFilesExcludingSelf({
+    mode: "project",
+    projectDir: dir,
+  });
+
+  assert(result.excludedSessionId === null, `no exclusion: ${result.excludedSessionId}`);
+  assert(result.sessions.length === 2, `all sessions returned: ${result.sessions.length}`);
+  ok("no exclusion when toolUseId not provided");
+}
+
+console.log("\n--- resolveSessionFilesExcludingSelf: toolUseId not found → no exclusion ---");
+{
+  const dir = join(TMPDIR, "resolve-miss");
+  createSessionFile(dir, "session-x", "toolu_01SessionX000000000000");
+
+  const result = resolveSessionFilesExcludingSelf({
+    mode: "project",
+    projectDir: dir,
+    toolUseId: "toolu_01CompletelyUnknown000000",
+  });
+
+  assert(result.excludedSessionId === null, `no exclusion: ${result.excludedSessionId}`);
+  assert(result.sessions.length === 1, `all sessions returned: ${result.sessions.length}`);
+  ok("no exclusion when toolUseId not found in any file");
+}
+
+// ============================================================================
+// Cleanup & Summary
+// ============================================================================
+
+rmSync(TMPDIR, { recursive: true, force: true });
+
+console.log(`\n✅ Self-exclusion tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/system-prompt.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Tests for system prompt + context reconstruction.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { parseSession } from "../src/parser.js";
+import { buildRawChain } from "../src/tree.js";
+import { normalizeMessages } from "../src/normalize.js";
+import { buildSystemPrompt, buildSystemPromptString, injectUserContext } from "../src/system-prompt.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+function findSessionFiles(): string[] {
+  const files: string[] = [];
+  function walk(dir: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "subagents") walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl") && !dir.includes("subagents")) files.push(full);
+    }
+  }
+  walk(TESTDATA);
+  return files;
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+
+console.log("\n--- System Prompt: base construction ---");
+{
+  const prompt = buildSystemPromptString({
+    cwd: "/workspace",
+    modelId: "claude-sonnet-4-20250514",
+    toolNames: new Set(["Read", "Edit", "Write", "Bash", "Grep", "Glob"]),
+  });
+
+  assert(prompt.includes("interactive agent"), "includes identity intro");
+  assert(prompt.includes("software engineering"), "includes SE context");
+  assert(prompt.includes("/workspace"), "includes cwd");
+  assert(prompt.includes("claude-sonnet"), "includes model name");
+  assert(prompt.includes("Platform:"), "includes platform");
+  assert(prompt.includes("# System"), "includes system section");
+  assert(prompt.includes("# Doing tasks"), "includes doing tasks section");
+  assert(prompt.includes("# Executing actions with care"), "includes careful actions");
+  assert(prompt.includes("# Using your tools"), "includes tool usage");
+  assert(prompt.includes("# Tone and style"), "includes tone section");
+  assert(prompt.includes("# Output efficiency"), "includes output efficiency");
+  assert(prompt.includes("Read instead of cat"), "includes tool-specific instructions");
+  ok(`system prompt: ${prompt.length} chars`);
+}
+
+console.log("\n--- System Prompt: sections ---");
+{
+  const sections = buildSystemPrompt({
+    cwd: "/workspace",
+    modelId: "claude-opus-4-6",
+  });
+
+  assert(sections.length >= 7, `has ${sections.length} sections (need >= 7)`);
+  assert(sections[0].includes("interactive agent"), "section 0: identity");
+  assert(sections[1].includes("# System"), "section 1: system rules");
+  assert(sections.some(s => s.includes("<env>")), "has environment section");
+  ok("sections structured correctly");
+}
+
+console.log("\n--- userContext injection ---");
+{
+  const files = findSessionFiles();
+  const file = files.find((f) => {
+    const content = readFileSync(f, "utf-8");
+    return content.length > 10000;
+  }) ?? files[0];
+
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const name = basename(file, ".jsonl").slice(0, 12);
+
+  if (chain.length > 0) {
+    const normalized = normalizeMessages(chain);
+    const withContext = injectUserContext(normalized, "/workspace");
+
+    // If first message was user, context is merged in (same count)
+    // If first message was assistant, context is prepended (+1)
+    const firstWasUser = normalized.length > 0 && normalized[0].type === "user";
+    const expectedLen = firstWasUser ? normalized.length : normalized.length + 1;
+    assert(
+      withContext.length === expectedLen,
+      `${name}: correct length after context injection (${withContext.length} vs ${expectedLen})`,
+    );
+
+    // First message should contain the system-reminder
+    const first = withContext[0];
+    assert(first.type === "user", "first message is user");
+
+    const content = typeof first.message.content === "string"
+      ? first.message.content
+      : JSON.stringify(first.message.content);
+    assert(content.includes("system-reminder"), "has system-reminder");
+    assert(content.includes("currentDate"), "has currentDate");
+
+    ok(`${name}: context injected, ${content.length} chars`);
+  }
+}
+
+console.log("\n--- userContext: CLAUDE.md loading from cwd ---");
+{
+  // Test with a directory that has CLAUDE.md (if any exist in testdata)
+  // Since our testdata is CC sessions, not project files, just verify the function doesn't crash
+  const withContext = injectUserContext([], "/nonexistent/path");
+  assert(withContext.length === 1, "injects context even for empty messages");
+  assert(
+    typeof withContext[0].message.content === "string" &&
+    withContext[0].message.content.includes("currentDate"),
+    "includes currentDate even without CLAUDE.md",
+  );
+  ok("handles missing CLAUDE.md gracefully");
+}
+
+console.log("\n--- System Prompt: tool name extraction ---");
+{
+  const file = join(
+    TESTDATA,
+    "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex",
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl"
+  );
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+
+  const { extractToolNames } = await import("../src/system-prompt.js");
+  const toolNames = extractToolNames(chain);
+  assert(toolNames.size > 0, `found ${toolNames.size} tool names`);
+  // CC sessions use standard tools
+  const hasStandard = toolNames.has("Read") || toolNames.has("Bash") || toolNames.has("Grep");
+  assert(hasStandard, `has standard tools: ${[...toolNames].join(", ")}`);
+  ok(`extracted ${toolNames.size} tools: ${[...toolNames].slice(0, 5).join(", ")}...`);
+
+  // System prompt should include tool-specific instructions when tools are provided
+  const prompt = buildSystemPromptString({
+    cwd: "/workspace",
+    toolNames,
+  });
+  if (toolNames.has("Read")) {
+    assert(prompt.includes("Read instead of cat"), "prompt has Read-specific instructions");
+  }
+  if (toolNames.has("Bash")) {
+    assert(prompt.includes("Bash exclusively for system commands"), "prompt has Bash-specific instructions");
+  }
+  ok("tool-specific instructions present in system prompt");
+}
+
+console.log("\n--- System Prompt: memory from project dir ---");
+{
+  // The ideas project has memory/MEMORY.md
+  const projectDir = join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-ideas");
+  const prompt = buildSystemPromptString({
+    cwd: "/workspace",
+    projectDir,
+  });
+  assert(prompt.includes("Memory"), "includes memory section header");
+  assert(prompt.includes("Gears Project Memory") || prompt.includes("MEMORY"), "includes memory content");
+  ok("memory loaded from project dir");
+
+  // No memory project dir
+  const promptNoMem = buildSystemPromptString({
+    cwd: "/workspace",
+    projectDir: join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex"),
+  });
+  assert(!promptNoMem.includes("# Memory"), "no memory section when none exists");
+  ok("no memory section for projects without MEMORY.md");
+}
+
+console.log("\n--- System Prompt: language ---");
+{
+  const prompt = buildSystemPromptString({
+    cwd: "/workspace",
+    language: "Japanese",
+  });
+  assert(prompt.includes("# Language"), "has language section");
+  assert(prompt.includes("Japanese"), "includes language name");
+  ok("language section present");
+
+  const promptNoLang = buildSystemPromptString({ cwd: "/workspace" });
+  assert(!promptNoLang.includes("# Language"), "no language section by default");
+  ok("no language section when not specified");
+}
+
+console.log("\n--- System Prompt: model extraction from session ---");
+{
+  // Extract model from a real session's assistant messages
+  const file = join(
+    TESTDATA,
+    "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex",
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl"
+  );
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+
+  // Find model from assistant messages
+  const assistant = chain.find((m) => m.type === "assistant" && m.message.model);
+  assert(assistant !== undefined, "found assistant with model");
+  if (assistant) {
+    const model = assistant.message.model!;
+    ok(`extracted model: ${model}`);
+
+    // Build system prompt with this model
+    const prompt = buildSystemPromptString({
+      cwd: "/Users/wednesdayniemeyer/Documents/gniemeyer/Projects/codex",
+      modelId: model,
+      modelName: model,
+    });
+    assert(prompt.includes(model), "system prompt includes session model");
+    ok("system prompt uses session's model");
+  }
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}