pantheon-opencode 1.5.0-beta.8 → 1.5.0

package/src/pantheon/v2-hooks.ts

@@ -1,287 +0,0 @@
-/**
- * V2 Session Hooks — Pantheon session hooks for the V2 plugin API.
- *
- * Provides two hook types:
- * - `"prompt"` hook: Vision message interception (paste-and-ask). Intercepts
- *   user messages with pasted images and replaces them with text instructions
- *   or native vision descriptions.
- * - `"context"` hook: Inject routing policy, active goals, and pending todos
- *   into the system context before each LLM call.
- *
- * These handlers are PURE — they depend only on structural interfaces.
- *
- * @module pantheon/v2-hooks
- */
-
-import type { BackgroundJobBoard } from './background-job-board.ts'
-import { buildCompactionContext } from './delegation-compaction.ts'
-import type { GoalStore } from './goal-loop.ts'
-import { createPantheonLogger } from './logger.ts'
-import type { TodoEnforcer } from './todo-enforcer.ts'
-
-const log = createPantheonLogger({ module: 'pantheon-v2-hooks' })
-
-// ─── Types ───────────────────────────────────────────────────────────────
-
-/**
- * Structural context event passed to the "context" hook.
- * V2 API: `ctx.session.hook("context", (event) => { ... })`
- */
-export interface V2ContextHookEvent {
-  sessionID: string
-  // Unknown: host beta may send string, string[], SystemPart objects
-  // ({type,text}), mixed arrays, or non-array. Narrow internally (fail-open).
-  system: unknown
-  generation: {
-    temperature?: number
-  }
-}
-
-/**
- * Structural prompt event passed to the "prompt" hook.
- * V2 API: `ctx.session.hook("prompt", (event) => { ... })`
- */
-export interface V2PromptHookEvent {
-  sessionID: string
-  message: unknown
-}
-
-/**
- * Dependencies for session hooks.
- */
-export interface V2HookDeps {
-  board: BackgroundJobBoard
-  goalStore: GoalStore
-  todoEnforcer: TodoEnforcer
-}
-
-// ─── Context Hook ────────────────────────────────────────────────────────
-
-const POLICY_MARKER = '<!-- pantheon-v2-policy -->'
-const ROUTING_POLICY =
-  `${POLICY_MARKER}\nFollow Pantheon routing policy: delegate implementation work ` +
-  `to the named specialist and do not claim work was performed without verification.`
-
-/** Default max compaction items (matching routing.yml background_delegation.max_compaction_items). */
-const DEFAULT_MAX_COMPACTION_ITEMS = 10
-
-/**
- * Extract comparable text from a system entry: plain string or
- * SystemPart-like object ({type,text}). Returns null for junk (null/number).
- * Runtime sniffing: pinned SDK (@opencode-ai/plugin 1.18.18) only knows
- * string/string[] — host beta sends objects. Never throws (fail-open).
- */
-function systemEntryText(entry: unknown): string | null {
-  try {
-    if (typeof entry === 'string') return entry
-    if (
-      typeof entry === 'object' &&
-      entry !== null &&
-      typeof (entry as { text?: unknown }).text === 'string'
-    ) {
-      return (entry as { text: string }).text
-    }
-    return null
-  } catch {
-    return null
-  }
-}
-
-function hasPolicyMarker(arr: unknown[]): boolean {
-  try {
-    return arr.some((s) => {
-      const t = systemEntryText(s)
-      return t?.includes(POLICY_MARKER) ?? false
-    })
-  } catch {
-    return false
-  }
-}
-
-function usesObjectShape(arr: unknown[]): boolean {
-  try {
-    return arr.some(
-      (s) =>
-        typeof s === 'object' && s !== null && typeof (s as { text?: unknown }).text === 'string',
-    )
-  } catch {
-    return false
-  }
-}
-
-function toSystemEntry(text: string, useObject: boolean): string | { type: 'text'; text: string } {
-  return useObject ? { type: 'text', text } : text
-}
-
-/**
- * Context hook handler — injects Pantheon policy, routing, and compaction
- * state into the system context before each LLM call.
- *
- * Registered via: `ctx.session.hook("context", handler)`
- */
-export function createV2ContextHookHandler(deps: V2HookDeps) {
-  return async (event: V2ContextHookEvent): Promise<void> => {
-    try {
-      // Beta 19192 hardening (defense-in-depth) + SystemPart sniffing: the
-      // host may send string[], SystemPart objects ({type,text}), mixed
-      // arrays, a single string, or a non-array system. Preserve the string
-      // path behavior; inject object shape when the array contains objects
-      // (else host schema validation fails on system[N]). Never throw.
-      const rawSystem: unknown = (event as { system?: unknown } | null | undefined)?.system
-      let system: unknown[]
-      if (typeof rawSystem === 'string') {
-        system = rawSystem.includes(POLICY_MARKER) ? [rawSystem] : [rawSystem, ROUTING_POLICY]
-        ;(event as { system?: unknown }).system = system
-      } else if (Array.isArray(rawSystem)) {
-        // 1. Inject routing policy if not already present (string OU .text)
-        if (!hasPolicyMarker(rawSystem)) {
-          rawSystem.push(toSystemEntry(ROUTING_POLICY, usesObjectShape(rawSystem)))
-        }
-        system = rawSystem
-      } else {
-        // Non-string, non-array system: ignore silently (fail-open).
-        return
-      }
-
-      // 2. Inject compaction context (active goals, pending todos, delegations)
-      // Convert blocks to the same shape as the host array (object vs string).
-      const blocks = await buildCompactionContext(deps.board, {
-        sessionID: event.sessionID,
-        maxItems: DEFAULT_MAX_COMPACTION_ITEMS,
-        goals: {
-          enabled: true,
-          list: (sessionID: string) => deps.goalStore.list(sessionID),
-        },
-        todos: {
-          enabled: true,
-          list: (sessionID: string) => deps.todoEnforcer.listPendingTodos(sessionID),
-        },
-      })
-      if (blocks.length > 0) {
-        const useObject = usesObjectShape(system)
-        for (const b of blocks) {
-          system.push(useObject ? { type: 'text' as const, text: b } : b)
-        }
-      }
-
-      // 3. Apply conservative temperature for routing decisions
-      const generation = (event as { generation?: { temperature?: number } }).generation
-      if (generation != null && generation.temperature === undefined) {
-        generation.temperature = 0.2
-      }
-    } catch (err) {
-      log.warn('[Pantheon V2] Context hook failed:', err)
-      // Fail-open: never break the session
-    }
-  }
-}
-
-// ─── Prompt Hook ─────────────────────────────────────────────────────────
-
-/**
- * Prompt hook handler — intercepts user messages for vision processing.
- *
- * Registered via: `ctx.session.hook("prompt", handler)`
- *
- * Note: The full vision handler is complex (file I/O, provider API calls).
- * This is a minimal adapter that delegates to the V1 vision handler
- * if available. Without vision infrastructure, it's a no-op.
- */
-export function createV2PromptHookHandler(_deps: V2HookDeps) {
-  return async (event: V2PromptHookEvent): Promise<void> => {
-    // Vision interception is a complex subsystem (see src/pantheon/vision.ts).
-    // The V2 prompt hook delegates to the V1 vision handler via the plugin's
-    // integration point. Without V1 client access, this is a graceful no-op.
-    //
-    // TODO: Wire full vision handler when V2 provides SDK client access.
-    void event
-  }
-}
-
-// ─── Tool Hooks ──────────────────────────────────────────────────────────
-
-/**
- * Tool execute.before hook — enforces read-only restrictions, command
- * normalization, and todo preservation.
- *
- * Registered via: `ctx.tool.hook("execute.before", handler)`
- */
-export interface V2ToolBeforeEvent {
-  tool: string
-  sessionID: string
-  callID: string
-  args?: unknown
-}
-
-export function createV2ToolBeforeHookHandler(
-  enforcementGuard: (
-    input: { tool: string; sessionID: string; callID: string },
-    output?: { args?: unknown },
-  ) => void,
-  commandNormalizer: (
-    input: { tool: string; sessionID: string; callID: string },
-    output?: { args?: unknown },
-  ) => Promise<void>,
-) {
-  return async (event: V2ToolBeforeEvent): Promise<void> => {
-    try {
-      enforcementGuard(
-        { tool: event.tool, sessionID: event.sessionID, callID: event.callID },
-        { args: event.args },
-      )
-      await commandNormalizer(
-        { tool: event.tool, sessionID: event.sessionID, callID: event.callID },
-        { args: event.args },
-      )
-    } catch (err) {
-      log.warn('[Pantheon V2] Tool before-hook failed:', err)
-    }
-  }
-}
-
-/**
- * Tool execute.after hook — augments read output with hashline tags
- * and applies context sandbox truncation.
- *
- * Registered via: `ctx.tool.hook("execute.after", handler)`
- */
-export interface V2ToolAfterEvent {
-  tool: string
-  sessionID: string
-  callID: string
-  args?: unknown
-  // The host may send a non-string output (shape drift on beta). Keep this
-  // honest as unknown and narrow with typeof at the use site — never assume.
-  output: unknown
-}
-
-export function createV2ToolAfterHookHandler(
-  readEnhancer: (
-    input: { tool: string; sessionID: string; callID: string; args?: unknown },
-    output: { output: string },
-  ) => Promise<void>,
-  sandboxHandler: (
-    input: { tool: string; sessionID: string; callID: string; args?: unknown },
-    output: { output: string },
-  ) => Promise<void>,
-) {
-  return async (event: V2ToolAfterEvent): Promise<void> => {
-    try {
-      const input = {
-        tool: event.tool,
-        sessionID: event.sessionID,
-        callID: event.callID,
-        args: event.args,
-      }
-      // Narrow the honest unknown: only strings flow through the enhancers.
-      // Non-string output is left untouched (fail-open, preserve host shape).
-      if (typeof event.output !== 'string') return
-      const output = { output: event.output }
-      await sandboxHandler(input, output)
-      await readEnhancer(input, output)
-      event.output = output.output
-    } catch (err) {
-      log.warn('[Pantheon V2] Tool after-hook failed:', err)
-    }
-  }
-}

package/src/pantheon/v2-tool-definitions.ts

@@ -1,331 +0,0 @@
-/**
- * V2 Tool Definitions — the 9 Pantheon orchestration tools adapted for the
- * V2 plugin API. Each tool wraps existing V1 infrastructure (delegation,
- * goal-loop, hashline, cost-command, model-command) into a unified
- * `{ name, description, input, execute }` shape compatible with V2's
- * `ctx.tool.transform()`.
- *
- * These definitions are PURE — they don't import any V1 plugin types.
- * The execute functions use a structural `ToolContextLike` surface that
- * both V1 and V2 can satisfy.
- *
- * @module pantheon/v2-tool-definitions
- */
-
-import type { z } from 'zod'
-import type { CostCommand } from './cost-command.ts'
-import type { DelegationToolset } from './delegation.ts'
-import type { GoalToolset } from './goal-loop.ts'
-import type { ModelToolset } from './model-command.ts'
-
-// ─── Structural Context ──────────────────────────────────────────────────
-
-/**
- * Minimal structural context passed to V2 tool execute functions.
- * Matches V1's ToolContextLike but avoids importing V1 types.
- */
-export interface V2ToolContext {
-  sessionID: string
-  directory?: string
-  worktree?: string
-  agent?: string
-}
-
-/**
- * A V2-compatible tool definition: name + description + JSON-Schema input
- * + async execute function.
- */
-export interface V2ToolDefinition {
-  name: string
-  description: string
-  input: {
-    type: 'object'
-    properties: Record<string, unknown>
-    required?: string[]
-  }
-  execute: (input: Record<string, unknown>, context: V2ToolContext) => Promise<string>
-}
-
-// ─── Zod → JSON-Schema Helpers ──────────────────────────────────────────
-
-/**
- * Convert a zod ZodRawShape to a minimal JSON-Schema properties object.
- * Uses safe introspection: checks for `.describe()` and basic shape keys.
- * Falls back to `{ type: "string" }` for unrecognizable schemas.
- */
-function zodShapeToJsonSchema(
-  shape: z.ZodRawShape,
-  required: string[] = [],
-): { properties: Record<string, unknown>; required?: string[] } {
-  const properties: Record<string, unknown> = {}
-  for (const [key, schema] of Object.entries(shape)) {
-    const prop: Record<string, unknown> = {}
-
-    // Get description via .describe() if available
-    try {
-      const schemaAsObj = schema as unknown as Record<string, unknown>
-      const describeFn = schemaAsObj.describe
-      if (typeof describeFn === 'function') {
-        const desc = (describeFn as () => string).call(schemaAsObj)
-        if (typeof desc === 'string' && desc !== '') {
-          prop.description = desc
-        }
-      }
-    } catch {
-      // Some zod types may throw on describe()
-    }
-
-    // Detect type from constructor name or _def.type (works across zod versions)
-    const typeName = schema.constructor?.name ?? ''
-    const defObj = (schema as unknown as { _def?: Record<string, unknown> })?._def
-    const defType = (defObj?.typeName as string) ?? ''
-
-    if (typeName.includes('ZodString') || defType === 'ZodString') {
-      prop.type = 'string'
-    } else if (typeName.includes('ZodNumber') || defType === 'ZodNumber') {
-      prop.type = 'number'
-    } else if (typeName.includes('ZodBoolean') || defType === 'ZodBoolean') {
-      prop.type = 'boolean'
-    } else if (typeName.includes('ZodEnum') || defType === 'ZodEnum') {
-      prop.type = 'string'
-      // Safely extract enum values
-      try {
-        const schemaObj = schema as unknown as Record<string, unknown>
-        const defObj = schemaObj._def as Record<string, unknown> | undefined
-        const values = (schemaObj.options ?? defObj?.values) as string[] | undefined
-        if (Array.isArray(values)) prop.enum = values
-      } catch {
-        /* ignore */
-      }
-    } else if (typeName.includes('ZodArray') || defType === 'ZodArray') {
-      prop.type = 'array'
-    } else if (typeName.includes('ZodOptional') || defType === 'ZodOptional') {
-      // Optional wrappers — treat as string by default
-      prop.type = 'string'
-    } else {
-      prop.type = 'string'
-    }
-
-    properties[key] = prop
-  }
-
-  const result: { properties: Record<string, unknown>; required?: string[] } = { properties }
-  if (required.length > 0) {
-    result.required = required
-  }
-  return result
-}
-
-// ─── V2 Tool Factory ────────────────────────────────────────────────────
-
-export interface V2ToolFactoryDeps {
-  delegation: DelegationToolset
-  goalTools: GoalToolset
-  costCommand: CostCommand
-  modelCommand: ModelToolset
-}
-
-/**
- * Create all 9 V2 tool definitions from the V1 infrastructure.
- * These can be registered via `ctx.tool.transform()` or used directly.
- */
-export function createV2ToolDefinitions(deps: V2ToolFactoryDeps): V2ToolDefinition[] {
-  const { delegation, goalTools, costCommand, modelCommand } = deps
-
-  return [
-    // 1. pantheon_delegate
-    {
-      name: 'pantheon_delegate',
-      description: delegation.pantheon_delegate.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(delegation.pantheon_delegate.args as z.ZodRawShape, [
-          'prompt',
-          'agent',
-        ]),
-      },
-      execute: async (input, ctx) => {
-        return delegation.pantheon_delegate.execute(
-          input as Parameters<typeof delegation.pantheon_delegate.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 2. pantheon_delegation_read
-    {
-      name: 'pantheon_delegation_read',
-      description: delegation.pantheon_delegation_read.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(delegation.pantheon_delegation_read.args as z.ZodRawShape, ['id']),
-      },
-      execute: async (input, ctx) => {
-        return delegation.pantheon_delegation_read.execute(
-          input as Parameters<typeof delegation.pantheon_delegation_read.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 3. pantheon_delegation_list
-    {
-      name: 'pantheon_delegation_list',
-      description: delegation.pantheon_delegation_list.description,
-      input: {
-        type: 'object',
-        properties: {},
-      },
-      execute: async (input, ctx) => {
-        return delegation.pantheon_delegation_list.execute(
-          input as Parameters<typeof delegation.pantheon_delegation_list.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 4. hashline_edit
-    {
-      name: 'hashline_edit',
-      description:
-        'Edit a file anchored by hashline refs (LINE#TAG) instead of raw line numbers. ' +
-        'Ops: replace (ref..endRef or single ref → lines), append/prepend (anchor ref → content), ' +
-        'delete (ref..endRef). ALL refs must be validated against the ORIGINAL file before anything ' +
-        'is written; on mismatch the tool returns an error with a re-tagged excerpt and a ' +
-        'Did-you-mean suggestion, and nothing is modified.',
-      input: {
-        type: 'object',
-        properties: {
-          file: { type: 'string', description: 'Absolute path to the file to edit.' },
-          edits: {
-            type: 'array',
-            description: 'List of edit operations to apply.',
-            items: {
-              type: 'object',
-              properties: {
-                op: {
-                  type: 'string',
-                  enum: ['replace', 'append', 'prepend', 'delete'],
-                  description: 'The edit operation.',
-                },
-                ref: {
-                  type: 'string',
-                  description: 'Anchor ref "LINE#TAG" against the ORIGINAL snapshot.',
-                },
-                endRef: {
-                  type: 'string',
-                  description: 'Optional range end for replace/delete ("LINE#TAG").',
-                },
-                lines: {
-                  type: 'array',
-                  items: { type: 'string' },
-                  description: 'Replacement lines (replace).',
-                },
-                content: {
-                  type: 'string',
-                  description: 'Text to insert (append/prepend; split on newlines).',
-                },
-              },
-              required: ['op', 'ref'],
-            },
-          },
-        },
-        required: ['file', 'edits'],
-      },
-      execute: async (input, ctx) => {
-        // hashline_edit uses a different execute signature — it takes (args, toolContext)
-        // where toolContext includes sessionID, directory, worktree
-        const { createHashlineEditTool } = await import('./hashline/tool.ts')
-        const tool = createHashlineEditTool()
-        const result = await tool.execute(
-          input as Parameters<typeof tool.execute>[0],
-          ctx as Parameters<typeof tool.execute>[1],
-        )
-        if (typeof result === 'string') return result
-        return result.output
-      },
-    },
-
-    // 5. pantheon_goal_create
-    {
-      name: 'pantheon_goal_create',
-      description: goalTools.pantheon_goal_create.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(goalTools.pantheon_goal_create.args as z.ZodRawShape, [
-          'objective',
-        ]),
-      },
-      execute: async (input, ctx) => {
-        return goalTools.pantheon_goal_create.execute(
-          input as Parameters<typeof goalTools.pantheon_goal_create.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 6. pantheon_goal_get
-    {
-      name: 'pantheon_goal_get',
-      description: goalTools.pantheon_goal_get.description,
-      input: {
-        type: 'object',
-        properties: {},
-      },
-      execute: async (input, ctx) => {
-        return goalTools.pantheon_goal_get.execute(
-          input as Parameters<typeof goalTools.pantheon_goal_get.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 7. pantheon_goal_update
-    {
-      name: 'pantheon_goal_update',
-      description: goalTools.pantheon_goal_update.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(goalTools.pantheon_goal_update.args as z.ZodRawShape),
-      },
-      execute: async (input, ctx) => {
-        return goalTools.pantheon_goal_update.execute(
-          input as Parameters<typeof goalTools.pantheon_goal_update.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 8. pantheon_cost
-    {
-      name: 'pantheon_cost',
-      description: costCommand.pantheon_cost.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(costCommand.pantheon_cost.args as z.ZodRawShape),
-      },
-      execute: async (input, ctx) => {
-        return costCommand.pantheon_cost.execute(
-          input as Parameters<typeof costCommand.pantheon_cost.execute>[0],
-          ctx,
-        )
-      },
-    },
-
-    // 9. pantheon_model
-    {
-      name: 'pantheon_model',
-      description: modelCommand.pantheon_model.description,
-      input: {
-        type: 'object',
-        ...zodShapeToJsonSchema(modelCommand.pantheon_model.args as z.ZodRawShape),
-      },
-      execute: async (input, ctx) => {
-        return modelCommand.pantheon_model.execute(
-          input as Parameters<typeof modelCommand.pantheon_model.execute>[0],
-          ctx,
-        )
-      },
-    },
-  ]
-}