saeeol 1.1.0 → 1.2.0

package/src/overlay/snapshot/diff-full.ts

@@ -0,0 +1,150 @@
+//
+// Patch generation. Runs `git diff --unified=INT_MAX` to produce
+// unified-diff text for a set of files, instead of the npm `diff` package's
+// JS Myers implementation. Myers is O(N*M) with full context, so on
+// huge-file diffs it can block the event loop for minutes (the TUI freeze
+// where ESC stopped working after a turn).
+//
+// Both helpers fail soft: on any git error they return an empty value so
+// callers emit an empty patch string. Additions/deletions come from
+// `git --numstat` and stay accurate.
+
+import { Effect } from "effect"
+import { parsePatch } from "diff"
+import type { StructuredPatch } from "diff"
+import * as Log from "@saeeol/core/util/log"
+
+export namespace DiffFull {
+  const log = Log.create({ service: "snapshot.diff-full" })
+
+  // INT_MAX — git clamps to this, effectively infinite context.
+  const unified = "--unified=2147483647"
+
+  interface GitResult {
+    readonly code: number
+    readonly text: string
+    readonly stderr: string
+  }
+
+  /**
+   * Run `git diff --unified=INT_MAX` for a set of files between two refs and
+   * return a `file → unified-diff text` map. Output format matches what the
+   * `diff` package's `parsePatch` expects, so downstream clients continue to
+   * work.
+   *
+   * `files` entries must use forward slashes (git's output uses `/` even on
+   * Windows); paths with backslashes will silently miss the suffix match.
+   *
+   * Returns an empty map if `files` is empty or git fails. Callers emit an
+   * empty patch string for any file missing from the map; numstat-derived
+   * additions/deletions stay accurate.
+   */
+  export const batch = Effect.fn("DiffFull.batch")(function* (
+    git: (cmd: string[]) => Effect.Effect<GitResult>,
+    from: string,
+    to: string,
+    files: string[],
+  ) {
+    const map = new Map<string, string>()
+    if (files.length === 0) return map
+
+    // Windows cmdline limit is ~8191 chars. 500 * avg-15-char filename ≈ 7500.
+    const size = 500
+    let failed = 0
+    let stderr = ""
+    for (let i = 0; i < files.length; i += size) {
+      const chunk = files.slice(i, i + size)
+      const result = yield* git([
+        "diff",
+        "--no-color",
+        "--no-ext-diff",
+        "--no-renames",
+        unified,
+        from,
+        to,
+        "--",
+        ...chunk,
+      ])
+      if (result.code !== 0) {
+        failed += 1
+        stderr = result.stderr || stderr
+        continue
+      }
+      parseBatch(result.text, chunk, map)
+    }
+    if (failed) {
+      log.info("git diff failed, emitting empty patches for affected files", {
+        chunksFailed: failed,
+        filesTotal: files.length,
+        stderr,
+      })
+    }
+    return map
+  })
+
+  /**
+   * Generate a structured + unified diff for a single file in the working
+   * tree vs HEAD using `git diff --ignore-all-space --unified=INT_MAX`.
+   * Returns `null` if git produces no output (caller emits a content-only
+   * response with no patch).
+   */
+  export const file = Effect.fn("DiffFull.file")(function* (
+    gitText: (args: string[]) => Effect.Effect<string>,
+    file: string,
+  ) {
+    const flags = ["-c", "core.fsmonitor=false", "diff", "--no-color", "--no-ext-diff", "--ignore-all-space", unified]
+    const primary = yield* gitText([...flags, "--", file])
+    const text = primary.trim() ? primary : yield* gitText([...flags, "--staged", "--", file])
+    if (!text.trim()) return null
+    const parsed = parsePatch(text)[0]
+    if (!parsed) return null
+    // Normalize paths to match what `structuredPatch(file, file, ...)` used to
+    // produce — downstream UIs key off the bare filename, not `a/…` / `b/…`.
+    const patch: StructuredPatch = {
+      ...parsed,
+      oldFileName: file,
+      newFileName: file,
+    }
+    return { patch, text }
+  })
+
+  /**
+   * Split a multi-file `git diff` output into one entry per file, keyed by
+   * the input filename (not the path from the header — that can be quoted).
+   * Silently drops sections whose header does not match any entry in `chunk`.
+   */
+  function parseBatch(text: string, chunk: string[], map: Map<string, string>) {
+    // Longest-first so `lib/a.txt` beats `a.txt` on suffix matches.
+    const ordered = chunk.slice().sort((a, b) => b.length - a.length)
+    // With `--no-renames` the header is always `diff --git a/PATH b/PATH` with
+    // both PATHs identical, so we can confirm both halves to avoid false
+    // positives where PATH happens to also appear as a substring earlier in
+    // the line (e.g. a filename containing ` b/`).
+    const match = (header: string) => {
+      for (const f of ordered) {
+        if (header.endsWith(" b/" + f) && header.includes(" a/" + f + " ")) return f
+        if (header.endsWith(` "b/${f}"`) && header.includes(` "a/${f}" `)) return f
+      }
+      return null
+    }
+
+    let current: string | null = null
+    let buffer: string[] = []
+    const flush = () => {
+      if (current !== null && buffer.length) map.set(current, buffer.join("\n"))
+      current = null
+      buffer = []
+    }
+
+    for (const line of text.split("\n")) {
+      if (line.startsWith("diff --git ")) {
+        flush()
+        current = match(line)
+        if (current !== null) buffer.push(line)
+        continue
+      }
+      if (current !== null) buffer.push(line)
+    }
+    flush()
+  }
+}

package/src/overlay/snapshot/index.ts

@@ -0,0 +1,2 @@
+export * from "./track"
+export * from "./diff-full"

package/src/overlay/snapshot/track-hooks.ts

@@ -0,0 +1,182 @@
+import { Effect } from "effect"
+import { applyEdits, modify } from "jsonc-parser"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { Question } from "@/question"
+import type { SessionID, MessageID, PartID } from "@/session/schema"
+import { PartID as PartIDSchema } from "@/session/schema"
+import type { MessageV2 } from "@/session/message-v2"
+import { SaeeolConfig } from "@/saeeol/config/config"
+import { ConfigParse } from "@/config/parse"
+import * as Log from "@saeeol/core/util/log"
+import { makeRuntime } from "@/effect/run-service"
+import type { Config } from "@/config/config"
+import { SaeeolSnapshotTrack as T } from "./track-types"
+
+export namespace SaeeolSnapshotTrack {
+  const log = Log.create({ service: "snapshot.track" })
+
+  const questionRt = makeRuntime(Question.Service, Question.defaultLayer)
+  const fsRt = makeRuntime(AppFileSystem.Service, AppFileSystem.defaultLayer)
+
+  // Lazy to break a module-load cycle with @/session/index.ts.
+  let cachedSessionRt: T.SessionRuntime | undefined
+  async function sessionRuntime(): Promise<T.SessionRuntime> {
+    if (cachedSessionRt) return cachedSessionRt
+    const mod = await import("@/session/session")
+    cachedSessionRt = makeRuntime(mod.Session.Service, mod.Session.defaultLayer) as unknown as T.SessionRuntime
+    return cachedSessionRt
+  }
+
+  const progressPart = (input: {
+    sessionID: SessionID
+    messageID: MessageID
+    partID: PartID
+    text: string
+  }): MessageV2.TextPart => ({
+    id: input.partID,
+    messageID: input.messageID,
+    sessionID: input.sessionID,
+    type: "text",
+    text: input.text,
+    synthetic: true,
+  })
+
+  export const defaultHooks: T.Hooks = {
+    async startProgress(input) {
+      const partID = PartIDSchema.ascending()
+      try {
+        const rt = await sessionRuntime()
+        await rt.runPromise((svc) => svc.updatePart(progressPart({ ...input, partID })))
+        return { sessionID: input.sessionID, messageID: input.messageID, partID }
+      } catch (err) {
+        log.warn("failed to publish snapshot progress part", { err })
+        return undefined
+      }
+    },
+
+    async updateProgress(input) {
+      try {
+        const rt = await sessionRuntime()
+        await rt.runPromise((svc) =>
+          svc.updatePart(
+            progressPart({
+              sessionID: input.handle.sessionID,
+              messageID: input.handle.messageID,
+              partID: input.handle.partID,
+              text: input.text,
+            }),
+          ),
+        )
+      } catch (err) {
+        log.warn("failed to update snapshot progress part", { err })
+      }
+    },
+
+    async endProgress(input) {
+      try {
+        const rt = await sessionRuntime()
+        await rt.runPromise((svc) =>
+          svc.removePart({
+            sessionID: input.handle.sessionID,
+            messageID: input.handle.messageID,
+            partID: input.handle.partID,
+          }),
+        )
+      } catch (err) {
+        log.warn("failed to remove snapshot progress part", { err })
+      }
+    },
+
+    async ask(input) {
+      const answers = await questionRt
+        .runPromise((svc) =>
+          svc.ask({
+            sessionID: input.sessionID,
+            blocking: true,
+            questions: [
+              {
+                header: "Snapshot is slow",
+                headerKey: "snapshot.slowRepo.header",
+                question:
+                  "It is taking a long time to initialize the snapshot system, likely due to the size of the repository.\n\n" +
+                  "Do you want to disable Snapshots for this repository?",
+                questionKey: "snapshot.slowRepo.question",
+                custom: false,
+                options: [
+                  {
+                    label: T.ANSWER_CONTINUE,
+                    labelKey: "snapshot.slowRepo.answer.continue",
+                    description:
+                      "Keep waiting for the snapshot to complete. Subsequent turns are fast once the initial snapshot is built.",
+                    descriptionKey: "snapshot.slowRepo.answer.continue.description",
+                  },
+                  {
+                    label: T.ANSWER_DISABLE,
+                    labelKey: "snapshot.slowRepo.answer.disable",
+                    description:
+                      "Turn off Saeeol's snapshots for this project. You will lose undo/redo of Saeeol file changes, but git still tracks everything.",
+                    descriptionKey: "snapshot.slowRepo.answer.disable.description",
+                  },
+                ],
+              },
+            ],
+          }),
+        )
+        .catch(() => undefined)
+      const pick = answers?.[0]?.[0]
+      if (pick === T.ANSWER_CONTINUE) return "continue"
+      if (pick === T.ANSWER_DISABLE) return "disable"
+      return "dismissed"
+    },
+
+    async persistDisable() {
+      const directory = await currentDirectory()
+      if (!directory) return
+      const patch: Config.Info = { snapshot: false }
+      await fsRt.runPromise((fs) =>
+        Effect.gen(function* () {
+          yield* SaeeolConfig.updateProjectConfig({
+            fs,
+            directory: directory.directory,
+            worktree: directory.worktree,
+            config: patch,
+            read: (file: string) =>
+              fs.readFileString(file).pipe(
+                Effect.map((s) => s as string | undefined),
+                Effect.catch(() => Effect.succeed<string | undefined>(undefined)),
+              ),
+            parse: (input: string, file: string) => ConfigParse.jsonc(input, file) as Config.Info,
+            patch: patchTopLevelJsonc,
+            writable: (c: Config.Info) => c,
+          })
+        }),
+      )
+    },
+  }
+
+  /**
+   * Minimal JSONC patcher. Writes each top-level key in `patch` as a single
+   * `modify()` edit — nested object values are replaced wholesale.
+   */
+  function patchTopLevelJsonc(input: string, patch: Config.Info): string {
+    return Object.entries(patch).reduce((out, [key, value]) => {
+      if (value === undefined) return out
+      if (value !== null && typeof value === "object") {
+        log.warn("patchTopLevelJsonc called with a non-scalar value", { key })
+      }
+      const edits = modify(out, [key], value, {
+        formattingOptions: { insertSpaces: true, tabSize: 2 },
+      })
+      return applyEdits(out, edits)
+    }, input)
+  }
+
+  async function currentDirectory(): Promise<{ directory: string; worktree?: string } | undefined> {
+    const { Instance } = await import("@/project/instance")
+    try {
+      return { directory: Instance.directory, worktree: Instance.worktree }
+    } catch {
+      return undefined
+    }
+  }
+}

package/src/overlay/snapshot/track-types.ts

@@ -0,0 +1,86 @@
+import { Effect } from "effect"
+import type { MessageID, PartID, SessionID } from "@/session/schema"
+import type { MessageV2 } from "@/session/message-v2"
+import { iife } from "@/util/iife"
+
+export namespace SaeeolSnapshotTrack {
+  export const TIMEOUT_MS = iife(() => {
+    const raw = process.env["SAEEOL_SNAPSHOT_TRACK_TIMEOUT_MS"]
+    if (raw) {
+      const parsed = Number(raw)
+      if (Number.isFinite(parsed) && parsed > 0) return parsed
+    }
+    return 10_000
+  })
+
+  export const ANSWER_CONTINUE = "Continue with snapshots"
+  export const ANSWER_DISABLE = "Disable for this project"
+
+  /**
+   * User-visible progress label injected into the live assistant message
+   * while snapshot.track() is running. The leading `{spinner}` placeholder
+   * is replaced at publish time with a rotating braille frame.
+   */
+  export const PROGRESS_INITIALIZING = "{spinner} Initializing snapshot…"
+
+  export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const
+  export const SPINNER_INTERVAL_MS = 120
+
+  export const formatProgress = (template: string, frame: string): string =>
+    template.replace("{spinner}", frame)
+
+  export interface State {
+    disabledForSession: boolean
+    asked: boolean
+  }
+
+  export const makeState = (): State => ({
+    disabledForSession: false,
+    asked: false,
+  })
+
+  export type Answer = "continue" | "disable" | "dismissed"
+
+  export interface Hooks {
+    readonly ask: (input: { sessionID: SessionID }) => Promise<Answer>
+    readonly persistDisable: () => Promise<void>
+    readonly startProgress: (input: {
+      sessionID: SessionID
+      messageID: MessageID
+      text: string
+    }) => Promise<ProgressHandle | undefined>
+    readonly updateProgress: (input: { handle: ProgressHandle; text: string }) => Promise<void>
+    readonly endProgress: (input: { handle: ProgressHandle }) => Promise<void>
+  }
+
+  export type ProgressHandle = {
+    readonly sessionID: SessionID
+    readonly messageID: MessageID
+    readonly partID: PartID
+  }
+
+  export interface WrapInput {
+    readonly inner: Effect.Effect<string | undefined>
+    readonly state: State
+    readonly sessionID?: SessionID
+    readonly messageID?: MessageID
+    readonly hooks?: Hooks
+    readonly timeoutMs?: number
+    readonly progressDelayMs?: number
+  }
+
+  /**
+   * Narrow typed view of the Session.Service methods used by defaultHooks.
+   * Kept local to avoid a value-level import cycle with @/session/index.ts.
+   */
+  export interface SessionPartAPI {
+    readonly updatePart: <T extends MessageV2.Part>(part: T) => Effect.Effect<T>
+    readonly removePart: (
+      input: { sessionID: SessionID; messageID: MessageID; partID: PartID },
+    ) => Effect.Effect<PartID>
+  }
+
+  export type SessionRuntime = {
+    runPromise: <A>(fn: (svc: SessionPartAPI) => Effect.Effect<A>) => Promise<A>
+  }
+}

package/src/overlay/snapshot/track.ts

@@ -0,0 +1,175 @@
+//
+// Slow-repo guard for Snapshot.track.
+//
+// On huge repositories (e.g. 270k+ untracked files in intellij-community)
+// the initial `git add --pathspec-from-file=-` staged by the snapshot system
+// can take tens of seconds — long enough to wedge the turn before the LLM
+// is even called. This wrapper:
+//
+//   1. Runs the real `track()` in a forked fiber.
+//   2. Waits up to `TIMEOUT_MS` for it to complete.
+//   3. If it times out AND we have a sessionID to target, asks the user:
+//        - "Continue with snapshots": keep waiting on this turn; snapshot
+//          finishes eventually and undo/redo stays functional. Future turns
+//          are fast because the snapshot index is built.
+//        - "Disable for this project": interrupt the in-flight snapshot,
+//          persist `"snapshot": false` to `.saeeol/saeeol.json`, and skip. All
+//          future sessions on this project load with snapshots off.
+//        - Dismissed / no sessionID: interrupt and skip. Mark the instance
+//          so we don't prompt again until the instance reloads.
+//
+// While the snapshot is running, we inject a synthetic text part into the
+// live assistant message so the user sees an "Initializing snapshot…" line
+// in the chat — the same place bash/edit tool calls render. The part is
+// removed when the snapshot finishes, so the chat history stays clean.
+//
+// All of this is Saeeol-specific — the upstream snapshot module remains a thin
+// shim that calls into here.
+
+import { Duration, Effect, Fiber } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import { SaeeolSnapshotTrack as T } from "./track-types"
+import { SaeeolSnapshotTrack as H } from "./track-hooks"
+
+/**
+ * Re-exported namespace that merges track-types + track-hooks + wrap().
+ */
+export namespace SaeeolSnapshotTrack {
+  export type Answer = T.Answer
+  export type Hooks = T.Hooks
+  export type WrapInput = T.WrapInput
+  export type ProgressHandle = T.ProgressHandle
+  export type State = T.State
+  export const TIMEOUT_MS = T.TIMEOUT_MS
+  export const ANSWER_CONTINUE = T.ANSWER_CONTINUE
+  export const ANSWER_DISABLE = T.ANSWER_DISABLE
+  export const PROGRESS_INITIALIZING = T.PROGRESS_INITIALIZING
+  export const formatProgress = T.formatProgress
+  export const defaultHooks = H.defaultHooks
+  const log = Log.create({ service: "snapshot.track" })
+  export const makeState = T.makeState
+  /** Runs `inner` with a timeout + slow-repo prompt flow. */
+  export const wrap = (input: T.WrapInput): Effect.Effect<string | undefined> =>
+    Effect.gen(function* () {
+      if (input.state.disabledForSession) return undefined
+
+      const hooks = input.hooks ?? H.defaultHooks
+      const timeoutMs = input.timeoutMs ?? T.TIMEOUT_MS
+      const progressDelayMs = input.progressDelayMs ?? 500
+
+      const canShowProgress = !!(input.sessionID && input.messageID)
+      let handle: T.ProgressHandle | undefined
+      let frameIdx = 0
+
+      const nextFrameText = () => {
+        const frame = T.SPINNER_FRAMES[frameIdx % T.SPINNER_FRAMES.length]
+        frameIdx += 1
+        return T.formatProgress(T.PROGRESS_INITIALIZING, frame)
+      }
+
+      const clearProgress = () =>
+        Effect.gen(function* () {
+          if (!handle) return
+          const h = handle
+          handle = undefined
+          yield* Effect.promise(() =>
+            hooks.endProgress({ handle: h }).catch((err: unknown) => {
+              log.warn("failed to clear snapshot progress part", { err })
+            }),
+          )
+        })
+
+      const progressFiber = canShowProgress
+        ? yield* Effect.forkChild(
+            Effect.gen(function* () {
+              yield* Effect.sleep(Duration.millis(Math.min(progressDelayMs, timeoutMs)))
+              if (!input.sessionID || !input.messageID) return
+              const started = yield* Effect.promise(async () => {
+                try {
+                  return await hooks.startProgress({
+                    sessionID: input.sessionID!,
+                    messageID: input.messageID!,
+                    text: nextFrameText(),
+                  })
+                } catch (err) {
+                  log.warn("failed to publish snapshot progress part", { err })
+                  return undefined
+                }
+              })
+              if (!started) return
+              handle = started
+              while (true) {
+                yield* Effect.sleep(Duration.millis(T.SPINNER_INTERVAL_MS))
+                if (!handle) return
+                const text = nextFrameText()
+                const h = handle
+                yield* Effect.promise(() =>
+                  hooks.updateProgress({ handle: h, text }).catch((err: unknown) => {
+                    log.warn("failed to advance snapshot spinner frame", { err })
+                  }),
+                )
+              }
+            }),
+          )
+        : undefined
+
+      const fiber = yield* Effect.forkChild(input.inner)
+      const quick = yield* Fiber.join(fiber).pipe(
+        Effect.timeoutOption(Duration.millis(timeoutMs)),
+        Effect.catch((err) => {
+          log.warn("snapshot track failed", { err })
+          return Effect.succeed({ _tag: "Some" as const, value: undefined as string | undefined })
+        }),
+      )
+      if (quick._tag === "Some") {
+        if (progressFiber) yield* Fiber.interrupt(progressFiber)
+        yield* clearProgress()
+        return quick.value
+      }
+
+      if (!input.sessionID || input.state.asked) {
+        log.warn("snapshot track slow; skipping for this instance", { timeoutMs })
+        input.state.disabledForSession = true
+        yield* Fiber.interrupt(fiber)
+        if (progressFiber) yield* Fiber.interrupt(progressFiber)
+        yield* clearProgress()
+        return undefined
+      }
+      input.state.asked = true
+
+      const sessionID = input.sessionID
+      const answer = yield* Effect.promise(() => hooks.ask({ sessionID }))
+
+      if (answer === "continue") {
+        log.info("user chose to keep waiting for snapshot; joining fiber")
+        const finished = yield* Fiber.join(fiber).pipe(
+          Effect.catch((err) => {
+            log.warn("snapshot track failed after user continue", { err })
+            return Effect.succeed(undefined as string | undefined)
+          }),
+        )
+        if (progressFiber) yield* Fiber.interrupt(progressFiber)
+        yield* clearProgress()
+        if (finished) input.state.asked = false
+        return finished
+      }
+
+      yield* Fiber.interrupt(fiber)
+      if (progressFiber) yield* Fiber.interrupt(progressFiber)
+      input.state.disabledForSession = true
+
+      if (answer === "disable") {
+        log.info("user chose to disable snapshot for this project")
+        yield* Effect.promise(() =>
+          hooks.persistDisable().catch((err: unknown) => {
+            log.error("failed to persist snapshot:false to project config", { err })
+          }),
+        )
+      } else {
+        log.info("user dismissed snapshot prompt; disabling for this instance only")
+      }
+
+      yield* clearProgress()
+      return undefined
+    })
+}

package/src/overlay/soul.txt

@@ -0,0 +1,28 @@
+You are Kilo, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+# Personality
+
+- Your goal is to accomplish the user's task, NOT engage in a back and forth conversation.
+- You accomplish tasks iteratively, breaking them down into clear steps and working through them methodically.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- NEVER end your result with a question or request to engage in further conversation. Formulate the end of your result in a way that is final and does not require further input from the user.
+- The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.
+
+# Code
+
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+
+## Suggestions
+
+- Use the `question` tool only when you need an actual answer from the user.
+- If the `suggest` tool is available, use it ONLY to offer a local code review — never for other actions like committing, pushing, running tests, or any other next step.
+- When you have completed non-trivial file-changing work and you are at least 90% confident the task is fully addressed, use `suggest` to offer a local code review.
+- Do not withhold a review suggestion merely because the work was reactive, fixed CI/lint failures, touched docs/config, or happened around commit/push work. If there are meaningful changes to review, suggest it.
+- Do not suggest review when there are no file changes, when the change is small or trivial (typo-only, comment-only, formatting-only, or tiny single-line tweaks), when the coding session is fixing another local or remote code review, or when a local code review suggestion has already been made in the current session.
+- Do not suggest it after every edit or partial implementation turn.
+- Keep suggestion text concise, use at most 1-2 actions, and make each accepted action prompt self-contained.
+- When suggesting a code review, choose the right command for the action prompt:
+  - `/local-review-uncommitted` — for reviewing uncommitted working-tree changes (staged, unstaged, and untracked files).
+  - `/local-review` — for reviewing all committed changes on the current branch vs its base branch.
+  - Prefer `/local-review-uncommitted` when the work you just did has not been committed yet.