airaknit 1.1.2-rc.9

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

@@ -0,0 +1,212 @@
+import type { ServerExtension, ExtensionRoute } from "../../../shared/extension-types"
+import { homedir } from "node:os"
+import path from "node:path"
+
+const LOG_PREFIX = "[c3-ext]"
+
+interface C3ListEntity {
+  id: string
+  type: string
+  title?: string
+  name?: string
+  parent?: string
+  status?: string
+  children?: C3ListEntity[]
+  [key: string]: unknown
+}
+
+interface C3ListJsonOutput {
+  entities?: C3ListEntity[]
+  items?: C3ListEntity[]
+  [key: string]: unknown
+}
+
+export function buildC3EntityTree(entities: C3ListEntity[]): C3ListEntity[] {
+  const byId = new Map<string, C3ListEntity>()
+  const roots: C3ListEntity[] = []
+
+  for (const entity of entities) {
+    const { children: _children, ...rest } = entity
+    byId.set(entity.id, { ...rest })
+  }
+
+  for (const entity of entities) {
+    const node = byId.get(entity.id)
+    if (!node) continue
+
+    const parentId = typeof entity.parent === "string" ? entity.parent : null
+    const parent = parentId && parentId !== entity.id ? byId.get(parentId) : undefined
+
+    if (parent) {
+      parent.children = parent.children ?? []
+      parent.children.push(node)
+    } else {
+      roots.push(node)
+    }
+  }
+
+  return roots
+}
+
+function normalizeListData(parsed: C3ListJsonOutput): C3ListEntity[] | C3ListJsonOutput {
+  if (Array.isArray(parsed.entities)) return buildC3EntityTree(parsed.entities)
+  if (Array.isArray(parsed.items)) return buildC3EntityTree(parsed.items)
+  return parsed
+}
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  })
+}
+
+function errorResponse(error: string, code: number): Response {
+  return jsonResponse({ error, code }, code)
+}
+
+/** Resolve c3x path: PATH first, then known install location */
+async function resolveC3xPath(): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["which", "c3x"], { stdout: "pipe", stderr: "pipe" })
+    const out = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+    if (exitCode === 0 && out.trim()) return out.trim()
+  } catch (_e: unknown) {
+    // fall through
+  }
+
+  const fallbacks = [
+    path.join(homedir(), ".agents/skills/c3/bin/c3x.sh"),
+    path.join(
+      homedir(),
+      ".claude/plugins/marketplaces/c3-skill-marketplace/skills/c3/bin/c3x.sh",
+    ),
+  ]
+  for (const fallback of fallbacks) {
+    const file = Bun.file(fallback)
+    if (await file.exists()) return fallback
+  }
+
+  return null
+}
+
+function c3xEnv(): Record<string, string> {
+  const env: Record<string, string> = {}
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key === "C3X_MODE" || value === undefined) continue
+    env[key] = value
+  }
+  return env
+}
+
+async function runC3x(
+  args: string[],
+  projectPath: string,
+): Promise<{ stdout: string; exitCode: number }> {
+  const c3xPath = await resolveC3xPath()
+  if (!c3xPath) throw new Error("c3x not found")
+
+  // If c3xPath is a shell script, run via bash; if binary, run directly
+  const cmd = c3xPath.endsWith(".sh")
+    ? ["bash", c3xPath, ...args]
+    : [c3xPath, ...args]
+
+  const proc = Bun.spawn(cmd, {
+    cwd: projectPath,
+    env: c3xEnv(),
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  const stdout = await new Response(proc.stdout).text()
+  const exitCode = await proc.exited
+  return { stdout, exitCode }
+}
+
+function handleList(projectPath: string): ExtensionRoute["handler"] {
+  return async (_req, _params) => {
+    try {
+      const { stdout, exitCode } = await runC3x(["list", "--compact", "--json"], projectPath)
+      if (exitCode !== 0) {
+        console.warn(LOG_PREFIX, "c3x list exited with code", exitCode)
+        return errorResponse("c3x execution failed", 503)
+      }
+      try {
+        const parsed = JSON.parse(stdout) as C3ListJsonOutput
+        return jsonResponse({ data: normalizeListData(parsed) })
+      } catch (_e: unknown) {
+        return jsonResponse({ data: stdout.trim() })
+      }
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error)
+      console.warn(LOG_PREFIX, "list failed:", msg)
+      return errorResponse("c3x execution failed", 503)
+    }
+  }
+}
+
+function handleRead(projectPath: string): ExtensionRoute["handler"] {
+  return async (req, _params) => {
+    const url = new URL(req.url)
+    const id = url.searchParams.get("id")
+    if (!id) {
+      return errorResponse("Missing required 'id' query parameter", 400)
+    }
+
+    try {
+      const { stdout, exitCode } = await runC3x(["read", id, "--full", "--json"], projectPath)
+      if (exitCode !== 0) {
+        console.warn(LOG_PREFIX, "c3x read exited with code", exitCode)
+        return errorResponse("c3x execution failed", 503)
+      }
+      try {
+        const parsed = JSON.parse(stdout) as unknown
+        return jsonResponse({ data: parsed })
+      } catch (_error: unknown) {
+        return jsonResponse({ data: stdout.trim() })
+      }
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error)
+      console.warn(LOG_PREFIX, "read failed:", msg)
+      return errorResponse("c3x execution failed", 503)
+    }
+  }
+}
+
+function handleGraph(projectPath: string): ExtensionRoute["handler"] {
+  return async (req, _params) => {
+    const url = new URL(req.url)
+    const id = url.searchParams.get("id")
+    if (!id) {
+      return errorResponse("Missing required 'id' query parameter", 400)
+    }
+
+    try {
+      const { stdout, exitCode } = await runC3x(["graph", id, "--format", "mermaid"], projectPath)
+      if (exitCode !== 0) {
+        console.warn(LOG_PREFIX, "c3x graph exited with code", exitCode)
+        return errorResponse("c3x execution failed", 503)
+      }
+      return jsonResponse({ data: stdout.trim() })
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error)
+      console.warn(LOG_PREFIX, "graph failed:", msg)
+      return errorResponse("c3x execution failed", 503)
+    }
+  }
+}
+
+export const c3Extension: ServerExtension = {
+  id: "c3",
+  name: "Architecture",
+  icon: "building-2",
+  detect: [".c3/"],
+  routes(ctx) {
+    return [
+      { method: "GET", path: "/list", handler: handleList(ctx.projectPath) },
+      { method: "GET", path: "/read", handler: handleRead(ctx.projectPath) },
+      { method: "GET", path: "/graph", handler: handleGraph(ctx.projectPath) },
+    ]
+  },
+}

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

@@ -0,0 +1,200 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { codeExtension } from "./server"
+
+let tempDirs: string[] = []
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "code-ext-test-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+function getManifestHandler(projectPath: string) {
+  const routes = codeExtension.routes({ projectPath })
+  const route = routes.find((r) => r.path === "/manifest" && r.method === "GET")
+  if (!route) throw new Error("No /manifest route found")
+  return route.handler
+}
+
+async function callManifest(projectPath: string): Promise<{ status: number; body: unknown }> {
+  const handler = getManifestHandler(projectPath)
+  const req = new Request(`http://localhost/api/ext/code/manifest?projectPath=${encodeURIComponent(projectPath)}`)
+  const res = await handler(req, {})
+  const body = await res.json()
+  return { status: res.status, body }
+}
+
+afterEach(async () => {
+  for (const dir of tempDirs) {
+    await rm(dir, { recursive: true, force: true }).catch(() => {})
+  }
+  tempDirs = []
+})
+
+describe("code extension", () => {
+  test("has correct manifest metadata", () => {
+    expect(codeExtension.id).toBe("code")
+    expect(codeExtension.name).toBe("Code")
+    expect(codeExtension.detect).toContain("package.json")
+    expect(codeExtension.detect).toContain("Cargo.toml")
+    expect(codeExtension.detect).toContain("go.mod")
+    expect(codeExtension.detect).toContain("pyproject.toml")
+  })
+
+  test("exposes /manifest GET route", () => {
+    const routes = codeExtension.routes({ projectPath: "/tmp/fake" })
+    const manifest = routes.find((r) => r.path === "/manifest")
+    expect(manifest).toBeDefined()
+    expect(manifest!.method).toBe("GET")
+  })
+})
+
+describe("/manifest with package.json", () => {
+  test("parses valid package.json", async () => {
+    const dir = await makeTempDir()
+    await writeFile(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test",
+        version: "1.0.0",
+        scripts: { dev: "vite" },
+        dependencies: { react: "^19" },
+        devDependencies: { typescript: "^5" },
+      }),
+    )
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: Array<Record<string, unknown>> }
+    expect(result.manifests).toHaveLength(1)
+
+    const m = result.manifests[0]
+    expect(m.language).toBe("javascript")
+    expect(m.name).toBe("test")
+    expect(m.version).toBe("1.0.0")
+    expect(m.scripts).toEqual({ dev: "vite" })
+    expect(m.dependencies).toEqual({ react: "^19" })
+    expect(m.devDependencies).toEqual({ typescript: "^5" })
+  })
+})
+
+describe("/manifest with no manifest files", () => {
+  test("returns empty manifests array", async () => {
+    const dir = await makeTempDir()
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: unknown[] }
+    expect(result.manifests).toEqual([])
+  })
+})
+
+describe("/manifest with malformed JSON", () => {
+  test("handles malformed package.json gracefully", async () => {
+    const dir = await makeTempDir()
+    await writeFile(join(dir, "package.json"), "{ not valid json !!!")
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: Array<Record<string, unknown>> }
+    expect(result.manifests).toHaveLength(1)
+    expect(result.manifests[0].error).toBeDefined()
+    expect(result.manifests[0].language).toBe("javascript")
+  })
+})
+
+describe("/manifest with Cargo.toml", () => {
+  test("parses valid Cargo.toml", async () => {
+    const dir = await makeTempDir()
+    await writeFile(
+      join(dir, "Cargo.toml"),
+      `[package]
+name = "my-crate"
+version = "0.3.1"
+edition = "2021"
+
+[dependencies]
+serde = "1.0"
+tokio = "1.28"
+`,
+    )
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: Array<Record<string, unknown>> }
+    expect(result.manifests).toHaveLength(1)
+
+    const m = result.manifests[0]
+    expect(m.language).toBe("rust")
+    expect(m.name).toBe("my-crate")
+    expect(m.version).toBe("0.3.1")
+    expect(m.dependencies).toEqual({ serde: "1.0", tokio: "1.28" })
+  })
+})
+
+describe("/manifest with go.mod", () => {
+  test("parses valid go.mod", async () => {
+    const dir = await makeTempDir()
+    await writeFile(
+      join(dir, "go.mod"),
+      `module github.com/user/myapp
+
+go 1.21
+
+require (
+\tgolang.org/x/text v0.14.0
+\tgithub.com/gin-gonic/gin v1.9.1
+)
+`,
+    )
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: Array<Record<string, unknown>> }
+    expect(result.manifests).toHaveLength(1)
+
+    const m = result.manifests[0]
+    expect(m.language).toBe("go")
+    expect(m.name).toBe("github.com/user/myapp")
+    expect(m.version).toBe("1.21")
+    expect(m.dependencies).toEqual({
+      "golang.org/x/text": "v0.14.0",
+      "github.com/gin-gonic/gin": "v1.9.1",
+    })
+  })
+})
+
+describe("/manifest with multiple manifests", () => {
+  test("returns all detected manifests", async () => {
+    const dir = await makeTempDir()
+    await writeFile(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "frontend", version: "2.0.0" }),
+    )
+    await writeFile(
+      join(dir, "go.mod"),
+      `module github.com/user/backend
+
+go 1.22
+`,
+    )
+
+    const { status, body } = await callManifest(dir)
+    expect(status).toBe(200)
+
+    const result = body as { manifests: Array<Record<string, unknown>> }
+    expect(result.manifests).toHaveLength(2)
+
+    const languages = result.manifests.map((m) => m.language)
+    expect(languages).toContain("javascript")
+    expect(languages).toContain("go")
+  })
+})

package/src/server/extensions/code/server.ts

@@ -0,0 +1,150 @@
+import type { ServerExtension } from "../../../shared/extension-types"
+
+interface ManifestResult {
+  language: string
+  name: string
+  version: string
+  scripts: Record<string, string>
+  dependencies: Record<string, string>
+  devDependencies: Record<string, string>
+  error?: string
+}
+
+const MANIFEST_FILES = [
+  { file: "package.json", parser: parsePackageJson },
+  { file: "Cargo.toml", parser: parseCargoToml },
+  { file: "go.mod", parser: parseGoMod },
+  { file: "pyproject.toml", parser: parsePyprojectToml },
+] as const
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  })
+}
+
+async function parsePackageJson(filePath: string): Promise<ManifestResult> {
+  const text = await Bun.file(filePath).text()
+  const pkg = JSON.parse(text)
+  return {
+    language: "javascript",
+    name: pkg.name ?? "",
+    version: pkg.version ?? "",
+    scripts: pkg.scripts ?? {},
+    dependencies: pkg.dependencies ?? {},
+    devDependencies: pkg.devDependencies ?? {},
+  }
+}
+
+async function parseCargoToml(filePath: string): Promise<ManifestResult> {
+  const text = await Bun.file(filePath).text()
+  const name = text.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/)?.[1] ?? ""
+  const version = text.match(/\[package\][\s\S]*?version\s*=\s*"([^"]+)"/)?.[1] ?? ""
+  const depsMatch = text.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/)
+  const deps: Record<string, string> = {}
+  if (depsMatch) {
+    for (const line of depsMatch[1].split("\n")) {
+      const m = line.match(/^(\S+)\s*=\s*"?([^"\n]+)"?/)
+      if (m) deps[m[1]] = m[2].trim()
+    }
+  }
+  return {
+    language: "rust",
+    name,
+    version,
+    scripts: {},
+    dependencies: deps,
+    devDependencies: {},
+  }
+}
+
+async function parseGoMod(filePath: string): Promise<ManifestResult> {
+  const text = await Bun.file(filePath).text()
+  const moduleName = text.match(/^module\s+(\S+)/m)?.[1] ?? ""
+  const goVersion = text.match(/^go\s+(\S+)/m)?.[1] ?? ""
+  const requireBlock = text.match(/require\s*\(([\s\S]*?)\)/)
+  const deps: Record<string, string> = {}
+  if (requireBlock) {
+    for (const line of requireBlock[1].split("\n")) {
+      const m = line.trim().match(/^(\S+)\s+(\S+)/)
+      if (m) deps[m[1]] = m[2]
+    }
+  }
+  return {
+    language: "go",
+    name: moduleName,
+    version: goVersion,
+    scripts: {},
+    dependencies: deps,
+    devDependencies: {},
+  }
+}
+
+async function parsePyprojectToml(filePath: string): Promise<ManifestResult> {
+  const text = await Bun.file(filePath).text()
+  const name = text.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/)?.[1] ?? ""
+  const version = text.match(/\[project\][\s\S]*?version\s*=\s*"([^"]+)"/)?.[1] ?? ""
+  const depsMatch = text.match(/dependencies\s*=\s*\[([\s\S]*?)\]/)
+  const deps: Record<string, string> = {}
+  if (depsMatch) {
+    for (const m of depsMatch[1].matchAll(/"([^"]+)"/g)) {
+      const parts = m[1].split(/[><=~!]+/)
+      deps[parts[0].trim()] = m[1].replace(parts[0].trim(), "").trim() || "*"
+    }
+  }
+  return {
+    language: "python",
+    name,
+    version,
+    scripts: {},
+    dependencies: deps,
+    devDependencies: {},
+  }
+}
+
+function handleManifest(projectPath: string) {
+  return async (_req: Request, _params: Record<string, string>): Promise<Response> => {
+    const results: ManifestResult[] = []
+
+    for (const { file, parser } of MANIFEST_FILES) {
+      const filePath = `${projectPath}/${file}`
+      const bunFile = Bun.file(filePath)
+      const exists = await bunFile.exists()
+      if (!exists) continue
+
+      try {
+        const result = await parser(filePath)
+        results.push(result)
+      } catch (err: unknown) {
+        const language = file === "package.json" ? "javascript"
+          : file === "Cargo.toml" ? "rust"
+          : file === "go.mod" ? "go"
+          : "python"
+        results.push({
+          language,
+          name: "",
+          version: "",
+          scripts: {},
+          dependencies: {},
+          devDependencies: {},
+          error: err instanceof Error ? err.message : String(err),
+        })
+      }
+    }
+
+    return jsonResponse({ manifests: results })
+  }
+}
+
+export const codeExtension: ServerExtension = {
+  id: "code",
+  name: "Code",
+  icon: "code",
+  detect: ["package.json", "Cargo.toml", "go.mod", "pyproject.toml"],
+  routes(ctx) {
+    return [
+      { method: "GET", path: "/manifest", handler: handleManifest(ctx.projectPath) },
+    ]
+  },
+}

package/src/server/extensions.config.ts

@@ -0,0 +1,10 @@
+import { c3Extension } from "./extensions/c3/server"
+import { agentsExtension } from "./extensions/agents/server"
+import { codeExtension } from "./extensions/code/server"
+import type { ServerExtension } from "../shared/extension-types"
+
+export const serverExtensions: ServerExtension[] = [
+  c3Extension,
+  agentsExtension,
+  codeExtension,
+]

package/src/server/external-open.ts

@@ -0,0 +1,69 @@
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+import type { ClientCommand } from "../shared/protocol"
+import { resolveLocalPath } from "./paths"
+import { hasCommand, spawnDetached } from "./process-utils"
+
+type OpenExternalCommand = Extract<ClientCommand, { type: "system.openExternal" }>
+
+export async function openExternal(command: OpenExternalCommand) {
+  const resolvedPath = resolveLocalPath(command.localPath)
+  const platform = process.platform
+  const info = command.action === "open_finder"
+    ? await stat(resolvedPath).catch(() => null)
+    : null
+
+  if (platform === "darwin") {
+    if (command.action === "open_finder") {
+      if (info?.isDirectory()) {
+        spawnDetached("open", [resolvedPath])
+      } else {
+        spawnDetached("open", ["-R", resolvedPath])
+      }
+      return
+    }
+    if (command.action === "open_terminal") {
+      spawnDetached("open", ["-a", "Terminal", resolvedPath])
+      return
+    }
+  }
+
+  if (platform === "win32") {
+    if (command.action === "open_finder") {
+      if (info?.isDirectory()) {
+        spawnDetached("explorer", [resolvedPath])
+      } else {
+        spawnDetached("explorer", ["/select,", resolvedPath])
+      }
+      return
+    }
+    if (command.action === "open_terminal") {
+      if (hasCommand("wt")) {
+        spawnDetached("wt", ["-d", resolvedPath])
+        return
+      }
+      spawnDetached("cmd", ["/c", "start", "", "cmd", "/K", `cd /d ${resolvedPath}`])
+      return
+    }
+  }
+
+  if (command.action === "open_finder") {
+    spawnDetached("xdg-open", [info?.isDirectory() ? resolvedPath : path.dirname(resolvedPath)])
+    return
+  }
+  if (command.action === "open_terminal") {
+    for (const terminalCommand of ["x-terminal-emulator", "gnome-terminal", "konsole"]) {
+      if (!hasCommand(terminalCommand)) continue
+      if (terminalCommand === "gnome-terminal") {
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
+      } else if (terminalCommand === "konsole") {
+        spawnDetached(terminalCommand, ["--workdir", resolvedPath])
+      } else {
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
+      }
+      return
+    }
+    spawnDetached("xdg-open", [resolvedPath])
+  }
+}

package/src/server/generate-fork-context.ts

@@ -0,0 +1,58 @@
+import type { TranscriptEntry } from "../shared/types"
+import { getForkPreset } from "../shared/fork-presets"
+import { QuickResponseAdapter } from "./quick-response"
+import { toTranscriptLine } from "./transcript-utils"
+import { buildSessionSeedPrompt } from "./session-seed"
+
+const MAX_FORK_TRANSCRIPT_LINES = 32
+const MAX_FORK_TRANSCRIPT_CHARS = 14_000
+const MAX_FORK_LINE_CHARS = 700
+/** Build a bounded transcript excerpt from a list of transcript entries.
+ * Exported for reuse by merge-context generation. */
+export function buildForkTranscriptExcerpt(entries: TranscriptEntry[]): string {
+  const lines = entries
+    .map((e) => toTranscriptLine(e, MAX_FORK_LINE_CHARS))
+    .filter((line): line is string => Boolean(line))
+
+  if (lines.length === 0) return "No prior transcript context was available."
+
+  const selected = lines.slice(-MAX_FORK_TRANSCRIPT_LINES)
+  const omittedCount = lines.length - selected.length
+  const header = omittedCount > 0
+    ? [`Recent source transcript excerpt. Older relevant lines omitted: ${omittedCount}.`]
+    : ["Recent source transcript excerpt:"]
+
+  const combined = [...header, ...selected]
+  let serialized = combined.join("\n")
+  if (serialized.length <= MAX_FORK_TRANSCRIPT_CHARS) return serialized
+
+  const trimmed: string[] = []
+  let remaining = MAX_FORK_TRANSCRIPT_CHARS - header[0]!.length - 1
+  for (let index = selected.length - 1; index >= 0; index -= 1) {
+    const line = selected[index]!
+    const cost = line.length + 1
+    if (remaining - cost < 0) break
+    trimmed.unshift(line)
+    remaining -= cost
+  }
+
+  return [...header, ...trimmed].join("\n")
+}
+
+export async function generateForkPromptForChat(
+  forkIntent: string,
+  entries: TranscriptEntry[],
+  cwd: string,
+  presetId?: string,
+  adapter = new QuickResponseAdapter(),
+): Promise<string> {
+  const preset = getForkPreset(presetId)
+  return buildSessionSeedPrompt({
+    mode: "fork",
+    intent: forkIntent,
+    preset,
+    sources: [{ chatId: "current-session", entries }],
+    cwd,
+    adapter,
+  })
+}