pi-ghost-autocomplete 0.9.1 → 0.11.0

package/dist/providers/openai-compat-provider.d.ts

@@ -25,6 +25,10 @@ export declare class OpenAICompatProvider implements GhostProvider {
     readonly name: string;
     /** Why the most recent `fireOne` resolved empty; consumed by the editor. */
     private lastEmptyReason;
+    /** Snapshot of `PI_GHOST_FIM_CONTEXT_ALL_INTENTS`, read once at construction
+     *  instead of per `predict` (#3 — `buildFIMPrompt` previously read
+     *  `process.env` on every prediction). */
+    private readonly fimContextAllIntentsRaw;
     constructor(config: OpenAICompatProviderConfig);
     get debounceMs(): number;
     /**
@@ -66,7 +70,7 @@ export declare function fimContextIncluded(intent: PromptIntent | undefined, all
  * `question` intents, where the context is dropped to avoid the empty-rate
  * spike described on {@link FIM_CONTEXT_SUPPRESSED_INTENTS}.
  */
-export declare function buildFIMPrompt(req: GhostRequest, maxRecent: number): {
+export declare function buildFIMPrompt(req: GhostRequest, maxRecent: number, fimContextAllIntentsRaw?: string): {
     prompt: string;
     suffix: string;
 };

package/dist/providers/pi-model-provider.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { EmptyReason } from "../metrics.js";
+import type { PiModelProviderConfig } from "../config.js";
+import { type GhostProvider, type GhostRequest, type StreamDelta } from "./types.js";
+/**
+ * Pi-registry backend: complete through the session's own `ModelRegistry`.
+ *
+ * Unlike {@link CloudProvider} — which can only resolve models from pi-ai's
+ * *static builtin* catalog and must hand-resolve auth (skipping registries
+ * with a custom `baseUrl`) — this backend delegates both concerns to pi:
+ *
+ *  - **Model resolution** via `registry.find(provider, id)` / first match in
+ *    `registry.getAvailable()`. Works for dynamic providers (e.g. "radius")
+ *    and any model registered by other extensions, none of which exist in
+ *    the static catalog.
+ *  - **Auth + endpoint** via `registry.complete()`, which resolves
+ *    request-time auth (models.json keys, stored credentials, OAuth) and the
+ *    provider's real `baseUrl` exactly as the main agent sees them
+ *    (`ModelRuntime.prepareRequest`). No ghost API key needed.
+ *
+ * Available on pi 0.84+; streaming additionally requires 0.99's
+ * `registry.stream` (feature-detected, falls back to the pipeline's
+ * non-streaming `predict()` path on 0.84).
+ */
+export declare class PiModelProvider implements GhostProvider {
+    readonly name: string;
+    private readonly registry;
+    private readonly config;
+    private readonly streamFn;
+    private resolved;
+    private resolvedSpec;
+    private lastEmpty;
+    /**
+     * Streaming variant — attached in the constructor **only** when the
+     * registry exposes `stream()` (pi ≥ 0.99). The request pipeline selects
+     * the streaming path whenever `predictStream` is present, so a class
+     * method would make every host look streaming-capable and silently starve
+     * pi 0.84–0.98 of ghosts instead of falling back to `predict()`.
+     */
+    predictStream?: (req: GhostRequest) => AsyncIterable<StreamDelta>;
+    constructor(config: PiModelProviderConfig, registry: ModelRegistry);
+    get debounceMs(): number;
+    consumeLastEmptyReason(): EmptyReason | null;
+    /**
+     * Resolve `modelSpec` (`"provider/model-id"` or bare `"model-id"`) to a
+     * registry model. Successful lookups are cached per spec; failures retry
+     * on the next call (the registry may still be loading models.json early
+     * in a session, and a failed scan of the model list is cheap).
+     */
+    private resolveModel;
+    /**
+     * One completion through the registry. Auth, headers, and endpoint are
+     * resolved by pi at request time; we only supply sampling knobs, the
+     * abort signal, and the SEC-3 timeout.
+     */
+    predict(req: GhostRequest): Promise<string | null>;
+    /**
+     * Streaming implementation behind the conditionally-attached
+     * {@link predictStream} — only reachable when the registry exposes
+     * `stream()` (pi ≥ 0.99; see {@link StreamingRegistry}). Mirrors
+     * {@link CloudProvider.predictStream}: sanitize once on the final
+     * assembled text, never per delta.
+     */
+    private streamPredict;
+    /**
+     * Preflight for /ghost diagnostics and router chat-leg warnings: resolves
+     * the spec and (when the registry supports it) checks that the model's
+     * provider has configured auth.
+     */
+    preflight(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}

package/dist/providers/race.d.ts

@@ -41,6 +41,17 @@ export declare class RaceProvider implements GhostProvider {
         wins: number;
         skipRemaining: number;
     }>;
+    /**
+     * Skip-penalty filter (PRD §M8). Drop members still under a skip penalty,
+     * decrementing their counter and recording them in `skipped` so metrics can
+     * attribute the skip. If ALL members are skipped, fall back to running them
+     * anyway so the weighting policy can't permanently starve the user.
+     *
+     * In the all-skipped fallback the returned array is `this.members`, but
+     * `skipRemaining` has already been decremented for everyone — they execute
+     * regardless, which prevents starvation when every member is flagged slow.
+     */
+    private filterSkippedMembers;
     get debounceMs(): number;
     consumeLastTrace(): RaceTrace | null;
     /**

package/dist/providers/router.d.ts

@@ -42,6 +42,11 @@ export declare class RouterProvider implements GhostProvider {
     /** Leg that served the most recent request — the one to query for the
      *  empty-cause diagnostic so it reflects the register that actually ran. */
     private lastLeg;
+    /** Register-debounce multipliers snapshotted once at construction instead
+     *  of re-read per `debounceMsFor` (#3 — `debounceProseMult`/
+     *  `debounceAgentMult` previously read `process.env` on every dispatch). */
+    private readonly proseMult;
+    private readonly agentMult;
     constructor(fim: GhostProvider, chat: GhostProvider | null);
     get debounceMs(): number;
     /**

package/dist/recent-paths.d.ts

@@ -26,3 +26,34 @@ export declare function recentBoost(matchPath: string, recent: Set<string> | nul
  * assistant messages. Oldest-first.
  */
 export declare function getRoleWeightedRecent(ctx: ExtensionContext, userMax: number, assistantMax: number): RecentMessage[];
+/** How long a tool-touched path keeps its ranking boost. */
+export declare const TOOL_PATH_TTL_MS: number;
+/** Bound on live tool paths kept for boosting. */
+export declare const MAX_TOOL_PATHS = 32;
+/**
+ * Normalize a `read`/`edit`/`write` tool-input path so it string-matches
+ * PathIndex entries (git ls-files output: POSIX separators, root-relative).
+ *
+ * - Backslashes → forward slashes (Windows tool inputs).
+ * - Absolute paths inside `root` → root-relative.
+ * - Leading `./` stripped.
+ *
+ * Paths outside `root` (or when `root` is null) pass through normalized —
+ * they simply won't exact-hit an index entry and only degrade the boost.
+ */
+export declare function normalizeToolPath(raw: string, root: string | null): string;
+/**
+ * Merge regex-scraped mention paths with live tool-recorded paths.
+ * Tool entries survive the scrape TTL (5 s) — they are exact inputs, not
+ * text guesses — and are pruned only by their own {@link TOOL_PATH_TTL_MS}.
+ */
+export declare function mergeRecentPathSets(scraped: Set<string>, toolPaths: Map<string, number>, now: number, ttlMs?: number): Set<string>;
+/**
+ * Re-key recorded tool paths against a (possibly late-arriving) index
+ * root. The PathIndex is built asynchronously after the editor installs;
+ * tool results that land before it settles were normalized with
+ * `root === null` and may be absolute. Renormalizing against the real
+ * root makes them string-match the git ls-files keys. Collisions keep
+ * the newest timestamp.
+ */
+export declare function renormalizeToolPaths(toolPaths: Map<string, number>, root: string): Map<string, number>;