opencode-swarm 7.114.9 → 7.115.0

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

@@ -7,6 +7,17 @@
  * Pure TypeScript, no shell/git/external binaries, standard node:fs sync I/O.
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { loadPluginConfigWithMeta } from '../config';
+/**
+ * DI seam for hermetic config-load substitution in tests (AGENTS.md invariant 7).
+ * Mirrors the pattern at `src/tools/context-status.ts:81-88`. Tests override
+ * `_internals.loadPluginConfigWithMeta` and restore it in `afterEach` instead
+ * of writing real config files or using `mock.module` (which leaks across
+ * test files in Bun's shared runner).
+ */
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+};
 /** Per-file error detail in the structured output. */
 export interface ApplyPatchFileError {
     hunkIndex: number;
@@ -45,6 +56,16 @@ export interface ApplyPatchArgs {
     allowCreates?: boolean;
     allowDeletes?: boolean;
 }
+/**
+ * Opt-in fuzzy-matching options threaded from `execute` → `processFileDiff`
+ * → `applyHunks`. Both flags default false (exact-match-only, B3 decision).
+ */
+export interface ApplyHunksOptions {
+    /** Enable fuzzy fallback (strategies 1-8) on exact-match failure. */
+    fuzzyMatch: boolean;
+    /** Additionally enable strategy 9 (context_aware). Only effective with fuzzyMatch. */
+    fuzzyMatchContextAware: boolean;
+}
 /**
  * Swarm unified-diff patch tool (formerly registered as apply_patch).
  * Renamed to swarm_apply_patch so it no longer shadows the native opencode

package/dist/utils/fuzzy-match.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Fuzzy text-matching engine — faithful TypeScript port of hermes-agent's
+ * `tools/fuzzy_match.py` (issue #1718).
+ *
+ * Implements a 9-strategy matching chain that finds and replaces text,
+ * tolerating the whitespace, indentation, escape-sequence, and Unicode
+ * drift common in LLM-generated patches. Integrated into `apply-patch`
+ * as an **opt-in fallback** (default off) gated by the `apply_patch.fuzzy_match`
+ * and `apply_patch.fuzzy_match_context_aware` config flags.
+ *
+ * Porting conventions:
+ * - Operates on **UTF-16 code units** consistently (`s[i]`, `s.length`).
+ *   Matches `src/utils/sequence-matcher.ts`. Round-trip safe.
+ * - Per-line stripping uses JS `String.prototype.trim()`, which strips the
+ *   Unicode WhiteSpace + LineTerminator set. Coincides with Python
+ *   `str.strip()` for the ASCII/BMP content in the test suite; minor
+ *   divergence on exotic whitespace categories is acceptable.
+ * - Strategy 9 (`contextAware`) is opt-in via the `includeContextAware`
+ *   option to `fuzzyFindAndReplace`. It is the loosest, most-false-positive-
+ *   prone strategy and is separately gated in apply-patch by
+ *   `apply_patch.fuzzy_match_context_aware`.
+ */
+/** A `[start, end)` character span in the content string. */
+type Span = [number, number];
+/** Result of {@link fuzzyFindAndReplace}. */
+export interface FuzzyResult {
+    /** Modified content on success; original content on failure. */
+    content: string;
+    /** Number of replacements made (0 on failure). */
+    matchCount: number;
+    /** Name of the strategy that matched, or `null` on failure. */
+    strategy: string | null;
+    /** `null` on success; an error description on failure. */
+    error: string | null;
+}
+/** Options for {@link fuzzyFindAndReplace}. */
+export interface FuzzyOptions {
+    /**
+     * When true (default at the utility level), the `context_aware` strategy
+     * (9) is included in the chain. Strategy 9 is the loosest/most-false-
+     * positive-prone strategy (requires 50% of lines to reach 0.80 per-line
+     * similarity) and has quadratic cost, so it is bounded by an internal
+     * cell-count cap.
+     *
+     * **Default divergence (intentional):** the utility defaults this to
+     * `true` so the byte-faithful ported hermes test suite passes unmodified
+     * (strategy 9 is a legitimate part of the matching chain and some test
+     * cases depend on it). The `apply-patch` integration — the only consumer
+     * today — explicitly passes `false` unless the separate
+     * `apply_patch.fuzzy_match_context_aware` config flag is set, honoring
+     * issue #1718's Non-Goal "do not port strategy 9 as default-on" at the
+     * integration layer. New callers should pass `false` unless they
+     * specifically want strategy 9.
+     */
+    includeContextAware?: boolean;
+}
+/**
+ * Maps Unicode typographic characters to their ASCII equivalents.
+ * Some replacements EXPAND a single code point into multiple ASCII chars
+ * (em-dash → "--", ellipsis → "..."); the position-remap helpers handle the
+ * resulting offset divergence.
+ */
+export declare const UNICODE_MAP: Record<string, string>;
+/** Normalize Unicode typographic characters to ASCII equivalents. */
+export declare function unicodeNormalize(text: string): string;
+/**
+ * Find and replace text using a chain of increasingly fuzzy strategies.
+ *
+ * Strategies are tried in order; the first that yields matches wins. On a
+ * unique match (or when `replaceAll` is true), the replacement is applied.
+ * On failure, returns the original content with an error description.
+ *
+ * Guards (ported verbatim from hermes):
+ * - Ambiguity: `>1 match && !replaceAll` → fail with a helpful message.
+ * - Escape-drift: `\'`/`\"` present in both old+new but absent from the
+ *   matched file region → block (transport serialization artifact).
+ * - Selective unescape: `\t`/`\r` in new_string → real bytes only when the
+ *   matched file region contains the corresponding control char. `\n` excluded.
+ * - Unicode preservation: under strategy 7, unchanged spans keep the file's
+ *   original Unicode characters rather than the ASCII-normalized equivalents.
+ */
+export declare function fuzzyFindAndReplace(content: string, oldString: string, newString: string, replaceAll?: boolean, options?: FuzzyOptions): FuzzyResult;
+/** Strategy 1: exact string match, non-overlapping. */
+export declare function strategyExact(content: string, pattern: string): Span[];
+/** Strategy 2: per-line `.trim()` + block equality. */
+export declare function strategyLineTrimmed(content: string, pattern: string): Span[];
+/** Strategy 3: collapse `[ \t]+` → single space, preserve newlines. */
+export declare function strategyWhitespaceNormalized(content: string, pattern: string): Span[];
+/** Strategy 4: strip all leading whitespace per line (lstrip). */
+export declare function strategyIndentationFlexible(content: string, pattern: string): Span[];
+/** Strategy 5: unescape `\n`/`\t`/`\r` literals → bytes, then exact match. */
+export declare function strategyEscapeNormalized(content: string, pattern: string): Span[];
+/** Strategy 6: trim only first and last lines, sliding window. */
+export declare function strategyTrimmedBoundary(content: string, pattern: string): Span[];
+/** Strategy 7: Unicode normalization (smart quotes, em/en dash, ellipsis, NBSP). */
+export declare function strategyUnicodeNormalized(content: string, pattern: string): Span[];
+/** Strategy 8: anchor on first+last lines, similarity for the middle. */
+export declare function strategyBlockAnchor(content: string, pattern: string): Span[];
+export declare function strategyContextAware(content: string, pattern: string): Span[];
+/**
+ * Find lines in `content` most similar to `oldString` for "did you mean?" feedback.
+ *
+ * Returns a formatted string showing the closest matching lines with context
+ * and line numbers, or `''` if no useful match is found.
+ */
+export declare function findClosestLines(oldString: string, content: string, contextLines?: number, maxResults?: number): string;
+/**
+ * Return a "Did you mean..." snippet for plain no-match errors.
+ *
+ * Gated so the hint only fires for actual "old_string not found" failures.
+ * Ambiguous-match, escape-drift, and identical-strings errors all have
+ * `matchCount === 0` but a did-you-mean snippet would be misleading.
+ */
+export declare function formatNoMatchHint(error: string | null, matchCount: number, oldString: string, content: string): string;
+export {};

package/dist/utils/sequence-matcher.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Faithful TypeScript port of CPython's `difflib.SequenceMatcher`.
+ *
+ * Implements the Ratcliff/Obershelp pattern-matching algorithm with the
+ * "popular element" (autojunk) guard, so that `.ratio()` produces values
+ * identical to CPython 3.x for the BMP character content used by the
+ * fuzzy-match strategies. The thresholds in `src/utils/fuzzy-match.ts`
+ * (0.50 / 0.70 / 0.80) were tuned against CPython's exact `2*M/T` ratio
+ * formula, so substituting a Levenshtein-based library would silently
+ * break those thresholds.
+ *
+ * Porting notes:
+ * - Operates on **UTF-16 code units** (`s[i]`, `s.length`, `s.charCodeAt(i)`)
+ *   consistently throughout. CPython operates on Unicode code points; for
+ *   ASCII/BMP content the two coincide. Astral-plane characters (emoji)
+ *   consume two UTF-16 units, so ratios for emoji-heavy input may differ
+ *   marginally from CPython. This is acceptable for the fuzzy-match use
+ *   case (source-code patches) and is round-trip-safe — no index mixing,
+ *   no file corruption.
+ * - `autojunk` defaults to `true`, matching CPython. When `b.length >= 200`
+ *   and an element appears more than 1% of the time in `b`, it is treated
+ *   as "popular" and excluded as an anchor candidate in `find_longest_match`.
+ *   This is essential for ratio fidelity on real file sections.
+ */
+export interface Match {
+    /** Start index in sequence `a`. */
+    a: number;
+    /** Start index in sequence `b`. */
+    b: number;
+    /** Length of the matching block. */
+    size: number;
+}
+export type OpcodeTag = 'equal' | 'replace' | 'delete' | 'insert';
+export interface Opcode {
+    tag: OpcodeTag;
+    i1: number;
+    i2: number;
+    j1: number;
+    j2: number;
+}
+/** A predicate that marks a character as "junk" (never a sync point). */
+export type IsJunk = ((ch: string) => boolean) | null;
+/**
+ * Difflib-compatible sequence matcher. Construct with two strings, then
+ * call `.ratio()`, `.get_matching_blocks()`, or `.get_opcodes()`.
+ */
+export declare class SequenceMatcher {
+    private a;
+    private b;
+    private isJunk;
+    private autoJunk;
+    private b2j;
+    private popularSet;
+    private matchingBlocks;
+    constructor(isJunk: IsJunk, a: string, b: string, autoJunk?: boolean);
+    /** Allow changing the input sequences (mirrors CPython `set_seqs`/`set_seq2`). */
+    setSeqs(a: string, b: string): void;
+    /** Precompute the `b` index map and the popular-element set. */
+    private chainB;
+    /**
+     * Find the longest matching block in `a[alo:ahi]` and `b[blo:bhi]`.
+     *
+     * Returns `{ a, b, size }` where `size` is maximal; ties are broken by
+     * smallest `a`, then smallest `b` (CPython canonical tiebreak).
+     *
+     * A "match" means `a[i] === b[j]` and the run extends as far as possible.
+     * Elements in the popular set are only used as anchor candidates when no
+     * non-popular match exists (CPython behavior: popular elements are
+     * excluded from `b2j`, so they only match opportunistically via the
+     * extending run after a non-popular anchor).
+     */
+    findLongestMatch(alo: number, ahi: number, blo: number, bhi: number): Match;
+    /** Recursively compute the list of matching blocks (descending order). */
+    getMatchingBlocks(): Match[];
+    /**
+     * Return a float in [0, 1]: `2*M / T`, where `M` is the total matched
+     * characters and `T` is the sum of the two sequence lengths.
+     * Returns `1.0` when both sequences are empty (matches CPython).
+     */
+    ratio(): number;
+    /** Compute the opcodes describing how to turn `a` into `b`. */
+    getOpcodes(): Opcode[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.114.9",
+	"version": "7.115.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",