saeeol 1.0.9 → 1.1.0

package/src/saeeol/provider/provider.ts

@@ -1,220 +0,0 @@
-//
-// Saeeol-specific provider logic extracted from packages/saeeol/src/provider/provider.ts
-// to minimize merge conflicts with upstream saeeol.
-//
-// This module exports patch functions and data that the upstream provider.ts
-
-import { AI_SDK_PROVIDERS, PROMPTS } from "@saeeol/gateway"
-import { DEFAULT_HEADERS } from "@/saeeol/const"
-import { ProviderID, ModelID } from "@/provider/schema"
-import { Effect, Schema } from "effect"
-import type { ProviderV2 } from "@ai-sdk/provider"
-import { mapValues, omit, pickBy } from "remeda"
-
-/** Default timeout (ms) for provider HTTP requests (connection phase). */
-export const REQUEST_TIMEOUT_MS = 300_000 // 5 minutes
-
-// ---------------------------------------------------------------------------
-// Model schema extensions  (spread into Provider.Model Schema.Struct)
-// ---------------------------------------------------------------------------
-
-export const SAEEOL_MODEL_SCHEMA_EXTENSIONS = {
-  recommendedIndex: Schema.optional(Schema.Number),
-  prompt: Schema.optional(Schema.Literals(PROMPTS)),
-  isFree: Schema.optional(Schema.Boolean),
-  ai_sdk_provider: Schema.optional(Schema.Literals(AI_SDK_PROVIDERS)),
-}
-
-// ---------------------------------------------------------------------------
-// fromModelsDevModel patch — returns saeeol-specific fields
-// ---------------------------------------------------------------------------
-
-export function patchModelsDevModel(providerID: string, source: any) {
-  return {
-    variants: providerID === "saeeol" ? (source.variants ?? {}) : {},
-    recommendedIndex: source.recommendedIndex,
-    prompt: source.prompt,
-    isFree: source.isFree,
-    ai_sdk_provider: source.ai_sdk_provider,
-    options: source.options ?? {},
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Config model patch — merges saeeol-specific fields from config + existing
-// ---------------------------------------------------------------------------
-
-export function patchConfigModel(cfg: any, existing: any) {
-  return {
-    recommendedIndex: cfg.recommendedIndex ?? existing?.recommendedIndex,
-    prompt: cfg.prompt ?? existing?.prompt,
-    isFree: cfg.isFree ?? existing?.isFree,
-    ai_sdk_provider: cfg.ai_sdk_provider ?? existing?.ai_sdk_provider,
-    variants: cfg.variants
-      ? mapValues(
-          pickBy(cfg.variants, (v) => !!v && !v.disabled),
-          (v) => omit(v, ["disabled"]),
-        )
-      : {},
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Custom loaders (new or fully-replaced loaders)
-// ---------------------------------------------------------------------------
-
-type CustomDep = {
-  auth: (id: string) => Effect.Effect<any | undefined>
-  config: () => Effect.Effect<any>
-  env: () => Effect.Effect<Record<string, string | undefined>>
-  get: (key: string) => Effect.Effect<string | undefined>
-}
-
-// Mirrors upstream's CustomLoader return type so Object.entries preserves proper typing
-type CustomLoaderResult = {
-  autoload: boolean
-  getModel?: (sdk: any, modelID: string, options?: Record<string, any>) => Promise<any>
-  vars?: (options: Record<string, any>) => Record<string, string>
-  options?: Record<string, any>
-  discoverModels?: () => Promise<Record<string, any>>
-}
-
-type CustomLoader = (provider: any) => Effect.Effect<CustomLoaderResult>
-
-function shouldUseCopilotResponsesApi(modelID: string): boolean {
-  const match = /^gpt-(\d+)/.exec(modelID)
-  if (!match) return false
-  return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
-}
-
-function useLanguageModel(sdk: any) {
-  return sdk.responses === undefined && sdk.chat === undefined
-}
-
-export function saeeolCustomLoaders(dep: CustomDep): Record<string, CustomLoader> {
-  return {
-    "github-copilot-enterprise": () =>
-      Effect.succeed({
-        autoload: false,
-        async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {
-          if (useLanguageModel(sdk)) return sdk.languageModel(modelID)
-          return shouldUseCopilotResponsesApi(modelID) ? sdk.responses(modelID) : sdk.chat(modelID)
-        },
-        options: {},
-      }),
-
-    saeeol: Effect.fnUntraced(function* (input: any) {
-      const env = yield* dep.env()
-      const hasKey = yield* Effect.gen(function* () {
-        if (input.env.some((item: string) => env[item])) return true
-        if (yield* dep.auth(input.id)) return true
-        if ((yield* dep.config()).provider?.["saeeol"]?.options?.apiKey) return true
-        return false
-      })
-
-      const options: Record<string, string> = {}
-      if (env.SAEEOL_ORG_ID) {
-        options.saeeolOrganizationId = env.SAEEOL_ORG_ID
-      }
-      if (!hasKey) {
-        options.apiKey = "anonymous"
-      }
-
-      return {
-        autoload: Object.keys(input.models).length > 0,
-        options,
-        async getModel(sdk: any, modelID: string) {
-          const provider = input.models[modelID]?.ai_sdk_provider
-          if (provider === "alibaba") return sdk.alibaba(modelID)
-          if (provider === "anthropic") return sdk.anthropic(modelID)
-          if (provider === "openai") return sdk.openai(modelID)
-          if (provider === "openai-compatible") return sdk.openaiCompatible(modelID)
-          return sdk.languageModel(modelID)
-        },
-      }
-    }),
-
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Post-processing for custom loader results
-// Patches options/headers for providers whose upstream loaders we don't fully
-// replace but where specific values differ (headers, branding, env vars).
-// ---------------------------------------------------------------------------
-
-export function patchCustomLoaderResult(
-  providerID: string,
-  result: { options?: Record<string, any> },
-  env: Record<string, string | undefined>,
-) {
-  if (!result.options) return
-
-  switch (providerID) {
-    case "openrouter":
-    case "vercel":
-    case "zenmux":
-      result.options.headers = { ...result.options.headers, ...DEFAULT_HEADERS }
-      break
-    case "cerebras":
-      result.options.headers = {
-        ...result.options.headers,
-        "X-Cerebras-3rd-Party-Integration": "saeeol",
-      }
-      break
-    case "azure": {
-      // Extend env var lookup for Azure baseURL / resource name
-      const url = result.options.baseURL ?? env["AZURE_OPENAI_ENDPOINT"]
-      const resource = (() => {
-        const name = result.options.resourceName
-        if (typeof name === "string" && name.trim() !== "") return name
-        return env["AZURE_RESOURCE_NAME"] ?? env["AZURE_OPENAI_RESOURCE_NAME"]
-      })()
-      if (url) {
-        result.options.baseURL = url
-        delete result.options.resourceName
-      } else if (resource) {
-        result.options.resourceName = resource
-        delete result.options.baseURL
-      }
-      break
-    }
-    // gitlab User-Agent and cloudflare error message are patched inline
-  }
-}
-
-// ---------------------------------------------------------------------------
-// getSmallModel helpers
-// ---------------------------------------------------------------------------
-
-export function saeeolSmallModelPriority(providerID: string): string[] | undefined {
-  if (providerID.startsWith("saeeol")) return ["saeeol-auto/small"]
-  return undefined
-}
-
-// ---------------------------------------------------------------------------
-// Fetch timeout wrapper
-// Replaces AbortSignal.timeout() with a cancellable setTimeout+AbortController
-// so the timer is cleared once response headers arrive. This prevents healthy
-// streaming responses from being aborted mid-stream.
-// ---------------------------------------------------------------------------
-
-export function buildTimeoutSignal(options: Record<string, any>): {
-  signal: AbortSignal | undefined
-  clear: () => void
-} {
-  const ms = options["timeout"] ?? REQUEST_TIMEOUT_MS
-  if (ms === false || ms === undefined || ms === null) return { signal: undefined, clear() {} }
-
-  const controller = new AbortController()
-  const timer = setTimeout(
-    () => controller.abort(new DOMException("The operation timed out.", "TimeoutError")),
-    ms as number,
-  )
-  return {
-    signal: controller.signal,
-    clear() {
-      clearTimeout(timer)
-    },
-  }
-}

package/src/saeeol/provider-options.ts

@@ -1,33 +0,0 @@
-import type { AlibabaProviderOptions } from "@ai-sdk/alibaba"
-import type { AnthropicProviderOptions } from "@ai-sdk/anthropic"
-import type { OpenAIResponsesProviderOptions } from "@ai-sdk/openai"
-import type { OpenAICompatibleProviderOptions } from "@ai-sdk/openai-compatible"
-import type { OpenRouterProviderOptions } from "@openrouter/ai-sdk-provider"
-
-export function saeeolProviderOptions(options: { [x: string]: any }) {
-  const result: Record<string, any> = {}
-  const openrouter = options as OpenRouterProviderOptions & {
-    verbosity?: "high" | "medium" | "low"
-  }
-  result.openrouter = openrouter
-  result.openai = {
-    reasoningEffort:
-      openrouter.reasoning && "effort" in openrouter.reasoning ? openrouter.reasoning?.effort : undefined,
-    textVerbosity: openrouter.verbosity,
-    store: false,
-    forceReasoning: openrouter.reasoning?.enabled,
-  } satisfies OpenAIResponsesProviderOptions
-  result.anthropic = {
-    thinking: { type: openrouter.reasoning?.enabled ? "adaptive" : "disabled" },
-    effort: openrouter.verbosity,
-  } satisfies AnthropicProviderOptions
-  result.openaiCompatible = {
-    reasoningEffort:
-      openrouter.reasoning && "effort" in openrouter.reasoning ? openrouter.reasoning?.effort : undefined,
-    textVerbosity: openrouter.verbosity,
-  } satisfies OpenAICompatibleProviderOptions
-  result.alibaba = {
-    enableThinking: openrouter.reasoning?.enabled,
-  } satisfies AlibabaProviderOptions
-  return result
-}

package/src/saeeol/question/index.ts

@@ -1,62 +0,0 @@
-import { Deferred, Effect } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import * as Log from "@saeeol/core/util/log"
-import { SessionID } from "@/session/schema"
-import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
-
-/**
- * Saeeol-specific helpers for the shared `@/question` module.
- *
- * Extracted here so the upstream file keeps just the import, an Interface entry
- * for `dismissAll`, and one-liner calls at the use sites — minimising the
- * surface area that conflicts with upstream.
- */
-export namespace SaeeolQuestion {
-  const log = Log.create({ service: "question" })
-
-  /** Minimal entry shape both helpers need; matches `PendingEntry` in `@/question`. */
-  type Entry = {
-    info: { id: unknown; sessionID: SessionID }
-    deferred: Deferred.Deferred<any, any>
-  }
-
-  /**
-   * Factory for `Question.dismissAll`: dismisses every pending question on a
-   * session so a new prompt can unblock an in-flight tool waiting on user
-   * input. Mirrors `Suggestion.dismissAll` so both read the same way at the
-   * callsite.
-   *
-   * The caller provides a `publishRejected` callback (closed over the already-
-   * resolved `Bus.Service` in the Question layer) and an error factory so this
-   * helper stays free of any `@/question` import and dodges a circular dep.
-   */
-  export const makeDismissAll =
-    <ID, PE extends Entry>(args: {
-      state: InstanceState.InstanceState<{ pending: Map<ID, PE> }>
-      publishRejected: (entry: PE) => Effect.Effect<void>
-      makeError: () => PE["deferred"] extends Deferred.Deferred<any, infer E> ? E : never
-    }) =>
-    (sessionID: SessionID) =>
-      Effect.gen(function* () {
-        const pending = (yield* InstanceState.get(args.state)).pending
-        for (const [id, entry] of Array.from(pending.entries())) {
-          if (entry.info.sessionID !== sessionID) continue
-          pending.delete(id)
-          log.info("dismissed", { requestID: id })
-          yield* args.publishRejected(entry)
-          yield* Deferred.fail(entry.deferred, args.makeError())
-        }
-      })
-
-  /**
-   * Auto-dismiss when a newer prompt is already queued on this session — a
-   * tool that calls `Question.ask` after the queue event would otherwise block
-   * the run while the user waits for their queued prompt to take over.
-   */
-  export const guardFollowup = <E>(sessionID: SessionID, makeError: () => E) =>
-    Effect.gen(function* () {
-      if (!SaeeolSessionPromptQueue.hasFollowup(sessionID)) return
-      log.info("auto-dismissed — followup queued", { sessionID })
-      return yield* Effect.fail(makeError())
-    })
-}

package/src/saeeol/remote-tui.tsx

@@ -1,47 +0,0 @@
-/**
- * Remote Session Relay TUI indicator
- *
- * RemoteIndicator component for the footer status bar.
- */
-
-import type { Event } from "@saeeol/sdk/v2"
-import { createSignal, onCleanup, onMount, Show } from "solid-js"
-
-type Status = {
-  enabled: boolean
-  connected: boolean
-}
-
-/**
- * Footer indicator showing remote connection status.
- * Uses the TUI event stream after an initial status fetch.
- */
-export function RemoteIndicator(props: {
-  sdk: any
-  theme: any
-  saeeol: boolean
-  event: {
-    on: <Type extends Event["type"]>(type: Type, handler: (event: Extract<Event, { type: Type }>) => void) => () => void
-  }
-}) {
-  const [status, setStatus] = createSignal<Status | null>(null)
-
-  onMount(() => {
-    void props.sdk.client.remote
-      .status()
-      .then((res: { data?: Status }) => {
-        if (res.data) setStatus(res.data)
-      })
-      .catch(() => undefined)
-    const off = props.event.on("saeeol-sessions.remote-status-changed" as any, (evt: any) => setStatus(evt.properties))
-    onCleanup(off)
-  })
-
-  return (
-    <Show when={props.saeeol && status()?.enabled}>
-      <text fg={status()?.connected ? props.theme.success : props.theme.warning}>
-        ◆ Remote{status()?.connected ? "" : " …"}
-      </text>
-    </Show>
-  )
-}

package/src/saeeol/review/command.ts

@@ -1,30 +0,0 @@
-import type { Command } from "@/command"
-import { Review } from "./review"
-
-/**
- * /local-review-uncommitted - local review (uncommitted changes)
- */
-export function localReviewUncommittedCommand(): Command.Info {
-  return {
-    name: "local-review-uncommitted",
-    description: "local review (uncommitted changes)",
-    get template() {
-      return Review.buildReviewPromptUncommitted()
-    },
-    hints: [],
-  }
-}
-
-/**
- * /local-review - local review (current branch vs base)
- */
-export function localReviewCommand(): Command.Info {
-  return {
-    name: "local-review",
-    description: "local review (current branch)",
-    get template() {
-      return Review.buildReviewPromptBranch()
-    },
-    hints: [],
-  }
-}

package/src/saeeol/review/diff.ts

@@ -1,128 +0,0 @@
-import { $ } from "bun"
-import * as Log from "@saeeol/core/util/log"
-import { Instance } from "@/project/instance"
-import type { DiffFile, DiffHunk, DiffResult } from "./types"
-
-const log = Log.create({ service: "review" })
-
-export function parseDiff(raw: string): DiffResult {
-  const files: DiffFile[] = []
-
-  if (!raw.trim()) {
-    return { files: [], raw }
-  }
-
-  const fileDiffs = raw.split(/^diff --git /m).filter(Boolean)
-
-  for (const fileDiff of fileDiffs) {
-    const file = parseFileDiff("diff --git " + fileDiff)
-    if (file) files.push(file)
-  }
-
-  return { files, raw }
-}
-
-function parseFileDiff(content: string): DiffFile | null {
-  const lines = content.split("\n")
-
-  const headerMatch = lines[0]?.match(/^diff --git a\/(.+) b\/(.+)$/)
-  if (!headerMatch) return null
-
-  const oldPath = headerMatch[1]
-  const newPath = headerMatch[2]
-
-  let status: DiffFile["status"] = "modified"
-  const isNew = lines.some((l) => l.startsWith("new file mode"))
-  const isDeleted = lines.some((l) => l.startsWith("deleted file mode"))
-  const isRenamed = lines.some((l) => l.startsWith("rename from"))
-
-  if (isNew) status = "added"
-  else if (isDeleted) status = "deleted"
-  else if (isRenamed) status = "renamed"
-
-  const hunks: DiffHunk[] = []
-  let currentHunk: DiffHunk | null = null
-  let hunkContent: string[] = []
-
-  for (const line of lines) {
-    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/)
-    if (hunkMatch) {
-      if (currentHunk) {
-        currentHunk.content = hunkContent.join("\n")
-        hunks.push(currentHunk)
-      }
-      currentHunk = {
-        oldStart: parseInt(hunkMatch[1], 10),
-        oldLines: parseInt(hunkMatch[2] || "1", 10),
-        newStart: parseInt(hunkMatch[3], 10),
-        newLines: parseInt(hunkMatch[4] || "1", 10),
-        content: "",
-      }
-      hunkContent = [line]
-    } else if (currentHunk && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
-      hunkContent.push(line)
-    }
-  }
-
-  if (currentHunk) {
-    currentHunk.content = hunkContent.join("\n")
-    hunks.push(currentHunk)
-  }
-
-  return {
-    path: newPath,
-    status,
-    hunks,
-    ...(isRenamed && oldPath !== newPath ? { oldPath } : {}),
-  }
-}
-
-export async function getCurrentBranch(): Promise<string> {
-  const result = await $`git rev-parse --abbrev-ref HEAD`.cwd(Instance.directory).quiet().nothrow()
-  return result.stdout.toString().trim()
-}
-
-export async function getBaseBranch(): Promise<string> {
-  const candidates = ["main", "master", "dev", "develop"]
-
-  for (const branch of candidates) {
-    const remoteCheck = await $`git show-ref --verify --quiet refs/remotes/origin/${branch}`
-      .cwd(Instance.directory)
-      .quiet()
-      .nothrow()
-
-    if (remoteCheck.exitCode === 0) {
-      log.info("detected remote base branch", { branch: `origin/${branch}` })
-      return `origin/${branch}`
-    }
-  }
-
-  for (const branch of candidates) {
-    const check = await $`git show-ref --verify --quiet refs/heads/${branch}`
-      .cwd(Instance.directory)
-      .quiet()
-      .nothrow()
-
-    if (check.exitCode === 0) {
-      log.info("detected local base branch", { branch })
-      return branch
-    }
-  }
-
-  log.warn("no base branch found, defaulting to main")
-  return "main"
-}
-
-export async function getBranchCommits(base: string, current: string): Promise<string> {
-  const result = await $`git log ${base}..${current} --oneline`.cwd(Instance.directory).quiet().nothrow()
-
-  if (result.exitCode !== 0) {
-    log.warn("git log for branch commits failed", {
-      exitCode: result.exitCode,
-      stderr: result.stderr.toString(),
-    })
-    return ""
-  }
-
-  return result.stdout.toString().trim()
-}

package/src/saeeol/review/prompt.ts

@@ -1,161 +0,0 @@
-import type { DiffFile } from "./types"
-
-export const REVIEW_PROMPT = `You are SAEEOL, an expert code reviewer with deep expertise in software engineering best practices, security vulnerabilities, performance optimization, and code quality. Your role is advisory — provide clear, actionable feedback but DO NOT modify any files. Do not use any file editing tools.
-
-You are reviewing: \${SCOPE_DESCRIPTION}
-
-## Files Changed
-
-\${FILE_LIST}
-
-## Scope
-\${SCOPE}
-
-**IMPORTANT**: ONLY review code changes from the files listed above. Do NOT review or flag issues in code that is not part of this diff. If you use git commands to gather context, use them only to understand the surrounding code — not to expand the scope of your review.
-
-## How to Review
-
-1. **Gather context**: Read full file context when needed; diffs alone can be misleading, as code that looks wrong in isolation may be correct given surrounding logic.
-
-2. **Tools Usage**: \${TOOLS}
-
-3. **Be confident**: Only flag issues where you have high confidence. Use these thresholds:
-   - **CRITICAL (95%+)**: Security vulnerabilities, data loss risks, crashes, authentication bypasses
-   - **WARNING (85%+)**: Bugs, logic errors, performance issues, unhandled errors
-   - **SUGGESTION (75%+)**: Code quality improvements, best practices, maintainability
-   - **Below 75%**: Don't report — gather more context first or omit the finding
-
-4. **Focus on what matters**:
-   - Security: Injection, auth issues, data exposure
-   - Bugs: Logic errors, null handling, race conditions
-   - Performance: Inefficient algorithms, memory leaks
-   - Error handling: Missing try-catch, unhandled promises
-
-5. **Don't flag**:
-   - Style preferences that don't affect functionality
-   - Minor naming suggestions
-   - Patterns that match existing codebase conventions
-   - Pre-existing code that wasn't modified in this diff
-
-Your review MUST follow this exact format:
-
-## Local Review for \${SCOPE_DESCRIPTION}
-
-### Summary
-2-3 sentences describing what this change does and your overall assessment.
-
-### Issues Found
-| Severity | File:Line | Issue |
-|----------|-----------|-------|
-| CRITICAL | path/file.ts:42 | Brief description |
-| WARNING | path/file.ts:78 | Brief description |
-| SUGGESTION | path/file.ts:15 | Brief description |
-
-If no issues found: "No issues found."
-
-### Detailed Findings
-For each issue listed in the table above:
-- **File:** \`path/to/file.ts:line\`
-- **Confidence:** X%
-- **Problem:** What's wrong and why it matters
-- **Suggestion:** Recommended fix with code snippet if applicable
-
-If no issues found: "No detailed findings."
-
-### Recommendation
-One of:
-- **APPROVE** — Code is ready to merge/commit
-- **APPROVE WITH SUGGESTIONS** — Minor improvements suggested but not blocking
-- **NEEDS CHANGES** — Issues must be addressed before merging
-
-## IMPORTANT: Post-Review Workflow
-
-You MUST first write the COMPLETE review above (Summary, Issues Found, Detailed Findings, Recommendation) as regular text output. Do NOT use the question tool until the entire review text has been written.
-
-ONLY AFTER the full review is written:
-
-- If your recommendation is **APPROVE** with no issues found, you are done. Do NOT call the question tool.
-- If your recommendation is **APPROVE WITH SUGGESTIONS** or **NEEDS CHANGES**, THEN call the question tool to offer fix suggestions with mode switching.
-
-When calling the question tool, provide at least one option. Choose the appropriate mode for each option:
-- mode "code" for direct code fixes (bugs, missing error handling, clear improvements)
-- mode "debug" for issues needing investigation before fixing (race conditions, unclear root causes, intermittent failures)
-- mode "orchestrator" when there are many issues (5+) spanning different categories that need coordinated, planned fixes
-
-Option patterns based on review findings:
-- **Few clear fixes (1-4 issues, same category):** offer mode "code" fixes
-- **Many issues across categories (5+, mixed security/performance/quality):** offer mode "orchestrator" to plan fixes and mode "code" for quick wins
-- **Issues needing investigation:** include a mode "debug" option to investigate root causes
-- **Suggestions only:** offer mode "code" to apply improvements
-
-Example question tool call (ONLY after full review is written):
-{
-  "questions": [{
-    "question": "What would you like to do?",
-    "header": "Next steps",
-    "options": [
-      { "label": "Fix all issues", "description": "Fix all issues found in this review", "mode": "code" },
-      { "label": "Fix critical only", "description": "Fix critical issues only", "mode": "code" }
-    ]
-  }]
-}
-`
-
-export const EMPTY_DIFF_PROMPT = `You are SAEEOL, an expert code reviewer with deep expertise in software engineering best practices, security vulnerabilities, performance optimization, and code quality. Your role is advisory — provide clear, actionable feedback but DO NOT modify any files. Do not use any file editing tools.
-
-You are reviewing: \${SCOPE_DESCRIPTION}.
-
-There is nothing to review.
-
-Your MUST output to the user this exact format:
-
-## Local Review for \${SCOPE_DESCRIPTION}
-
-### Summary
-No changes detected.
-
-### Issues Found
-No issues found.
-
-### Recommendation
-**APPROVE** — Nothing to review.
-`
-
-export function countChanges(file: DiffFile): { additions: number; deletions: number } {
-  let additions = 0
-  let deletions = 0
-  for (const hunk of file.hunks) {
-    for (const line of hunk.content.split("\n")) {
-      if (line.startsWith("+") && !line.startsWith("+++")) additions++
-      else if (line.startsWith("-") && !line.startsWith("---")) deletions++
-    }
-  }
-  return { additions, deletions }
-}
-
-export function formatFileList(files: DiffFile[]): string {
-  return files
-    .map((f) => {
-      const status =
-        f.status === "added" ? "[A]" : f.status === "deleted" ? "[D]" : f.status === "renamed" ? "[R]" : "[M]"
-      const renamed = f.oldPath ? ` (was: ${f.oldPath})` : ""
-      const { additions, deletions } = countChanges(f)
-      return `- ${status} ${f.path}${renamed} (+${additions}, -${deletions})`
-    })
-    .join("\n")
-}
-
-export function buildToolsSection(scope: "uncommitted" | "branch", baseBranch?: string, currentBranch?: string): string {
-  if (scope === "uncommitted") {
-    return `Use these git commands to explore the changes:
-  - View all changes: \`git diff && git diff --cached\`
-  - View specific file change: \`git diff -- <file> && git diff --cached -- <file>\`
-  - View recent commit history: \`git log --oneline -20\`
-  - View file history: \`git blame <file>\``
-  }
-  return `Use these git commands to explore the changes:
-  - View branch diff: \`git diff ${baseBranch}...${currentBranch}\`
-  - View specific file diff: \`git diff ${baseBranch}...${currentBranch} -- <file>\`
-  - View branch commit history: \`git log ${baseBranch}..${currentBranch} --oneline\`
-  - View file history: \`git blame <file>\``
-}