airaknit 1.1.2-rc.9

package/src/shared/vite-config.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test"
+import viteConfig, { getAllowedHosts } from "../../vite.config"
+
+describe("vite dev watch config", () => {
+  test("ignores unrelated markdown files", () => {
+    expect(viteConfig.server?.watch?.ignored).toEqual([
+      "**/*.md",
+      "**/*.markdown",
+      "**/*.mdx",
+    ])
+  })
+})
+
+describe("getAllowedHosts", () => {
+  test("uses vite defaults when no custom hosts are configured", () => {
+    const original = process.env.KANNA_DEV_ALLOWED_HOSTS
+    delete process.env.KANNA_DEV_ALLOWED_HOSTS
+
+    try {
+      expect(getAllowedHosts()).toBeUndefined()
+    } finally {
+      if (original === undefined) {
+        delete process.env.KANNA_DEV_ALLOWED_HOSTS
+      } else {
+        process.env.KANNA_DEV_ALLOWED_HOSTS = original
+      }
+    }
+  })
+
+  test("accepts explicit host lists and true passthrough", () => {
+    const original = process.env.KANNA_DEV_ALLOWED_HOSTS
+
+    try {
+      process.env.KANNA_DEV_ALLOWED_HOSTS = `["devbox.lan","preview.local"]`
+      expect(getAllowedHosts()).toEqual(["devbox.lan", "preview.local"])
+
+      process.env.KANNA_DEV_ALLOWED_HOSTS = "true"
+      expect(getAllowedHosts()).toBe(true)
+    } finally {
+      if (original === undefined) {
+        delete process.env.KANNA_DEV_ALLOWED_HOSTS
+      } else {
+        process.env.KANNA_DEV_ALLOWED_HOSTS = original
+      }
+    }
+  })
+})

package/src/shared/web-context.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test"
+import { getWebContextPrompt } from "./web-context"
+
+describe("getWebContextPrompt", () => {
+  test("returns a non-empty string for both providers", () => {
+    expect(getWebContextPrompt("claude").length).toBeGreaterThan(0)
+    expect(getWebContextPrompt("codex").length).toBeGreaterThan(0)
+  })
+
+  test("includes Tinkaria and web-based interface for both providers", () => {
+    for (const provider of ["claude", "codex"] as const) {
+      const prompt = getWebContextPrompt(provider)
+      expect(prompt).toContain("Tinkaria")
+      expect(prompt).toContain("web-based interface")
+    }
+  })
+
+  test("mentions the correct provider name", () => {
+    expect(getWebContextPrompt("claude")).toContain("Claude Code")
+    expect(getWebContextPrompt("codex")).toContain("Codex")
+    expect(getWebContextPrompt("codex")).not.toContain("Claude Code")
+  })
+
+  test("includes the current rich-content viewer contract and plan mode context", () => {
+    for (const provider of ["claude", "codex"] as const) {
+      const prompt = getWebContextPrompt(provider)
+      expect(prompt).toContain("The transcript supports rich markdown natively")
+      expect(prompt).toContain("rich-content cards")
+      expect(prompt).toContain("collapse/expand, copy, and opening the content in a larger overlay viewer")
+      expect(prompt).toContain("`html` for rendered embeds")
+      expect(prompt).toContain("`d2` for source-only previews")
+      expect(prompt).toContain("table of contents")
+      expect(prompt).toContain("render/source toggle and zoom controls")
+      expect(prompt).toContain("Prefer direct rich embeds or structured artifact cards over bare links")
+      expect(prompt).toContain("Plan mode")
+    }
+  })
+
+  test("describes cross-session orchestration as explicit tool-mediated chat coordination", () => {
+    const claudePrompt = getWebContextPrompt("claude")
+    expect(claudePrompt).toContain("spawn_agent")
+    expect(claudePrompt).toContain("list_agents")
+    expect(claudePrompt).toContain("fork_context")
+    expect(claudePrompt).toContain("send_input")
+    expect(claudePrompt).toContain("wait_agent")
+    expect(claudePrompt).toContain("close_agent")
+    expect(claudePrompt).toContain("not hidden shared memory")
+    expect(claudePrompt).toContain("Do not assume delegated chats share")
+
+    const codexPrompt = getWebContextPrompt("codex", { codexNativeSubagentsEnabled: true })
+    expect(codexPrompt).toContain("Codex-native subagent collaboration")
+    expect(codexPrompt).toContain("collabAgentToolCall")
+    expect(codexPrompt).toContain("spawnAgent")
+    expect(codexPrompt).toContain("sendInput")
+    expect(codexPrompt).toContain("closeAgent")
+    expect(codexPrompt).not.toContain("spawn_agent creates")
+    expect(codexPrompt).toContain("Do not assume delegated chats share")
+  })
+
+  test("orchestration block describes workflow semantics and accumulation pattern", () => {
+    for (const provider of ["claude", "codex"] as const) {
+      const prompt = getWebContextPrompt(provider, { codexNativeSubagentsEnabled: true })
+      // Workflow: spawn creates child, wait returns its result
+      expect(prompt).toMatch(/child session|spawned child/i)
+      // Accumulation: send_input/sendInput for follow-ups and iterative refinement
+      expect(prompt).toMatch(/send_input|sendInput/)
+      expect(prompt).toMatch(/follow-up|steer|accumulate|native subagent/i)
+      // Report instruction: child should end with a structured report
+      expect(prompt).toMatch(/report/i)
+      // Concurrency: multiple children
+      expect(prompt).toMatch(/multiple.*concurrent|concurrently/i)
+    }
+  })
+
+  test("mentions present_content for codex only when the tool is advertised", () => {
+    const enabledPrompt = getWebContextPrompt("codex", { presentContentEnabled: true })
+    const disabledPrompt = getWebContextPrompt("codex", { presentContentEnabled: false })
+
+    expect(enabledPrompt).toContain("present_content")
+    expect(enabledPrompt).toContain("implementation plans")
+    expect(enabledPrompt).toContain("comparison tables")
+    expect(enabledPrompt).toContain("concise status summaries")
+    expect(enabledPrompt).toContain("direct embeds")
+    expect(enabledPrompt).toContain("dedicated artifact card")
+    expect(enabledPrompt).toContain("easier to scan or interact with")
+    expect(disabledPrompt).not.toContain("present_content")
+  })
+
+  test("never mentions present_content for claude", () => {
+    const prompt = getWebContextPrompt("claude", { presentContentEnabled: true })
+    expect(prompt).not.toContain("present_content")
+  })
+
+  test("mentions ask_user_question for codex only when the tool is advertised", () => {
+    const enabledPrompt = getWebContextPrompt("codex", { askUserQuestionEnabled: true })
+    const disabledPrompt = getWebContextPrompt("codex", { askUserQuestionEnabled: false })
+
+    expect(enabledPrompt).toContain("ask_user_question")
+    expect(enabledPrompt).toContain("clarification")
+    expect(enabledPrompt).toContain("user input")
+    expect(enabledPrompt).toContain("Default mode")
+    expect(enabledPrompt).toContain("request_user_input")
+    expect(disabledPrompt).not.toContain("ask_user_question")
+  })
+
+  test("never mentions ask_user_question for claude", () => {
+    const prompt = getWebContextPrompt("claude", { askUserQuestionEnabled: true })
+    expect(prompt).not.toContain("ask_user_question")
+  })
+})

package/src/shared/web-context.ts

@@ -0,0 +1,76 @@
+import type { AgentProvider } from "./types"
+import { APP_NAME } from "./branding"
+
+const PROVIDER_NAMES: Record<AgentProvider, string> = {
+  claude: "Claude Code",
+  codex: "Codex",
+  "claude-pty": "Claude (PTY)",
+}
+
+/**
+ * Web-context instructions appended to the provider's system prompt.
+ * Makes the model aware it's operating within Tinkaria's browser-based interface
+ * rather than a terminal, enabling richer output choices.
+ */
+export function getWebContextPrompt(
+  provider: AgentProvider,
+  options?: {
+    askUserQuestionEnabled?: boolean
+    codexNativeSubagentsEnabled?: boolean
+    presentContentEnabled?: boolean
+  }
+): string {
+  const promptLines = [
+    `You are operating within ${APP_NAME}, a web-based interface for ${PROVIDER_NAMES[provider]}.`,
+    "The transcript supports rich markdown natively, including tables, fenced code blocks, and Mermaid diagrams. Images from tool results render inline.",
+    "The UI can render rich-content cards for markdown, code, embeds, and preview artifacts. These cards support collapse/expand, copy, and opening the content in a larger overlay viewer.",
+    "Supported embed formats are: `mermaid` for rendered diagrams, `svg` for rendered graphics, `html` for rendered embeds, `iframe` for remote embeds, `diashort` for remote embeds, and `d2` for source-only previews.",
+    "Use structured rich transcript output when it improves clarity, such as tables for comparisons, markdown checklists for plans, Mermaid diagrams for flows and relationships, bounded code samples, or direct embeds when the content is meant to be viewed.",
+    "Images from tool results (screenshots, Read tool on image files) render inline as embedded images.",
+    "Markdown content may be opened in an overlay with a table of contents. Embed content may be opened in an overlay with render/source toggle and zoom controls.",
+    "Prefer direct rich embeds or structured artifact cards over bare links when the content is embeddable and the embedded form is more useful than a plain link.",
+    "The user has a sidebar with chat history and project management — multiple concurrent chats are supported.",
+    "Plan mode renders a visual approval UI with approve/reject controls.",
+  ]
+
+  if (provider === "claude") {
+    promptLines.push(
+      "Cross-session agent work is explicit orchestration between separate chats in the same project, not hidden shared memory.",
+      "spawn_agent creates a child session — its final turn result is what wait_agent returns. Instruct children to end with a structured report.",
+      "list_agents returns the caller's current spawned-agent tree with statuses so you can inspect what is running before steering or waiting.",
+      "send_input sends follow-up messages to a child to steer, accumulate incremental results, or request a summary. The child resumes with full context.",
+      "wait_agent blocks until the child completes its current turn. Call it after each send_input for iterative exchanges.",
+      "close_agent disposes the child session — always close when done.",
+      "You can run multiple children concurrently: spawn all, then wait each.",
+      "Set `fork_context` on spawn_agent when the child session should start with a bounded snapshot of the current chat transcript.",
+      "Do not assume delegated chats share live intermediate reasoning or mutable context — communicate needed context explicitly.",
+      "Delegated chats may already be busy, and orchestration is bounded by depth and concurrency limits.",
+    )
+  } else if (options?.codexNativeSubagentsEnabled) {
+    promptLines.push(
+      "Cross-session agent work uses Codex-native subagent collaboration, surfaced to Tinkaria as collabAgentToolCall transcript items.",
+      "Use the native subagent tools for spawnAgent, sendInput, wait, and closeAgent behavior; do not invent snake_case dynamic-tool calls.",
+      "A spawned child should finish with a structured report so the parent can use the result after waiting.",
+      "You can run multiple children concurrently: spawn all useful children first, then wait for the needed results.",
+      "Do not assume delegated chats share live intermediate reasoning or mutable context — communicate needed context explicitly.",
+      "Delegated chats may already be busy, and orchestration is bounded by depth and concurrency limits.",
+    )
+  }
+
+  if (provider === "codex" && options?.presentContentEnabled) {
+    promptLines.push(
+      "When you need to intentionally present a bounded artifact in the transcript, call the `present_content` dynamic tool instead of only describing it in assistant text.",
+      "Use `present_content` for artifacts that benefit from a dedicated card, such as implementation plans, comparison tables, diagrams, code samples, checklists, design notes, concise status summaries, or direct embeds.",
+      "Use `present_content` when a dedicated artifact card will make the result easier to scan or interact with."
+    )
+  }
+
+  if (provider === "codex" && options?.askUserQuestionEnabled) {
+    promptLines.push(
+      "When you need clarification, a decision, or user input before proceeding, call the `ask_user_question` dynamic tool.",
+      "`ask_user_question` is available in Default mode; do not use plan-mode-only `request_user_input` for Codex user questions."
+    )
+  }
+
+  return promptLines.join("\n")
+}

package/src/shared/workflow-types.ts

@@ -0,0 +1,51 @@
+export type WorkflowTrigger = "manual" | { cron: string } | { on_event: string }
+export type WorkflowTarget = "all" | string
+
+export interface WorkflowStep {
+  mcp_tool: string
+  params: Record<string, unknown>
+  label?: string
+}
+
+export interface WorkflowDefinition {
+  id: string
+  name: string
+  trigger: WorkflowTrigger
+  target: WorkflowTarget
+  steps: WorkflowStep[]
+  on_failure: "stop" | "continue" | "rollback"
+}
+
+export type WorkflowRunStatus = "running" | "completed" | "failed" | "cancelled"
+
+export interface WorkflowRunStepResult {
+  stepIndex: number
+  label?: string
+  mcp_tool: string
+  repoId?: string
+  status: "pending" | "running" | "completed" | "failed" | "skipped"
+  output?: string
+  error?: string
+  startedAt?: number
+  completedAt?: number
+}
+
+export interface WorkflowRunState {
+  runId: string
+  workflowId: string
+  workspaceId: string
+  targetRepoIds: string[]
+  status: WorkflowRunStatus
+  steps: WorkflowRunStepResult[]
+  startedAt: number
+  completedAt?: number
+  failedStep?: number
+  error?: string
+  triggeredBy: string
+}
+
+export interface WorkflowRunsSnapshot {
+  workspaceId: string
+  runs: WorkflowRunState[]
+  activeRunIds: string[]
+}

package/src/shared/workspace-types.ts

@@ -0,0 +1,100 @@
+import type { AgentProvider } from "./types"
+
+// --- SessionIndex types ---
+
+export type SessionStatus = "active" | "idle" | "complete" | "failed"
+
+export interface SessionRecord {
+  chatId: string
+  intent: string
+  status: SessionStatus
+  provider: AgentProvider
+  branch: string | null
+  filesTouched: string[]
+  commandsRun: string[]
+  lastActivity: string
+}
+
+
+// --- TranscriptSearch types ---
+
+export type SearchDocumentKind = "user_prompt" | "assistant_text" | "tool_call" | "tool_result"
+
+export interface SearchResult {
+  chatId: string
+  timestamp: string
+  kind: SearchDocumentKind
+  fragment: string
+  score: number
+}
+
+// --- WorkspaceAgent types ---
+
+export interface DelegationResult {
+  status: "ok" | "error"
+  message: string
+  data?: Record<string, unknown>
+}
+
+// --- CLI output types ---
+
+export interface CliError {
+  error: string
+  code: number
+  detail?: string
+}
+
+// --- Coordination types ---
+
+export type TodoPriority = "high" | "normal" | "low"
+export type CoordinationTodoStatus = "open" | "claimed" | "complete" | "abandoned"
+export type ClaimStatus = "active" | "released" | "conflict"
+export type WorktreeStatus = "ready" | "assigned" | "removed"
+
+export interface WorkspaceTodo {
+  id: string
+  description: string
+  priority: TodoPriority
+  status: CoordinationTodoStatus
+  claimedBy: string | null
+  outputs: string[]
+  createdBy: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface WorkspaceClaim {
+  id: string
+  intent: string
+  files: string[]
+  sessionId: string
+  status: ClaimStatus
+  conflictsWith: string | null
+  createdAt: string
+}
+
+export interface WorkspaceWorktree {
+  id: string
+  branch: string
+  baseBranch: string
+  path: string
+  assignedTo: string | null
+  status: WorktreeStatus
+  createdAt: string
+}
+
+export interface WorkspaceRule {
+  id: string
+  content: string
+  setBy: string
+  updatedAt: string
+}
+
+export interface WorkspaceCoordinationSnapshot {
+  workspaceId: string
+  todos: WorkspaceTodo[]
+  claims: WorkspaceClaim[]
+  worktrees: WorkspaceWorktree[]
+  rules: WorkspaceRule[]
+  lastUpdated: string
+}