@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/core/edits/format-detector.js

@@ -0,0 +1,260 @@
+/**
+ * Edit-format auto-select (PUGI-79).
+ *
+ * The 4-layer diff dispatcher (Layer A single-block, B ordered batch,
+ * C sha256-gated rewrite, D AST-aware) is layer-agnostic at the wire
+ * — the model emits whichever marker family it was prompted with, and
+ * `dispatch.ts` routes per envelope. Empirically though, different
+ * model families have markedly different success rates per layer:
+ *
+ *   - Anthropic Claude family — native function-calling shape;
+ *     produces clean single-block Layer A edits with high recall
+ *     against `+++ NEW / --- OLD / ===` markers.
+ *   - Open-weight Qwen3 / Kimi / DeepSeek — historically stronger
+ *     with whole-file Layer C rewrites OR sha256-gated patches; the
+ *     conflict-marker (Gemini-style) Layer A surface has higher
+ *     ambiguity rates on these models.
+ *   - DeepSeek-coder family — anchors well on Layer C primary with
+ *     Layer A as fallback (their RLHF set leaned hard on patch-style
+ *     emit).
+ *   - Reasoning models (o-series, gpt-5) — handle Layer D AST-aware
+ *     operations when an LSP bridge is available; Layer C primary
+ *     otherwise.
+ *
+ * The existing `format-matrix.ts` keyed exact slugs only — fine for
+ * the canonical set but blind to vendor-prefixed slugs that come back
+ * from the Anvil gateway (e.g. `anthropic/claude-sonnet-4-20250514`,
+ * `qwen/qwen3-coder`, `deepseek/deepseek-chat-v3.1`). This detector
+ * layers ON TOP of the matrix:
+ *
+ *   1. exact-key match against `EDIT_FORMAT_MATRIX` — wins outright.
+ *   2. vendor-prefix strip → second exact-key probe (so
+ *      `anthropic/claude-sonnet-4-6` resolves the same as `claude-sonnet-4-6`).
+ *   3. family inference from the (possibly prefixed) slug — returns
+ *      the family-default chain (see `FAMILY_DEFAULTS`).
+ *   4. unknown — wildcard `*` from the matrix.
+ *
+ * The output is the same `EditFormatChain` shape the matrix already
+ * exposes so callers (dispatcher hint, persona prompt hint) consume a
+ * single contract.
+ *
+ * NOT a routing decision: the dispatcher's per-layer routing is still
+ * driven by what the model actually emits. The detector's output is a
+ * HINT — surfaced to the persona prompt so the model has the right
+ * marker template loaded, and surfaced to the dispatcher's fuzzy ladder
+ * / fallback ordering so an ambiguous response gets retried in an order
+ * that matches the model's empirical strengths.
+ *
+ * Spec: this is the PUGI-79 implementation; the issue ships the
+ * detector + dispatcher hint + persona hint together.
+ */
+import { EDIT_FORMAT_MATRIX, } from './format-matrix.js';
+/**
+ * Family-level default chains. These are deliberately CONSERVATIVE —
+ * each family's primary is the layer with the highest observed apply-
+ * rate across the 2026-05 dogfood corpus; fallbacks rank in observed
+ * success order. The exact-slug entries in `EDIT_FORMAT_MATRIX` can
+ * override per-model; family defaults are the floor.
+ *
+ * Anthropic:
+ *   The Anvil corpus shows Claude family hitting ~95% Layer A apply on
+ *   first try; Layer C is the rescue when the file is large enough
+ *   that the operator's region selection ambiguates. Matrix entries
+ *   for `claude-opus-4-7` + `claude-sonnet-4-6` override to Layer C
+ *   primary because the larger context windows let those models hold
+ *   the whole file comfortably.
+ *
+ * Open-weight (qwen / deepseek / kimi):
+ *   These ship whole-file rewrites more reliably than partial diffs —
+ *   the patch-style envelopes their fine-tune sets prefer match Layer
+ *   C semantics. Layer A is the fallback because they can still emit
+ *   sensible search/replace pairs when prompted explicitly.
+ *
+ * Reasoning (gpt-5 / o-series):
+ *   Layer C primary because the longer reasoning trace burns through
+ *   the partial-diff format's positional constraints. Layer D rides
+ *   the wire when an LSP is bridged; the matrix entries override per-
+ *   model when that's available (see `qwen3-coder-480b → D`).
+ *
+ * Unknown:
+ *   Defers to the wildcard chain from the matrix (Layer A primary).
+ */
+const FAMILY_DEFAULTS = {
+    anthropic: { primary: 'A', fallback: ['C', 'B'] },
+    openai: { primary: 'C', fallback: ['A', 'B'] },
+    gemini: { primary: 'A', fallback: ['C', 'B'] },
+    qwen: { primary: 'A', fallback: ['C', 'B'] },
+    deepseek: { primary: 'C', fallback: ['A', 'B'] },
+    kimi: { primary: 'C', fallback: ['A', 'B'] },
+    unknown: { primary: 'A', fallback: ['B', 'C'] },
+};
+/**
+ * Detect the model family from a slug. Handles vendor-prefixed forms
+ * (`<vendor>/<model>` and `<provider>:<model>`) plus bare-name forms.
+ * Case-insensitive on the family name; case-preserving on the rest.
+ *
+ * Order matters: vendor prefix wins when present (the gateway is
+ * authoritative about which family routed). Otherwise the bare slug
+ * gets prefix-matched against well-known family stems. Unknown slugs
+ * surface as `unknown` — the caller falls back to the matrix wildcard.
+ */
+export function detectModelFamily(modelSlug) {
+    if (!modelSlug)
+        return 'unknown';
+    const raw = modelSlug.trim();
+    if (raw.length === 0)
+        return 'unknown';
+    const lower = raw.toLowerCase();
+    // Vendor-prefix form: `<vendor>/<model>`. The vendor wins outright
+    // because the gateway is authoritative — `anthropic/<anything>`
+    // routes Claude family regardless of the suffix.
+    const slashIdx = lower.indexOf('/');
+    if (slashIdx > 0) {
+        const vendor = lower.slice(0, slashIdx);
+        switch (vendor) {
+            case 'anthropic':
+                return 'anthropic';
+            case 'openai':
+                return 'openai';
+            case 'google':
+            case 'gemini':
+            case 'xai':
+                return 'gemini';
+            case 'qwen':
+            case 'alibaba':
+                return 'qwen';
+            case 'deepseek':
+                return 'deepseek';
+            case 'moonshot':
+            case 'kimi':
+                return 'kimi';
+            default:
+                // Unknown vendor — fall through to bare-name detection on the
+                // suffix. Some gateways (OpenRouter style) put the family
+                // name AFTER the vendor (e.g. `together/qwen-coder`), so the
+                // suffix still carries signal.
+                return detectFamilyFromBareName(lower.slice(slashIdx + 1));
+        }
+    }
+    // Provider-prefix form: `ollama:<model>` (engine-VM local runtime).
+    // The prefix is informational; strip and continue.
+    const colonIdx = lower.indexOf(':');
+    if (colonIdx > 0) {
+        const prefix = lower.slice(0, colonIdx);
+        if (prefix === 'ollama' || prefix === 'lmstudio' || prefix === 'llama-cpp') {
+            return detectFamilyFromBareName(lower.slice(colonIdx + 1));
+        }
+    }
+    return detectFamilyFromBareName(lower);
+}
+/**
+ * Bare-name detector. Lower-case input. Prefix-match against family
+ * stems; longest match wins so `claude-opus-4-7` doesn't accidentally
+ * route through the generic `c*` lane.
+ */
+function detectFamilyFromBareName(name) {
+    if (name.startsWith('claude'))
+        return 'anthropic';
+    if (name.startsWith('gpt') || name.startsWith('o1') || name.startsWith('o3') || name.startsWith('o4')) {
+        return 'openai';
+    }
+    if (name.startsWith('gemini') || name.startsWith('grok'))
+        return 'gemini';
+    if (name.startsWith('qwen'))
+        return 'qwen';
+    if (name.startsWith('deepseek'))
+        return 'deepseek';
+    if (name.startsWith('kimi') || name.startsWith('moonshot'))
+        return 'kimi';
+    return 'unknown';
+}
+/**
+ * Family-default chain. Exported for callers that want the family-
+ * level recommendation without running the full detector pipeline
+ * (e.g. observability surfaces that already resolved the family).
+ */
+export function familyDefaultChain(family) {
+    // Defensive clone: the FAMILY_DEFAULTS table is readonly conceptually
+    // but the EditFormatChain type allows fallback array mutation. Clone
+    // so callers cannot accidentally mutate the table.
+    const base = FAMILY_DEFAULTS[family];
+    return { primary: base.primary, fallback: [...base.fallback] };
+}
+/**
+ * Resolve the preferred edit-format chain for a model slug.
+ *
+ * Resolution order:
+ *   1. Exact slug match in EDIT_FORMAT_MATRIX — overrides everything.
+ *      This lets per-model tuning (e.g. `qwen3-coder-480b → D`) win
+ *      over the family default.
+ *   2. Vendor-prefix strip + exact match — so `anthropic/claude-...`
+ *      resolves to the bare `claude-...` entry when present.
+ *   3. Family inference — `FAMILY_DEFAULTS[detectModelFamily(slug)]`.
+ *   4. Wildcard fallback — `EDIT_FORMAT_MATRIX['*']`.
+ *
+ * The returned chain is always a fresh object so caller mutations
+ * cannot leak back into the matrix.
+ */
+export function detectEditFormat(modelSlug) {
+    const fallbackWildcard = EDIT_FORMAT_MATRIX['*'] ?? { primary: 'A', fallback: [] };
+    if (!modelSlug || modelSlug.trim().length === 0) {
+        return { primary: fallbackWildcard.primary, fallback: [...fallbackWildcard.fallback] };
+    }
+    const raw = modelSlug.trim();
+    // Step 1 — exact match wins.
+    const exact = EDIT_FORMAT_MATRIX[raw];
+    if (exact)
+        return { primary: exact.primary, fallback: [...exact.fallback] };
+    // Step 2 — vendor-prefix strip (e.g. `anthropic/claude-sonnet-4-6`).
+    const slashIdx = raw.indexOf('/');
+    if (slashIdx > 0) {
+        const suffix = raw.slice(slashIdx + 1);
+        const stripped = EDIT_FORMAT_MATRIX[suffix];
+        if (stripped)
+            return { primary: stripped.primary, fallback: [...stripped.fallback] };
+    }
+    // Step 3 — family inference.
+    const family = detectModelFamily(raw);
+    if (family !== 'unknown')
+        return familyDefaultChain(family);
+    // Step 4 — wildcard.
+    return { primary: fallbackWildcard.primary, fallback: [...fallbackWildcard.fallback] };
+}
+/**
+ * Render a one-line marker-format hint for the persona prompt. The
+ * dispatcher already accepts every marker family (anthropic / gemini /
+ * openai), so the hint is preference, not gating — surface the
+ * preferred template + alternative so the model knows which envelope
+ * has the highest apply-rate for its family.
+ *
+ * Returns `null` when the slug is unknown / unset; the caller drops
+ * the hint module on null so the prompt is not polluted with empty
+ * sections.
+ */
+export function renderEditFormatHint(modelSlug) {
+    if (!modelSlug || modelSlug.trim().length === 0)
+        return null;
+    const family = detectModelFamily(modelSlug);
+    if (family === 'unknown')
+        return null;
+    const chain = detectEditFormat(modelSlug);
+    const markerStyle = FAMILY_MARKER_TEMPLATE[family];
+    return `# Edit-format hint (auto-selected for ${family})
+Preferred layer: Layer ${chain.primary}${chain.fallback.length > 0 ? ` (fallback: ${chain.fallback.map((l) => `Layer ${l}`).join(' -> ')})` : ''}.
+Marker template: ${markerStyle}
+The dispatcher accepts any marker family; this hint optimises apply-rate for the resolved model.`;
+}
+/**
+ * Marker template literal per family. Mirrors the three envelopes the
+ * marker-parser accepts; used by `renderEditFormatHint` so the model
+ * sees a concrete shape next to the layer recommendation.
+ */
+const FAMILY_MARKER_TEMPLATE = {
+    anthropic: '+++ NEW <file> / <new contents> / --- OLD <file> / <old contents> / ===',
+    openai: '@@@ REWRITE <file> sha256=<hex> / <full new contents> / @@@ END',
+    gemini: '<<<<<<< SEARCH <file> / <old> / ======= / <new> / >>>>>>> REPLACE',
+    qwen: '<<<<<<< SEARCH <file> / <old> / ======= / <new> / >>>>>>> REPLACE',
+    deepseek: '@@@ REWRITE <file> sha256=<hex> / <full new contents> / @@@ END',
+    kimi: '@@@ REWRITE <file> sha256=<hex> / <full new contents> / @@@ END',
+};
+//# sourceMappingURL=format-detector.js.map

package/dist/core/edits/format-matrix.js

@@ -0,0 +1,26 @@
+export const EDIT_FORMAT_MATRIX = {
+    'claude-opus-4-7': { primary: 'C', fallback: ['A', 'B'] },
+    'claude-sonnet-4-6': { primary: 'C', fallback: ['A', 'B'] },
+    'claude-haiku-4-5': { primary: 'A', fallback: ['B'] },
+    'gpt-5': { primary: 'C', fallback: ['A'] },
+    'gpt-5-mini': { primary: 'A', fallback: ['B'] },
+    'deepseek-v4-pro': { primary: 'A', fallback: ['B', 'C'] },
+    'deepseek-coder-v2': { primary: 'A', fallback: ['B'] },
+    'qwen3-coder-480b': { primary: 'D', fallback: ['A', 'B'] },
+    'qwen3:0.6b': { primary: 'A', fallback: [] },
+    'gemini-2.5-pro': { primary: 'C', fallback: ['A'] },
+    'gemini-2.0-flash': { primary: 'A', fallback: ['B'] },
+    'ollama:qwen3-coder:30b': { primary: 'A', fallback: ['B'] },
+    '*': { primary: 'A', fallback: ['B', 'C'] },
+};
+export function pickEditFormat(model, fileSize, isLSPAvailable = () => false) {
+    const chain = EDIT_FORMAT_MATRIX[model] ?? EDIT_FORMAT_MATRIX['*'] ?? { primary: 'A', fallback: [] };
+    if (chain.primary === 'C' && fileSize > 4000) {
+        return { primary: 'A', fallback: ['B'] };
+    }
+    if (chain.primary === 'D' && !isLSPAvailable()) {
+        return { primary: chain.fallback[0] ?? 'A', fallback: chain.fallback.slice(1) };
+    }
+    return chain;
+}
+//# sourceMappingURL=format-matrix.js.map