opencode-drive 0.1.0

package/src/experimental/flows/generate.ts

@@ -0,0 +1,278 @@
+import { createRng } from "../generators/random.js"
+import { defaultWeights, pickWeighted, type GenerationWeights } from "./weights.js"
+import type { FlowResponse, FlowScenario, FlowTurn, InteractionKind, ResponseKind } from "./types.js"
+
+const tasks = [
+  {
+    subject: "the request routing path",
+    target: "src/server.ts",
+    symbol: "createServer",
+    concern: "a request can be dispatched after shutdown begins",
+  },
+  {
+    subject: "the cache invalidation behavior",
+    target: "src/cache.ts",
+    symbol: "invalidate",
+    concern: "stale entries survive a failed refresh",
+  },
+  {
+    subject: "the configuration loading path",
+    target: "src/config.ts",
+    symbol: "loadConfig",
+    concern: "defaults are applied before validation",
+  },
+  {
+    subject: "the greeting helper",
+    target: "src/example.ts",
+    symbol: "greet",
+    concern: "empty names produce awkward output",
+  },
+] as const
+
+const followUps = [
+  "Keep the change narrow and call out any assumptions.",
+  "Check the edge cases before proposing a change.",
+  "Prefer evidence from the repository over guesses.",
+  "Explain what should be tested when you are done.",
+] as const
+
+const split = (text: string, pieces: number) => {
+  const size = Math.ceil(text.length / pieces)
+  return Array.from({ length: pieces }, (_, index) => text.slice(index * size, (index + 1) * size)).filter(Boolean)
+}
+
+export function generateFlow(seed: number, options?: { readonly turns?: number; readonly weights?: GenerationWeights; readonly enabledTools?: Set<keyof GenerationWeights["toolSelection"]> }): FlowScenario {
+  const rng = createRng(seed)
+  const weights = options?.weights ?? defaultWeights
+  const task = rng.pick(tasks)
+  const count = options?.turns ?? rng.int(6, 9)
+  
+  if (options?.enabledTools && options.enabledTools.size > 0) {
+  }
+  
+  // Use weights to select response kinds for each turn
+  const responseKindKeys: readonly ResponseKind[] = ["text", "chunked", "reasoning", "markdown", "raw", "tool"]
+  const responseKindWeights = responseKindKeys.map(k => weights.responseKinds[k])
+  const selected: ResponseKind[] = Array.from({ length: count }, () =>
+    pickWeighted(responseKindKeys, responseKindWeights, rng.next())
+  )
+  
+  const turns = selected.map((kind, index) => makeTurn(seed, index, kind, task, rng.pick(followUps), rng, weights, options?.enabledTools))
+  const responseKinds = { text: 0, chunked: 0, reasoning: 0, markdown: 0, raw: 0, tool: 0 }
+  const toolNames: Record<string, number> = {}
+  const interactions = { normal: 0, "double-submit": 0, steer: 0, interrupt: 0, "provider-drop": 0 }
+  const streamChunkTypes = new Set<string>()
+  for (const turn of turns) {
+    interactions[turn.interaction]++
+    for (const response of turn.responses) {
+      responseKinds[response.kind]++
+      for (const name of response.toolNames ?? []) toolNames[name] = (toolNames[name] ?? 0) + 1
+      for (const type of response.streamChunkTypes ?? []) streamChunkTypes.add(type)
+      for (const item of response.chunks.flat()) {
+        streamChunkTypes.add(item.type)
+      }
+    }
+  }
+  return {
+    version: 1,
+    seed,
+    name: `${task.symbol}-${seed.toString(36)}`,
+    turns,
+    coverage: {
+      responseKinds,
+      toolNames,
+      interactions,
+      streamChunkTypes: [...streamChunkTypes],
+      providerExchanges: turns.reduce((total, turn) => total + turn.responses.length, 0),
+    },
+  }
+}
+
+function makeTurn(
+  seed: number,
+  index: number,
+  kind: ResponseKind,
+  task: (typeof tasks)[number],
+  followUp: string,
+  rng: ReturnType<typeof createRng>,
+  weights: GenerationWeights,
+  enabledTools?: Set<keyof GenerationWeights["toolSelection"]>,
+): FlowTurn {
+  const marker = `[flow-${seed}-turn-${index + 1}-complete]`
+  
+  // Use weights to select interaction kind
+  const interactionKeys: readonly InteractionKind[] = ["normal", "double-submit", "steer", "interrupt", "provider-drop"]
+  const interactionWeights = interactionKeys.map(k => weights.interactions[k])
+  const interaction: InteractionKind = kind === "raw" 
+    ? "provider-drop"
+    : kind === "tool"
+    ? (seed % 2 === 0 ? "normal" : "interrupt")
+    : pickWeighted(interactionKeys, interactionWeights, rng.next())
+  
+  const prompts = [
+    `Orient yourself in this project and identify where ${task.subject} lives. ${followUp}`,
+    `Inspect ${task.target} and trace ${task.symbol} through its callers. What behavior is observable?`,
+    `The suspected bug is that ${task.concern}. Find evidence for or against that hypothesis.`,
+    "Compare the smallest plausible fixes. Which one preserves existing behavior best?",
+    "Describe the implementation in enough detail that another engineer could apply it safely.",
+    "Now challenge that approach with one failure scenario and revise it if necessary.",
+    "Give me a focused test plan covering the happy path, boundary behavior, and regression risk.",
+    "Review the whole investigation for contradictions or unsupported claims.",
+    "Summarize the final recommendation and the next concrete action.",
+  ]
+  return {
+    prompt: prompts[index % prompts.length]!,
+    marker,
+    interaction,
+    ...(interaction === "steer" ? { steerPrompt: `While that is running, also check the concurrency boundary for turn ${index + 1}.` } : {}),
+    responses: [
+      ...makeResponses(kind, marker, task, index, rng, weights, enabledTools),
+      ...(interaction === "steer"
+        ? [{ kind: "text" as const, chunks: [[{ type: "textDelta" as const, text: `I incorporated the in-flight steering prompt. ${marker}` }]], finish: "stop" as const }]
+        : []),
+    ],
+  }
+}
+
+function makeResponses(
+  kind: ResponseKind,
+  marker: string,
+  task: (typeof tasks)[number],
+  index: number,
+  rng: ReturnType<typeof createRng>,
+  weights: GenerationWeights,
+  enabledTools?: Set<keyof GenerationWeights["toolSelection"]>,
+): ReadonlyArray<FlowResponse> {
+  const conclusion = `Turn ${index + 1}: the evidence keeps the investigation focused on \`${task.symbol}\`. ${marker}`
+  if (kind === "text") return [{ kind, chunks: [[{ type: "textDelta", text: conclusion }]], finish: "stop" }]
+  if (kind === "chunked") {
+    return [{ kind, chunks: split(`${conclusion} I will preserve the current API and verify the boundary explicitly.`, 4).map((text) => [{ type: "textDelta", text }] as const), finish: "stop" }]
+  }
+  if (kind === "reasoning") {
+    return [{
+      kind,
+      chunks: [
+        [{ type: "reasoningDelta", text: `I need to separate observed behavior from the hypothesis about ${task.concern}.` }],
+        [{ type: "textDelta", text: conclusion }],
+      ],
+      finish: "stop",
+    }]
+  }
+  if (kind === "markdown") {
+    return [{
+      kind,
+      chunks: [[{
+        type: "textDelta",
+        text: `### Findings\n\n- Target: \`${task.target}\`\n- Symbol: \`${task.symbol}\`\n- Risk: ${task.concern}\n\n\`\`\`ts\n// Preserve the existing contract; test the boundary first.\n\`\`\`\n\n${marker}`,
+      }]],
+      finish: "stop",
+    }]
+  }
+  if (kind === "raw") {
+    // Use weights to decide whether to generate a failure at all
+    const failureTotal = weights.failures.disconnect + 
+                         weights.failures.invalidProviderEvent + 
+                         weights.failures.disconnectDuringToolInput + 
+                         weights.failures.disconnectAfterTools
+    const hasAnyFailure = failureTotal > 0 && rng.next() < (failureTotal / (failureTotal + 1))
+    
+    if (!hasAnyFailure) {
+      // Normal raw response, no failures
+      return [{
+        kind,
+        chunks: [
+          [{ type: "raw", chunk: { id: `chatcmpl-${index}`, object: "chat.completion.chunk", created: 1, model: "sim-model", choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] } }],
+          [{ type: "raw", chunk: { choices: [] } }],
+          [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: null, reasoning_content: "Checking the stream state. " }, finish_reason: null }] } }],
+          [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: null }, finish_reason: null }] } }],
+          [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: conclusion }, finish_reason: null }] } }],
+          [{ type: "raw", chunk: { choices: [], usage: { prompt_tokens: 120, completion_tokens: 24, total_tokens: 144, prompt_tokens_details: { cached_tokens: 20 }, completion_tokens_details: { reasoning_tokens: 5 } } } }],
+        ],
+        finish: (["stop", "length", "content-filter"] as const)[index % 3]!,
+        streamChunkTypes: [
+          "chat.metadata-role",
+          "chat.empty-choices",
+          "chat.reasoning-content",
+          "chat.content-null",
+          "chat.content-delta",
+          "chat.usage",
+          `chat.finish.${(["stop", "length", "content-filter"] as const)[index % 3]!}`,
+        ],
+      }]
+    }
+    
+    // Pick which failure mode to use
+    const failureKeys: readonly (keyof typeof weights.failures)[] = ["disconnect", "invalidProviderEvent", "disconnectDuringToolInput", "disconnectAfterTools"]
+    const failureWeights = failureKeys.map(k => weights.failures[k])
+    const failureType = pickWeighted(failureKeys, failureWeights, rng.next())
+    
+    const regularDisconnect = failureType === "disconnect"
+    const invalidEvent = failureType === "invalidProviderEvent"
+    
+    return [{
+      kind,
+      chunks: [
+        [{ type: "raw", chunk: { id: `chatcmpl-${index}`, object: "chat.completion.chunk", created: 1, model: "sim-model", choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [] } }],
+        [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: null, reasoning_content: "Checking the stream state. " }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: null }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [{ index: 0, delta: { content: conclusion }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [], usage: { prompt_tokens: 120, completion_tokens: 24, total_tokens: 144, prompt_tokens_details: { cached_tokens: 20 }, completion_tokens_details: { reasoning_tokens: 5 } } } }],
+        ...(invalidEvent ? [[{ type: "raw" as const, chunk: { choices: "detached" } }]] : []),
+      ],
+      finish: (["stop", "length", "content-filter"] as const)[index % 3]!,
+      ...(regularDisconnect ? { terminal: "disconnect" as const } : invalidEvent ? { terminal: "invalid-provider-event" as const } : {}),
+      streamChunkTypes: [
+        "chat.metadata-role",
+        "chat.empty-choices",
+        "chat.reasoning-content",
+        "chat.content-null",
+        "chat.content-delta",
+        "chat.usage",
+        `chat.finish.${(["stop", "length", "content-filter"] as const)[index % 3]!}`,
+        ...(invalidEvent ? ["chat.invalid-provider-event"] : []),
+        ...(regularDisconnect ? ["chat.transport-disconnect"] : []),
+      ],
+    }]
+  }
+  
+  // Tool response - keep it simple like the original, but filter tools
+  const baseTools = [
+    { name: "glob" as const, input: { pattern: "src/**/*.ts" } },
+    { name: "grep" as const, input: { pattern: task.symbol, path: "src", include: "*.ts" } },
+    { name: "read" as const, input: { path: task.target, limit: 120 } },
+    { name: "todowrite" as const, input: { todos: [{ content: "Reproduce detached loading state", status: "in_progress", priority: "high" }] } },
+  ]
+  
+  // Filter to only enabled tools
+  const availableTools = enabledTools 
+    ? baseTools.filter(t => enabledTools.has(t.name))
+    : baseTools
+  
+  if (availableTools.length === 0) {
+    // No tools enabled, return text response instead
+    return [{ kind: "text", chunks: [[{ type: "textDelta", text: conclusion }]], finish: "stop" }]
+  }
+  
+  const tool = availableTools[index % availableTools.length]!
+  return [
+    {
+      kind,
+      chunks: [
+        [{ type: "reasoningDelta", text: "I should inspect the repository before making a claim." }],
+        [{ type: "textDelta", text: `I'll check ${task.target} and related code.` }],
+        [{ type: "raw", chunk: { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: `call-${marker.slice(1, -1)}`, function: { name: tool.name, arguments: "{" } }] }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: JSON.stringify(tool.input).slice(1) } }] }, finish_reason: null }] } }],
+        [{ type: "raw", chunk: { choices: [], usage: { prompt_tokens: 180, completion_tokens: 30, total_tokens: 210 } } }],
+      ],
+      finish: "tool-calls",
+      toolNames: [tool.name],
+      streamChunkTypes: ["chat.tool-call-start", "chat.tool-call-arguments", "chat.usage", "chat.finish.tool-calls"],
+    },
+    {
+      kind: "text",
+      chunks: [[{ type: "textDelta", text: `The repository observation is now part of the evidence. ${conclusion}` }]],
+      finish: "stop",
+    },
+  ]
+}

package/src/experimental/flows/index.ts

@@ -0,0 +1,6 @@
+export { generateFlow } from "./generate.js"
+export { defineProperty, flowProperties, isRunning } from "./properties.js"
+export type { FlowProperty, FlowPropertyContext, TurnOutcome } from "./properties.js"
+export type { FlowResponse, FlowResult, FlowScenario, FlowTurn, InteractionKind, ResponseKind } from "./types.js"
+export { defaultWeights, parseWeightsFromArgs, pickWeighted, shouldGenerate } from "./weights.js"
+export type { GenerationWeights } from "./weights.js"

package/src/experimental/flows/properties.ts

@@ -0,0 +1,51 @@
+import type { BackendSimulationClient, SimulationClient, UiState } from "../../client/index.js"
+import type { FlowTurn } from "./types.js"
+
+export type TurnOutcome = "completed" | "interrupted" | "provider-error"
+
+export interface FlowPropertyContext {
+  readonly turn: FlowTurn
+  readonly ui: SimulationClient
+  readonly backend: BackendSimulationClient
+  readonly outcome?: TurnOutcome
+  readonly waitFor: (label: string, check: () => Promise<boolean>) => Promise<void>
+}
+
+export interface FlowProperty {
+  readonly name: string
+  readonly afterSubmit?: (context: FlowPropertyContext) => Promise<void>
+  readonly afterTerminal?: (context: FlowPropertyContext) => Promise<void>
+}
+
+export const defineProperty = (property: FlowProperty) => property
+
+export const flowProperties: ReadonlyArray<FlowProperty> = [
+  defineProperty({
+    name: "submitted-turn-shows-running",
+    afterSubmit: (context) => {
+      if (context.turn.responses.some((response) => response.terminal === "invalid-provider-event" || response.terminal === "disconnect")) return Promise.resolve()
+      return context.waitFor("submitted turn to show running", async () => isRunning(await context.ui.state()))
+    },
+  }),
+  defineProperty({
+    name: "turn-reaches-terminal-outcome",
+    afterTerminal: async (context) => {
+      if (context.outcome === undefined) throw new Error("turn has no terminal outcome")
+      await context.waitFor(
+        "terminal turn to have no provider exchange",
+        async () => (await context.backend.pendingExchanges()).exchanges.length === 0,
+      )
+    },
+  }),
+  defineProperty({
+    name: "terminal-turn-clears-running",
+    afterTerminal: (context) =>
+      context.waitFor("terminal turn to stop showing running", async () => {
+        return !isRunning(await context.ui.state())
+      }),
+  }),
+]
+
+export function isRunning(state: UiState) {
+  return !state.focused.editor
+}

package/src/experimental/flows/types.ts

@@ -0,0 +1,47 @@
+import type { BackendFinishReason, BackendItem, UiState } from "../../client/index.js"
+
+export type ResponseKind = "text" | "chunked" | "reasoning" | "markdown" | "raw" | "tool"
+export type InteractionKind = "normal" | "double-submit" | "steer" | "interrupt" | "provider-drop"
+
+export interface FlowResponse {
+  readonly kind: ResponseKind
+  readonly chunks: ReadonlyArray<ReadonlyArray<BackendItem>>
+  readonly finish: BackendFinishReason
+  readonly toolNames?: ReadonlyArray<string>
+  readonly terminal?: "finish" | "invalid-provider-event" | "disconnect"
+  readonly streamChunkTypes?: ReadonlyArray<string>
+}
+
+export interface FlowTurn {
+  readonly prompt: string
+  readonly marker: string
+  readonly interaction: InteractionKind
+  readonly steerPrompt?: string
+  readonly responses: ReadonlyArray<FlowResponse>
+}
+
+export interface FlowScenario {
+  readonly version: 1
+  readonly seed: number
+  readonly name: string
+  readonly turns: ReadonlyArray<FlowTurn>
+  readonly coverage: {
+    readonly responseKinds: Readonly<Record<ResponseKind, number>>
+    readonly toolNames: Readonly<Record<string, number>>
+    readonly interactions: Readonly<Record<InteractionKind, number>>
+    readonly streamChunkTypes: ReadonlyArray<string>
+    readonly providerExchanges: number
+  }
+}
+
+export interface FlowResult {
+  readonly seed: number
+  readonly name: string
+  readonly turns: number
+  readonly assistantExchanges: number
+  readonly subagentExchanges: number
+  readonly titleExchanges: number
+  readonly traceRecords: number
+  readonly durationMs: number
+  readonly finalState: UiState
+}

package/src/experimental/flows/weights.ts

@@ -0,0 +1,198 @@
+/**
+ * Weighted generation config for controlling what kinds of scenarios are generated.
+ * All weights are relative; they control probability distribution.
+ */
+
+export interface GenerationWeights {
+  // Response types
+  responseKinds: {
+    text: number
+    chunked: number
+    reasoning: number
+    markdown: number
+    raw: number
+    tool: number
+  }
+
+  // Interaction patterns
+  interactions: {
+    normal: number
+    "double-submit": number
+    steer: number
+    interrupt: number
+    "provider-drop": number
+  }
+
+  // Failure modes (for raw responses)
+  failures: {
+    invalidProviderEvent: number // malformed streaming event
+    disconnect: number // abrupt connection drop
+    disconnectDuringToolInput: number // drop mid-tool-call
+    disconnectAfterTools: number // drop after tool submission
+  }
+
+  // Tools to generate
+  toolSelection: {
+    glob: number
+    grep: number
+    read: number
+    todowrite: number
+    shell: number
+    write: number
+    edit: number
+    apply_patch: number
+    webfetch: number
+    websearch: number
+    skill: number
+    subagent: number
+    question: number
+  }
+}
+
+/**
+ * Default weights: balanced distribution across all options
+ */
+export const defaultWeights: GenerationWeights = {
+  responseKinds: {
+    text: 1,
+    chunked: 1,
+    reasoning: 1,
+    markdown: 1,
+    raw: 1,
+    tool: 1,
+  },
+  interactions: {
+    normal: 3,
+    "double-submit": 1,
+    steer: 1,
+    interrupt: 1,
+    "provider-drop": 1,
+  },
+  failures: {
+    invalidProviderEvent: 1,
+    disconnect: 1,
+    disconnectDuringToolInput: 1,
+    disconnectAfterTools: 1,
+  },
+  toolSelection: {
+    glob: 1,
+    grep: 1,
+    read: 1,
+    todowrite: 1,
+    shell: 1,
+    write: 1,
+    edit: 1,
+    apply_patch: 1,
+    webfetch: 1,
+    websearch: 1,
+    skill: 1,
+    subagent: 1,
+    question: 1,
+  },
+}
+
+/**
+ * Parse weights from CLI flags like --weight-text=5 --weight-disconnect=10
+ * Format: --weight-<key>=<number>
+ * Keys can use dashes or underscores (both map to the same key)
+ */
+export function parseWeightsFromArgs(args: string[]): GenerationWeights {
+  const weights = structuredClone(defaultWeights)
+  const keyMap = new Map<string, [category: keyof GenerationWeights, key: string]>()
+
+  // Build map of all known keys
+  const typedWeights = weights as Record<keyof GenerationWeights, Record<string, number>>
+  Object.entries(typedWeights).forEach(([category, items]) => {
+    if (typeof items === "object" && !Array.isArray(items)) {
+      Object.keys(items).forEach((key) => {
+        keyMap.set(key, [category as keyof GenerationWeights, key])
+        keyMap.set(key.replace(/_/g, "-"), [category as keyof GenerationWeights, key])
+      })
+    }
+  })
+
+  for (const arg of args) {
+    if (!arg.startsWith("--weight-")) continue
+    const [keyStr, valueStr] = arg.slice(9).split("=")
+    if (!keyStr || !valueStr) continue
+
+    const value = parseFloat(valueStr)
+    if (!isFinite(value) || value < 0) {
+      console.warn(`Invalid weight value for --weight-${keyStr}: ${valueStr}`)
+      continue
+    }
+
+    const found = keyMap.get(keyStr)
+    if (!found) {
+      console.warn(`Unknown weight key: --weight-${keyStr}`)
+      continue
+    }
+
+    const [category, key] = found
+    typedWeights[category][key] = value
+  }
+
+  return weights
+}
+
+/**
+ * Pick from weighted options using an RNG
+ */
+export function pickWeighted<T extends readonly string[]>(
+  options: T,
+  weights: readonly number[],
+  random: number,
+): T[number] {
+  const total = weights.reduce((sum, w) => sum + w, 0)
+  let accumulated = 0
+  const target = random * total
+
+  for (let i = 0; i < options.length; i++) {
+    accumulated += weights[i]!
+    if (target <= accumulated) return options[i]!
+  }
+
+  return options[options.length - 1]!
+}
+
+/**
+ * Get weighted probability for a single option from a set
+ */
+export function shouldGenerate(weight: number, total: number, random: number): boolean {
+  return random < weight / total
+}
+
+/**
+ * Filter tools based on enabled set from CLI
+ * Usage: --tools=glob,grep,read or --tools glob,grep,read
+ */
+export function parseEnabledTools(args: string[]): Set<keyof GenerationWeights["toolSelection"]> | null {
+  // Look for --tools= format
+  let toolsArg = args.find(arg => arg.startsWith("--tools="))?.slice(8)
+  
+  // Look for --tools <value> format
+  if (!toolsArg) {
+    const toolsIndex = args.indexOf("--tools")
+    if (toolsIndex !== -1 && toolsIndex + 1 < args.length) {
+      toolsArg = args[toolsIndex + 1]
+    }
+  }
+  
+  if (!toolsArg) return null
+  
+  const toolList = toolsArg.split(",").map(t => t.trim()).filter(t => t.length > 0)
+  if (toolList.length === 0) return null
+  
+  const validTools: Set<keyof GenerationWeights["toolSelection"]> = new Set()
+  const allTools = new Set(Object.keys(defaultWeights.toolSelection) as Array<keyof GenerationWeights["toolSelection"]>)
+  
+  for (const tool of toolList) {
+    if (allTools.has(tool as keyof GenerationWeights["toolSelection"])) {
+      validTools.add(tool as keyof GenerationWeights["toolSelection"])
+    } else {
+      console.warn(`Unknown tool: ${tool}`)
+    }
+  }
+  
+  return validTools.size > 0 ? validTools : null
+}