feat(vcs): add status raw diff and guarded apply

packages/app/src/context/prompt.test.ts

@@ -8,6 +8,7 @@ let isStructurallyEmpty: typeof import("./prompt").isStructurallyEmpty
 
 beforeAll(async () => {
   mock.module("@solidjs/router", () => ({
+    useNavigate: () => () => undefined,
     useParams: () => ({}),
   }))
   mock.module("@opencode-ai/ui/context", () => ({
@@ -182,4 +183,3 @@ describe("isStructurallyEmpty", () => {
     expect(isStructurallyEmpty(DEFAULT_PROMPT, [], [image])).toBe(false)
   })
 })
-

packages/app/src/hooks/use-providers.test.ts

@@ -1,6 +1,7 @@
 import { expect, mock, test } from "bun:test"
 
 mock.module("@solidjs/router", () => ({
+  useNavigate: () => () => undefined,
   useParams: () => ({}),
 }))
 

packages/app/src/pages/session/session-layout.test.ts

@@ -6,6 +6,7 @@ let sessionRouteLayoutKey: typeof import("./session-layout").sessionRouteLayoutK
 
 beforeAll(async () => {
   mock.module("@solidjs/router", () => ({
+    useNavigate: () => () => undefined,
     useParams: () => ({}),
   }))
   const mod = await import("./session-layout")

packages/app/src/pages/session/use-session-followups.test.ts

@@ -1,7 +1,8 @@
-import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test"
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test"
 import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import { createRoot, createSignal } from "solid-js"
 import { createStore } from "solid-js/store"
+import type { FollowupDraft } from "@/components/prompt-input/followup-draft"
 import { normalize, readPersistedAsync, readPersistedSync } from "@/utils/persist-read"
 import type {
   canSendFollowupItem as CanSendFollowupItem,
@@ -25,15 +26,14 @@ let followupDraftMatchesScope: typeof FollowupDraftMatchesScope
 const sendFollowupCalls: unknown[] = []
 let sendFollowupDraftImpl: (input: unknown) => Promise<boolean>
 
-type FollowupDraft = any
-
 function workspaceStorage(dir: string) {
   const head = (dir.slice(0, 12) || "workspace").replace(/[^a-zA-Z0-9._-]/g, "-")
-  let sum = 0
+  let hash = 0x811c9dc5
   for (let index = 0; index < dir.length; index++) {
-    sum = (sum + dir.charCodeAt(index) * (index + 1)) >>> 0
+    hash ^= dir.charCodeAt(index)
+    hash = Math.imul(hash, 0x01000193)
   }
-  return `pawwork.workspace.${head}.${sum.toString(36)}.dat`
+  return `pawwork.workspace.${head}.${(hash >>> 0).toString(36)}.dat`
 }
 
 const PersistMock = {
@@ -82,6 +82,7 @@ beforeAll(async () => {
       workspaceStorage,
     },
     persisted: (_target: unknown, store: unknown) => store,
+    removePersisted: () => undefined,
   }))
   mock.module("@/utils/id", () => ({
     Identifier: {
@@ -99,6 +100,10 @@ beforeAll(async () => {
   followupDraftMatchesScope = mod.followupDraftMatchesScope
 })
 
+afterAll(() => {
+  mock.restore()
+})
+
 function deferred<T>() {
   let resolve!: (value: T) => void
   const promise = new Promise<T>((done) => {

packages/opencode/src/git/index.ts

@@ -57,6 +57,7 @@ export namespace Git {
   export interface PatchOptions {
     readonly context?: number
     readonly maxOutputBytes?: number
+    readonly binary?: boolean
   }
 
   export interface Result {
@@ -73,6 +74,7 @@ export namespace Git {
     readonly cwd: string
     readonly env?: Record<string, string>
     readonly maxOutputBytes?: number
+    readonly stdin?: ChildProcess.CommandInput
   }
 
   export interface Interface {
@@ -95,11 +97,14 @@ export namespace Git {
     readonly statsStaged: (cwd: string) => Effect.Effect<Stat[]>
     readonly statsHead: (cwd: string, ref: string) => Effect.Effect<Stat[]>
     readonly patch: (cwd: string, ref: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
+    readonly patchAll: (cwd: string, ref: string, options?: PatchOptions) => Effect.Effect<Patch>
+    readonly patchStagedAll: (cwd: string, options?: PatchOptions) => Effect.Effect<Patch>
     readonly patchUnstaged: (cwd: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
     readonly patchStaged: (cwd: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
     readonly patchHead: (cwd: string, ref: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
     readonly patchUntracked: (cwd: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
     readonly statUntracked: (cwd: string, file: string) => Effect.Effect<Stat | undefined>
+    readonly applyPatch: (cwd: string, patch: string) => Effect.Effect<Result>
   }
 
   const kind = (code: string): Kind => {
@@ -116,14 +121,16 @@ export namespace Git {
     Service,
     Effect.gen(function* () {
       const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const encoder = new TextEncoder()
+      const stdin = (text: string) => Stream.make(encoder.encode(text))
 
       const run = Effect.fn("Git.run")(
         function* (args: string[], opts: Options) {
           const proc = ChildProcess.make("git", [...cfg, ...args], {
             cwd: opts.cwd,
             env: opts.env,
             extendEnv: true,
-            stdin: "ignore",
+            stdin: opts.stdin ?? "ignore",
             stdout: "pipe",
             stderr: "pipe",
           })
@@ -429,17 +436,35 @@ export namespace Git {
         return { text: result.truncated ? "" : result.text(), truncated: result.truncated } satisfies Patch
       })
 
+      const binary = (options?: PatchOptions) => (options?.binary ? ["--binary"] : [])
+
       const patch = Effect.fn("Git.patch")(function* (cwd: string, ref: string, file: string, options?: PatchOptions) {
         return yield* patchResult(
-          ["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", file],
+          ["diff", "--patch", ...binary(options), "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", file],
+          cwd,
+          options,
+        )
+      })
+
+      const patchAll = Effect.fn("Git.patchAll")(function* (cwd: string, ref: string, options?: PatchOptions) {
+        return yield* patchResult(
+          ["diff", "--patch", ...binary(options), "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", "."],
+          cwd,
+          options,
+        )
+      })
+
+      const patchStagedAll = Effect.fn("Git.patchStagedAll")(function* (cwd: string, options?: PatchOptions) {
+        return yield* patchResult(
+          ["diff", "--cached", "--patch", ...binary(options), "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, "--", "."],
           cwd,
           options,
         )
       })
 
       const patchUnstaged = Effect.fn("Git.patchUnstaged")(function* (cwd: string, file: string, options?: PatchOptions) {
         return yield* patchResult(
-          ["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, "--", file],
+          ["diff", "--patch", ...binary(options), "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, "--", file],
           cwd,
           options,
         )
@@ -451,6 +476,7 @@ export namespace Git {
             "diff",
             "--cached",
             "--patch",
+            ...binary(options),
             "--no-ext-diff",
             "--no-renames",
             `--unified=${options?.context ?? 3}`,
@@ -464,15 +490,26 @@ export namespace Git {
 
       const patchHead = Effect.fn("Git.patchHead")(function* (cwd: string, ref: string, file: string, options?: PatchOptions) {
         return yield* patchResult(
-          ["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "HEAD", "--", file],
+          ["diff", "--patch", ...binary(options), "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "HEAD", "--", file],
           cwd,
           options,
         )
       })
 
       const patchUntracked = Effect.fn("Git.patchUntracked")(function* (cwd: string, file: string, options?: PatchOptions) {
         return yield* patchResult(
-          ["diff", "--no-index", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, "--", "/dev/null", file],
+          [
+            "diff",
+            "--no-index",
+            "--patch",
+            ...binary(options),
+            "--no-ext-diff",
+            "--no-renames",
+            `--unified=${options?.context ?? 3}`,
+            "--",
+            "/dev/null",
+            file,
+          ],
           cwd,
           options,
         )
@@ -498,6 +535,10 @@ export namespace Git {
         } satisfies Stat
       })
 
+      const applyPatch = Effect.fn("Git.applyPatch")(function* (cwd: string, patch: string) {
+        return yield* run(["apply", "-"], { cwd, stdin: stdin(patch) })
+      })
+
       return Service.of({
         run,
         branch,
@@ -518,11 +559,14 @@ export namespace Git {
         statsStaged,
         statsHead,
         patch,
+        patchAll,
+        patchStagedAll,
         patchUnstaged,
         patchStaged,
         patchHead,
         patchUntracked,
         statUntracked,
+        applyPatch,
       })
     }),
   )