airaknit 1.1.2-rc.9

package/src/server/extensions/agents/server.test.ts

@@ -0,0 +1,191 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { agentsExtension } from "./server"
+
+/** Helper: create a temp project dir, return its path */
+async function makeTempProject(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "agents-ext-test-"))
+}
+
+/** Helper: invoke a route handler by path */
+function findRoute(projectPath: string, method: string, path: string) {
+  const routes = agentsExtension.routes({ projectPath })
+  return routes.find((r) => r.method === method && r.path === path)
+}
+
+/** Helper: build a minimal GET request */
+function fakeRequest(path: string): Request {
+  return new Request(`http://localhost${path}`)
+}
+
+describe("agents extension", () => {
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = await makeTempProject()
+  })
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  // ── /claude-md ──────────────────────────────────────────
+
+  describe("GET /claude-md", () => {
+    test("parses CLAUDE.md into structured sections", async () => {
+      const claudeMd = [
+        "## Architecture",
+        "Event sourcing with JSONL logs.",
+        "",
+        "## Dev",
+        "```bash",
+        "bun run dev",
+        "```",
+      ].join("\n")
+
+      await writeFile(join(tmpDir, "CLAUDE.md"), claudeMd)
+
+      const route = findRoute(tmpDir, "GET", "/claude-md")
+      expect(route).toBeDefined()
+
+      const res = await route!.handler(fakeRequest("/claude-md"), {})
+      expect(res.status).toBe(200)
+      expect(res.headers.get("Content-Type")).toBe("application/json")
+
+      const body = await res.json()
+      expect(body.sections).toBeArrayOfSize(2)
+      expect(body.sections[0].heading).toBe("Architecture")
+      expect(body.sections[0].content).toBe("Event sourcing with JSONL logs.")
+      expect(body.sections[1].heading).toBe("Dev")
+      expect(body.sections[1].content).toContain("bun run dev")
+    })
+
+    test("returns empty sections when CLAUDE.md does not exist", async () => {
+      const route = findRoute(tmpDir, "GET", "/claude-md")
+      expect(route).toBeDefined()
+
+      const res = await route!.handler(fakeRequest("/claude-md"), {})
+      expect(res.status).toBe(200)
+
+      const body = await res.json()
+      expect(body.sections).toBeArrayOfSize(0)
+    })
+
+    test("handles content before the first heading", async () => {
+      const claudeMd = [
+        "# Tinkaria",
+        "",
+        "Top-level intro paragraph.",
+        "",
+        "## Setup",
+        "Run bun install.",
+      ].join("\n")
+
+      await writeFile(join(tmpDir, "CLAUDE.md"), claudeMd)
+
+      const route = findRoute(tmpDir, "GET", "/claude-md")
+      const res = await route!.handler(fakeRequest("/claude-md"), {})
+      const body = await res.json()
+
+      // preamble before first ## gets captured with empty heading
+      expect(body.sections.length).toBeGreaterThanOrEqual(2)
+      expect(body.sections[0].heading).toBe("")
+      expect(body.sections[0].content).toContain("Top-level intro paragraph.")
+      expect(body.sections[1].heading).toBe("Setup")
+    })
+  })
+
+  // ── /skills ─────────────────────────────────────────────
+
+  describe("GET /skills", () => {
+    test("lists .md files from .claude/commands/", async () => {
+      const cmdDir = join(tmpDir, ".claude", "commands")
+      await mkdir(cmdDir, { recursive: true })
+      await writeFile(join(cmdDir, "deploy.md"), "Deploy the app to prod")
+      await writeFile(join(cmdDir, "lint.md"), "Run linter and fix issues")
+
+      const route = findRoute(tmpDir, "GET", "/skills")
+      expect(route).toBeDefined()
+
+      const res = await route!.handler(fakeRequest("/skills"), {})
+      expect(res.status).toBe(200)
+
+      const body = await res.json()
+      expect(body.skills).toBeArrayOfSize(2)
+
+      const names = body.skills.map((s: { name: string }) => s.name).sort()
+      expect(names).toEqual(["deploy", "lint"])
+
+      const deploy = body.skills.find((s: { name: string }) => s.name === "deploy")
+      expect(deploy.filename).toBe("deploy.md")
+      expect(deploy.content).toBe("Deploy the app to prod")
+    })
+
+    test("returns empty array when .claude/commands/ does not exist", async () => {
+      const route = findRoute(tmpDir, "GET", "/skills")
+      const res = await route!.handler(fakeRequest("/skills"), {})
+      expect(res.status).toBe(200)
+
+      const body = await res.json()
+      expect(body.skills).toBeArrayOfSize(0)
+    })
+
+    test("ignores non-.md files in commands dir", async () => {
+      const cmdDir = join(tmpDir, ".claude", "commands")
+      await mkdir(cmdDir, { recursive: true })
+      await writeFile(join(cmdDir, "valid.md"), "A skill")
+      await writeFile(join(cmdDir, "notes.txt"), "Not a skill")
+      await writeFile(join(cmdDir, ".hidden"), "Also not a skill")
+
+      const route = findRoute(tmpDir, "GET", "/skills")
+      const res = await route!.handler(fakeRequest("/skills"), {})
+      const body = await res.json()
+
+      expect(body.skills).toBeArrayOfSize(1)
+      expect(body.skills[0].name).toBe("valid")
+    })
+  })
+
+  // ── /agents-md ──────────────────────────────────────────
+
+  describe("GET /agents-md", () => {
+    test("parses .claude/agents.md into sections", async () => {
+      const agentsMd = [
+        "## reviewer",
+        "You are a code reviewer. Be thorough.",
+        "",
+        "## deployer",
+        "Handle deployment pipelines.",
+      ].join("\n")
+
+      await mkdir(join(tmpDir, ".claude"), { recursive: true })
+      await writeFile(join(tmpDir, ".claude", "agents.md"), agentsMd)
+
+      const route = findRoute(tmpDir, "GET", "/agents-md")
+      expect(route).toBeDefined()
+
+      const res = await route!.handler(fakeRequest("/agents-md"), {})
+      expect(res.status).toBe(200)
+
+      const body = await res.json()
+      expect(body.found).toBe(true)
+      expect(body.sections).toBeArrayOfSize(2)
+      expect(body.sections[0].heading).toBe("reviewer")
+      expect(body.sections[0].content).toBe("You are a code reviewer. Be thorough.")
+      expect(body.sections[1].heading).toBe("deployer")
+      expect(body.sections[1].content).toBe("Handle deployment pipelines.")
+    })
+
+    test("returns found:false and empty sections when agents.md missing", async () => {
+      const route = findRoute(tmpDir, "GET", "/agents-md")
+      const res = await route!.handler(fakeRequest("/agents-md"), {})
+      expect(res.status).toBe(200)
+
+      const body = await res.json()
+      expect(body.found).toBe(false)
+      expect(body.sections).toBeArrayOfSize(0)
+    })
+  })
+})

package/src/server/extensions/agents/server.ts

@@ -0,0 +1,108 @@
+import { readdir } from "node:fs/promises"
+import { join, basename } from "node:path"
+import type { ServerExtension } from "../../../shared/extension-types"
+
+// ── Helpers ───────────────────────────────────────────────
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  })
+}
+
+function parseMarkdownSections(content: string): { heading: string; content: string }[] {
+  const sections: { heading: string; content: string }[] = []
+  const lines = content.split("\n")
+  let currentHeading = ""
+  let currentContent: string[] = []
+
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      if (currentHeading || currentContent.length > 0) {
+        sections.push({ heading: currentHeading, content: currentContent.join("\n").trim() })
+      }
+      currentHeading = line.slice(3).trim()
+      currentContent = []
+    } else {
+      currentContent.push(line)
+    }
+  }
+  if (currentHeading || currentContent.length > 0) {
+    sections.push({ heading: currentHeading, content: currentContent.join("\n").trim() })
+  }
+  return sections
+}
+
+// ── Route handlers ────────────────────────────────────────
+
+function handleClaudeMd(projectPath: string) {
+  return async (_req: Request, _params: Record<string, string>): Promise<Response> => {
+    const filePath = join(projectPath, "CLAUDE.md")
+    const file = Bun.file(filePath)
+
+    if (!(await file.exists())) {
+      return jsonResponse({ sections: [] })
+    }
+
+    const text = await file.text()
+    return jsonResponse({ sections: parseMarkdownSections(text) })
+  }
+}
+
+function handleSkills(projectPath: string) {
+  return async (_req: Request, _params: Record<string, string>): Promise<Response> => {
+    const cmdDir = join(projectPath, ".claude", "commands")
+
+    let entries: string[]
+    try {
+      entries = await readdir(cmdDir)
+    } catch (_e: unknown) {
+      return jsonResponse({ skills: [] })
+    }
+
+    const mdFiles = entries.filter((f) => f.endsWith(".md"))
+    const skills = await Promise.all(
+      mdFiles.map(async (filename) => {
+        const content = await Bun.file(join(cmdDir, filename)).text()
+        return {
+          name: basename(filename, ".md"),
+          filename,
+          content,
+        }
+      }),
+    )
+
+    return jsonResponse({ skills })
+  }
+}
+
+function handleAgentsMd(projectPath: string) {
+  return async (_req: Request, _params: Record<string, string>): Promise<Response> => {
+    const filePath = join(projectPath, ".claude", "agents.md")
+    const file = Bun.file(filePath)
+
+    if (!(await file.exists())) {
+      return jsonResponse({ found: false, sections: [] })
+    }
+
+    const text = await file.text()
+    return jsonResponse({ found: true, sections: parseMarkdownSections(text) })
+  }
+}
+
+// ── Extension export ──────────────────────────────────────
+
+export const agentsExtension: ServerExtension = {
+  id: "agents",
+  name: "Agents",
+  icon: "bot",
+  detect: ["CLAUDE.md", ".claude/"],
+  routes(ctx) {
+    return [
+      { method: "GET", path: "/claude-md", handler: handleClaudeMd(ctx.projectPath) },
+      { method: "GET", path: "/skills", handler: handleSkills(ctx.projectPath) },
+      { method: "GET", path: "/agents-md", handler: handleAgentsMd(ctx.projectPath) },
+    ]
+  },
+}

package/src/server/extensions/c3/server.test.ts

@@ -0,0 +1,284 @@
+import { describe, test, expect, afterEach, beforeAll } from "bun:test"
+import { mkdtemp, mkdir, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { buildC3EntityTree, c3Extension } from "./server"
+
+let tempDir: string
+const originalC3xMode = process.env.C3X_MODE
+
+async function makeTempProject(): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "c3-test-"))
+  await mkdir(path.join(dir, ".c3"), { recursive: true })
+  return dir
+}
+
+// Check if c3x is available on this machine
+let c3xAvailable = false
+beforeAll(async () => {
+  try {
+    const proc = Bun.spawn(["which", "c3x"], { stdout: "pipe", stderr: "pipe" })
+    await proc.exited
+    c3xAvailable = proc.exitCode === 0
+  } catch {
+    c3xAvailable = false
+  }
+})
+
+afterEach(async () => {
+  if (originalC3xMode === undefined) {
+    delete process.env.C3X_MODE
+  } else {
+    process.env.C3X_MODE = originalC3xMode
+  }
+  if (tempDir) {
+    await rm(tempDir, { recursive: true, force: true })
+  }
+})
+
+// ── Manifest shape ──────────────────────────────────────────────────
+
+describe("c3Extension manifest", () => {
+  test("has correct id, name, icon, detect", () => {
+    expect(c3Extension.id).toBe("c3")
+    expect(c3Extension.name).toBe("Architecture")
+    expect(c3Extension.icon).toBe("building-2")
+    expect(c3Extension.detect).toEqual([".c3/"])
+  })
+})
+
+// ── Route structure ─────────────────────────────────────────────────
+
+describe("c3Extension routes", () => {
+  test("returns three routes", () => {
+    const routes = c3Extension.routes({ projectPath: "/tmp/fake" })
+    expect(routes).toHaveLength(3)
+  })
+
+  test("list route is GET /list", () => {
+    const routes = c3Extension.routes({ projectPath: "/tmp/fake" })
+    const list = routes.find((r) => r.path === "/list")
+    expect(list).toBeDefined()
+    expect(list!.method).toBe("GET")
+    expect(typeof list!.handler).toBe("function")
+  })
+
+  test("read route is GET /read", () => {
+    const routes = c3Extension.routes({ projectPath: "/tmp/fake" })
+    const read = routes.find((r) => r.path === "/read")
+    expect(read).toBeDefined()
+    expect(read!.method).toBe("GET")
+  })
+
+  test("graph route is GET /graph", () => {
+    const routes = c3Extension.routes({ projectPath: "/tmp/fake" })
+    const graph = routes.find((r) => r.path === "/graph")
+    expect(graph).toBeDefined()
+    expect(graph!.method).toBe("GET")
+  })
+})
+
+// ── Tree structure ─────────────────────────────────────────────────
+
+describe("buildC3EntityTree", () => {
+  test("nests parented entities while keeping unparented entities at the root", () => {
+    expect(
+      buildC3EntityTree([
+        { id: "c3-0", type: "system", title: "tinkaria" },
+        { id: "c3-1", type: "container", title: "client", parent: "c3-0" },
+        { id: "c3-120", type: "component", title: "extensions", parent: "c3-1" },
+        { id: "ref-project-context", type: "ref", title: "project-context" },
+      ]),
+    ).toEqual([
+      {
+        id: "c3-0",
+        type: "system",
+        title: "tinkaria",
+        children: [
+          {
+            id: "c3-1",
+            type: "container",
+            title: "client",
+            parent: "c3-0",
+            children: [
+              {
+                id: "c3-120",
+                type: "component",
+                title: "extensions",
+                parent: "c3-1",
+              },
+            ],
+          },
+        ],
+      },
+      { id: "ref-project-context", type: "ref", title: "project-context" },
+    ])
+  })
+})
+
+// ── Parameter validation ────────────────────────────────────────────
+
+describe("read handler validation", () => {
+  test("returns 400 when id query param is missing", async () => {
+    tempDir = await makeTempProject()
+    const routes = c3Extension.routes({ projectPath: tempDir })
+    const read = routes.find((r) => r.path === "/read")!
+
+    const req = new Request("http://localhost/api/ext/c3/read?projectPath=" + encodeURIComponent(tempDir))
+    const res = await read.handler(req, {})
+
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body.error).toMatch(/id/i)
+  })
+})
+
+describe("graph handler validation", () => {
+  test("returns 400 when id query param is missing", async () => {
+    tempDir = await makeTempProject()
+    const routes = c3Extension.routes({ projectPath: tempDir })
+    const graph = routes.find((r) => r.path === "/graph")!
+
+    const req = new Request("http://localhost/api/ext/c3/graph?projectPath=" + encodeURIComponent(tempDir))
+    const res = await graph.handler(req, {})
+
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body.error).toMatch(/id/i)
+  })
+})
+
+// ── c3x integration (only when c3x is available) ───────────────────
+
+describe("c3x integration", () => {
+  test("list handler returns JSON when c3x succeeds", async () => {
+    if (!c3xAvailable) {
+      console.log("SKIP: c3x not available")
+      return
+    }
+
+    // Use the actual project which has .c3/
+    const projectPath = path.resolve(import.meta.dir, "../../../..")
+    const routes = c3Extension.routes({ projectPath })
+    const list = routes.find((r) => r.path === "/list")!
+
+    const req = new Request("http://localhost/api/ext/c3/list?projectPath=" + encodeURIComponent(projectPath))
+    const res = await list.handler(req, {})
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(Array.isArray(body.data)).toBe(true)
+    expect(body.data.length).toBeGreaterThan(0)
+    expect(body.data[0]).toMatchObject({
+      id: "c3-0",
+      type: "system",
+      children: expect.arrayContaining([
+        expect.objectContaining({
+          id: expect.any(String),
+          type: "container",
+          children: expect.arrayContaining([
+            expect.objectContaining({
+              id: expect.any(String),
+              type: "component",
+            }),
+          ]),
+        }),
+      ]),
+    })
+  })
+
+  test("list handler ignores inherited agent output mode", async () => {
+    if (!c3xAvailable) {
+      console.log("SKIP: c3x not available")
+      return
+    }
+
+    process.env.C3X_MODE = "agent"
+    const projectPath = path.resolve(import.meta.dir, "../../../..")
+    const routes = c3Extension.routes({ projectPath })
+    const list = routes.find((r) => r.path === "/list")!
+
+    const req = new Request("http://localhost/api/ext/c3/list?projectPath=" + encodeURIComponent(projectPath))
+    const res = await list.handler(req, {})
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(Array.isArray(body.data)).toBe(true)
+    expect(body.data[0]).toMatchObject({
+      id: "c3-0",
+      type: "system",
+    })
+  })
+
+  test("read handler returns content for a valid id", async () => {
+    if (!c3xAvailable) {
+      console.log("SKIP: c3x not available")
+      return
+    }
+
+    const projectPath = path.resolve(import.meta.dir, "../../../..")
+    const routes = c3Extension.routes({ projectPath })
+    const read = routes.find((r) => r.path === "/read")!
+
+    // Use a known component id from the project
+    const req = new Request(
+      "http://localhost/api/ext/c3/read?projectPath=" +
+        encodeURIComponent(projectPath) +
+        "&id=c3-204",
+    )
+    const res = await read.handler(req, {})
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.data).toMatchObject({
+      id: "c3-204",
+      type: "component",
+      body: expect.stringContaining("##"),
+    })
+    expect(body.data.body_truncated).toBeUndefined()
+  })
+
+  test("graph handler returns mermaid content", async () => {
+    if (!c3xAvailable) {
+      console.log("SKIP: c3x not available")
+      return
+    }
+
+    const projectPath = path.resolve(import.meta.dir, "../../../..")
+    const routes = c3Extension.routes({ projectPath })
+    const graph = routes.find((r) => r.path === "/graph")!
+
+    const req = new Request(
+      "http://localhost/api/ext/c3/graph?projectPath=" +
+        encodeURIComponent(projectPath) +
+        "&id=c3-204",
+    )
+    const res = await graph.handler(req, {})
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.data).toBeDefined()
+    // Mermaid output should contain graph/flowchart keywords
+    expect(typeof body.data).toBe("string")
+  })
+})
+
+// ── Error handling ──────────────────────────────────────────────────
+
+describe("c3x error handling", () => {
+  test("returns 503 when c3x fails on a project without .c3/", async () => {
+    // Create an empty temp dir with .c3/ but no valid content
+    tempDir = await mkdtemp(path.join(tmpdir(), "c3-empty-"))
+    await mkdir(path.join(tempDir, ".c3"), { recursive: true })
+
+    const routes = c3Extension.routes({ projectPath: tempDir })
+    const list = routes.find((r) => r.path === "/list")!
+
+    const req = new Request("http://localhost/api/ext/c3/list?projectPath=" + encodeURIComponent(tempDir))
+    const res = await list.handler(req, {})
+
+    // c3x should fail on empty .c3/ — either 503 or a valid response
+    // The key assertion is it doesn't crash (no unhandled exception)
+    expect([200, 503]).toContain(res.status)
+  })
+})