oh-my-opencode-slim 0.9.9 → 0.9.11

package/README.md

@@ -371,6 +371,8 @@ If any agent fails to respond, check your provider authentication and config fil
 | **[Tools](docs/tools.md)** | Background tasks, LSP, code search, formatters |
 | **[Configuration](docs/configuration.md)** | Config files, prompt overriding, JSONC, full option reference |
 
+Slim only intercepts `apply_patch` before native execution. It rewrites recoverable stale patches, canonizes safe tolerant matches against the real file when unicode/trim drift is the only mismatch, keeps the authored `new_lines` bytes intact, preserves existing file EOL/final-newline state for updates, validates malformed patches strictly before helper execution, uses a conservative bounded LCS fallback, supports sequential `Update File` hunks on the same path through accumulated helper state, and blocks `apply_patch` before the native tool runs if any patch path falls outside the allowed root/worktree. This rescue does not extend to `edit` or `write`.
+
 ### 💡 Author's Setup
 
 | Doc | Contents |

package/dist/cli/index.js

@@ -208,7 +208,8 @@ var AgentOverrideConfigSchema = z2.object({
   temperature: z2.number().min(0).max(2).optional(),
   variant: z2.string().optional().catch(undefined),
   skills: z2.array(z2.string()).optional(),
-  mcps: z2.array(z2.string()).optional()
+  mcps: z2.array(z2.string()).optional(),
+  options: z2.record(z2.string(), z2.unknown()).optional()
 });
 var MultiplexerTypeSchema = z2.enum(["auto", "tmux", "zellij", "none"]);
 var MultiplexerLayoutSchema = z2.enum([

package/dist/config/schema.d.ts

@@ -59,6 +59,7 @@ export declare const AgentOverrideConfigSchema: z.ZodObject<{
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export declare const MultiplexerTypeSchema: z.ZodEnum<{
     auto: "auto";
@@ -127,6 +128,7 @@ export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>>;
 export type Preset = z.infer<typeof PresetSchema>;
 export declare const WebsearchConfigSchema: z.ZodObject<{
@@ -231,6 +233,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>>;
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -241,6 +244,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
     disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
     multiplexer: z.ZodOptional<z.ZodObject<{

package/dist/hooks/apply-patch/codec.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedPatch } from './types';
+export declare function normalizeUnicode(text: string): string;
+export declare function stripHeredoc(input: string): string;
+export declare function normalizePatchText(patchText: string): string;
+export declare function parsePatch(patchText: string): ParsedPatch;
+export declare function parsePatchStrict(patchText: string): ParsedPatch;
+export declare function formatPatch(patch: ParsedPatch): string;

package/dist/hooks/apply-patch/errors.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyPatchErrorCode, ApplyPatchErrorKind } from './types';
+export declare class ApplyPatchError extends Error {
+    readonly kind: ApplyPatchErrorKind;
+    readonly code: ApplyPatchErrorCode;
+    readonly cause?: unknown;
+    constructor(kind: ApplyPatchErrorKind, code: ApplyPatchErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function getErrorMessage(error: unknown): string;
+export declare function createApplyPatchBlockedError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchValidationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchVerificationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchInternalError(message: string, cause?: unknown): ApplyPatchError;
+export declare function isApplyPatchError(error: unknown): error is ApplyPatchError;
+export declare function isApplyPatchBlockedError(error: unknown): boolean;
+export declare function isApplyPatchValidationError(error: unknown): boolean;
+export declare function isApplyPatchVerificationError(error: unknown): boolean;
+export declare function isApplyPatchInternalError(error: unknown): boolean;
+export declare function getApplyPatchErrorDetails(error: unknown): {
+    kind: ApplyPatchErrorKind;
+    code: ApplyPatchErrorCode;
+    message: string;
+} | undefined;
+export declare function ensureApplyPatchError(error: unknown, context: string): ApplyPatchError;

package/dist/hooks/apply-patch/execution-context.d.ts

@@ -0,0 +1,30 @@
+import { resolveUpdateChunksFromText } from './resolution';
+import type { ApplyPatchRuntimeOptions, PatchHunk, UpdatePatchHunk } from './types';
+export type PreparedFileState = {
+    exists: false;
+    derived: boolean;
+} | {
+    exists: true;
+    text: string;
+    mode?: number;
+    derived: boolean;
+};
+export type PatchExecutionContext = {
+    hunks: PatchHunk[];
+    pathsNormalized: boolean;
+    staged: Map<string, PreparedFileState>;
+    getPreparedFileState: (filePath: string, verb: 'update' | 'delete') => Promise<PreparedFileState>;
+    assertPreparedPathMissing: (filePath: string, verb: 'add' | 'move') => Promise<void>;
+};
+export type ResolvedPreparedUpdate = {
+    resolved: Awaited<ReturnType<typeof resolveUpdateChunksFromText>>['resolved'];
+    nextText: string;
+};
+export declare function isMissingPathError(error: unknown): boolean;
+export declare function parseValidatedPatch(root: string, patchText: string, worktree?: string): Promise<{
+    hunks: PatchHunk[];
+    pathsNormalized: boolean;
+}>;
+export declare function createPatchExecutionContext(root: string, patchText: string, worktree?: string): Promise<PatchExecutionContext>;
+export declare function resolvePreparedUpdate(filePath: string, currentText: string, hunk: UpdatePatchHunk, cfg: ApplyPatchRuntimeOptions): ResolvedPreparedUpdate;
+export declare function stageAddedText(contents: string): string;

package/dist/hooks/apply-patch/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ToolExecuteBeforeInput {
+    tool: string;
+    directory?: string;
+}
+interface ToolExecuteBeforeOutput {
+    args?: {
+        patchText?: unknown;
+        [key: string]: unknown;
+    };
+}
+export declare function createApplyPatchHook(ctx: PluginInput): {
+    'tool.execute.before': (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/apply-patch/matching.d.ts

@@ -0,0 +1,18 @@
+import type { LineComparator, RescueResult, SeekHit } from './types';
+export declare function equalExact(a: string, b: string): boolean;
+export declare function equalUnicodeExact(a: string, b: string): boolean;
+export declare function equalTrimEnd(a: string, b: string): boolean;
+export declare function equalUnicodeTrimEnd(a: string, b: string): boolean;
+export declare function equalTrim(a: string, b: string): boolean;
+export declare function equalUnicodeTrim(a: string, b: string): boolean;
+export declare const autoRescueComparators: LineComparator[];
+export declare const permissiveComparators: LineComparator[];
+export declare function seekMatch(lines: string[], pattern: string[], start: number, eof?: boolean): SeekHit | undefined;
+export declare function seek(lines: string[], pattern: string[], start: number, eof?: boolean): number;
+export declare function list(lines: string[], pattern: string[], start: number, same: LineComparator): number[];
+export declare function sameRescueLine(a: string, b: string): boolean;
+export declare function prefix(old_lines: string[], new_lines: string[]): number;
+export declare function suffix(old_lines: string[], new_lines: string[], prefixLength: number): number;
+export declare function rescueByPrefixSuffix(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;
+export declare function score(a: string[], b: string[]): number;
+export declare function rescueByLcs(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;

package/dist/hooks/apply-patch/operations.d.ts

@@ -0,0 +1,3 @@
+export { parseValidatedPatch } from './execution-context';
+export { applyPreparedChanges, preparePatchChanges } from './prepared-changes';
+export { rewritePatch, rewritePatchText } from './rewrite';

package/dist/hooks/apply-patch/patch.d.ts

@@ -0,0 +1,2 @@
+export { parsePatch } from './codec';
+export { preparePatchChanges, rewritePatch, rewritePatchText, } from './operations';

package/dist/hooks/apply-patch/prepared-changes.d.ts

@@ -0,0 +1,17 @@
+import type { ApplyPatchRuntimeOptions, PreparedChange } from './types';
+export declare function preparePatchChanges(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<PreparedChange[]>;
+/**
+ * Internal best-effort helper that applies the output of
+ * `preparePatchChanges()`: it snapshots all touched paths first and uses
+ * temp + rename for writes to regular files. It is not a universal multi-file
+ * transaction and is not perfect against concurrent external interference,
+ * but it avoids leaving silent partial states on normal apply failures.
+ *
+ * Contract: although it is exported for local tests/helpers, its expected
+ * input is the already prepared output of `preparePatchChanges()`. If it
+ * receives manual arrays, it revalidates the basic shape
+ * (types/text/normalized absolute paths) and filesystem invariants: it
+ * rejects updates/deletes/moves whose source does not exist, and add/move
+ * operations whose destination is already occupied.
+ */
+export declare function applyPreparedChanges(changes: PreparedChange[]): Promise<void>;

package/dist/hooks/apply-patch/resolution.d.ts

@@ -0,0 +1,19 @@
+import type { ApplyPatchRuntimeOptions, MatchHit, PatchChunk, ResolvedChunk } from './types';
+export declare function readFileLines(file: string): Promise<string[]>;
+export declare function resolveChunkStart(lines: string[], chunk: PatchChunk, start: number): number;
+export declare function locateChunk(lines: string[], file: string, chunk: PatchChunk, start: number, cfg: ApplyPatchRuntimeOptions): ResolvedChunk;
+export declare function applyHits(lines: string[], hits: MatchHit[], eol?: '\n' | '\r\n', hasFinalNewline?: boolean): string;
+export declare function resolveUpdateChunks(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<{
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+}>;
+export declare function deriveNewContentFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): string;
+export declare function resolveUpdateChunksFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): {
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+};
+export declare function deriveNewContent(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<string>;

package/dist/hooks/apply-patch/rewrite.d.ts

@@ -0,0 +1,10 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export type RewritePatchResult = {
+    patchText: string;
+    changed: boolean;
+    rewrittenChunks: number;
+    totalChunks: number;
+    rewriteModes: string[];
+};
+export declare function rewritePatch(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<RewritePatchResult>;
+export declare function rewritePatchText(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<string>;

package/dist/hooks/apply-patch/test-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export declare const DEFAULT_OPTIONS: ApplyPatchRuntimeOptions;
+export declare function createTempDir(prefix?: string): Promise<string>;
+export declare function writeFixture(root: string, relativePath: string, contents: string): Promise<void>;
+export declare function readText(root: string, relativePath: string): Promise<string>;
+export declare function applyPatch(root: string, patchText: string, cfg?: ApplyPatchRuntimeOptions): Promise<void>;

package/dist/hooks/apply-patch/types.d.ts

@@ -0,0 +1,80 @@
+export type ApplyPatchRuntimeOptions = {
+    prefixSuffix: boolean;
+    lcsRescue: boolean;
+};
+export type ApplyPatchErrorKind = 'blocked' | 'validation' | 'verification' | 'internal';
+export type ApplyPatchErrorCode = 'malformed_patch' | 'outside_workspace' | 'verification_failed' | 'internal_unexpected';
+export type ApplyPatchRescueStrategy = 'prefix/suffix' | 'lcs' | 'anchor';
+export type MatchComparatorName = 'exact' | 'unicode' | 'trim-end' | 'unicode-trim-end' | 'trim' | 'unicode-trim';
+export type PatchChunk = {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+};
+export type AddPatchHunk = {
+    type: 'add';
+    path: string;
+    contents: string;
+};
+export type DeletePatchHunk = {
+    type: 'delete';
+    path: string;
+};
+export type UpdatePatchHunk = {
+    type: 'update';
+    path: string;
+    move_path?: string;
+    chunks: PatchChunk[];
+};
+export type PatchHunk = AddPatchHunk | DeletePatchHunk | UpdatePatchHunk;
+export type ParsedPatch = {
+    hunks: PatchHunk[];
+};
+export type AddPreparedChange = {
+    type: 'add';
+    file: string;
+    text: string;
+};
+export type DeletePreparedChange = {
+    type: 'delete';
+    file: string;
+};
+export type UpdatePreparedChange = {
+    type: 'update';
+    file: string;
+    move?: string;
+    text: string;
+};
+export type PreparedChange = AddPreparedChange | DeletePreparedChange | UpdatePreparedChange;
+export type MatchHit = {
+    start: number;
+    del: number;
+    add: string[];
+};
+export type SeekHit = {
+    index: number;
+    comparator: MatchComparatorName;
+    exact: boolean;
+};
+export type ResolvedChunk = {
+    hit: MatchHit;
+    old_lines: string[];
+    canonical_old_lines: string[];
+    canonical_new_lines: string[];
+    canonical_change_context?: string;
+    resolved_is_end_of_file: boolean;
+    rewritten: boolean;
+    strategy?: ApplyPatchRescueStrategy;
+    matchComparator?: MatchComparatorName;
+};
+export type RescueResult = {
+    kind: 'miss';
+} | {
+    kind: 'ambiguous';
+    phase: 'prefix_suffix' | 'lcs';
+} | {
+    kind: 'match';
+    hit: MatchHit;
+};
+export type LineComparator = (a: string, b: string) => boolean;

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
+export { createApplyPatchHook } from './apply-patch';
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
 export { createChatHeadersHook } from './chat-headers';

package/dist/hooks/post-file-tool-nudge/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Post-tool nudge - appends a delegation reminder after file reads/writes.
+ * Post-tool nudge - queues a delegation reminder after file reads/writes.
  * Catches the "inspect/edit files → implement myself" anti-pattern.
  */
 interface ToolExecuteAfterInput {
@@ -7,12 +7,29 @@ interface ToolExecuteAfterInput {
     sessionID?: string;
     callID?: string;
 }
-interface ToolExecuteAfterOutput {
-    title: string;
-    output: string;
-    metadata: Record<string, unknown>;
+interface ChatSystemTransformInput {
+    sessionID?: string;
+}
+interface ChatSystemTransformOutput {
+    system: string[];
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: {
+            info?: {
+                id?: string;
+            };
+            sessionID?: string;
+        };
+    };
+}
+interface PostFileToolNudgeOptions {
+    shouldInject?: (sessionID: string) => boolean;
 }
-export declare function createPostFileToolNudgeHook(): {
-    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+export declare function createPostFileToolNudgeHook(options?: PostFileToolNudgeOptions): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, _output: unknown) => Promise<void>;
+    'experimental.chat.system.transform': (input: ChatSystemTransformInput, output: ChatSystemTransformOutput) => Promise<void>;
+    event: (input: EventInput) => Promise<void>;
 };
 export {};

package/dist/hooks/todo-continuation/index.d.ts

@@ -12,6 +12,10 @@ export declare function createTodoContinuationHook(ctx: PluginInput, config?: {
             properties?: Record<string, unknown>;
         };
     }) => Promise<void>;
+    handleChatMessage: (input: {
+        sessionID: string;
+        agent?: string;
+    }) => void;
     handleCommandExecuteBefore: (input: {
         command: string;
         sessionID: string;