opencode-rag-plugin 1.15.1 → 1.17.2

package/dist/core/manifest.d.ts

@@ -2,6 +2,7 @@
  * @fileoverview File hash manifest for tracking indexing state across sessions.
  * Provides load/save with atomic writes, schema versioning, and corruption detection.
  */
+import type { RagConfig } from "./config.js";
 /** Metadata entry for a single indexed file. */
 export interface ManifestEntry {
     /** SHA-256 hash of the file content. */
@@ -16,9 +17,22 @@ export interface ManifestEntry {
     size?: number;
     /** Whether the description generation step failed for this file. */
     descriptionFailed?: boolean;
+    /**
+     * Hash of the description config (provider, model, baseUrl, prompts) that
+     * was active when descriptions were generated for this file.  Skipped when
+     * no description provider is configured.  Used to avoid re-describing
+     * files whose source content and description config are both unchanged.
+     */
+    descHash?: string;
 }
 /** Current schema version for manifest files. */
-export declare const SCHEMA_VERSION = 1;
+export declare const SCHEMA_VERSION = 3;
+/**
+ * Oldest schema version still accepted as valid.
+ * Bumping this intentionally marks older manifests corrupt and forces a
+ * rebuild, so only raise it when a migration is not practical.
+ */
+export declare const MIN_SUPPORTED_SCHEMA_VERSION = 3;
 /** Persistent manifest tracking indexing state across sessions. */
 export interface FileManifest {
     /** Unix timestamp of the last full index pass. */
@@ -49,6 +63,15 @@ export declare function manifestPathFor(dbPath: string): string;
 export declare function normalizeFilePath(filePath: string): string;
 /** Compute the SHA-256 hex hash of a string. */
 export declare function computeFileHash(content: string): string;
+/**
+ * Compute a hash of the description configuration (provider, model, baseUrl,
+ * systemPrompt, image prompt, etc.) so that files are only re-described when
+ * the config actually changes.
+ *
+ * Returns `undefined` when neither `description` nor `imageDescription` is
+ * configured — callers treat this as "no descriptions needed".
+ */
+export declare function computeDescriptionConfigHash(config: RagConfig): string | undefined;
 /** Load a manifest from disk, handling missing or corrupt files gracefully. */
 export declare function loadManifest(dbPath: string): Promise<LoadedManifest>;
 /** Persist a manifest to disk with atomic write (temp file + rename, with Windows fallback). */

package/dist/core/manifest.js

@@ -6,7 +6,13 @@ import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 /** Current schema version for manifest files. */
-export const SCHEMA_VERSION = 1;
+export const SCHEMA_VERSION = 3;
+/**
+ * Oldest schema version still accepted as valid.
+ * Bumping this intentionally marks older manifests corrupt and forces a
+ * rebuild, so only raise it when a migration is not practical.
+ */
+export const MIN_SUPPORTED_SCHEMA_VERSION = 3;
 /** Create a new empty manifest with the current schema version. */
 export function createEmptyManifest() {
     return { files: {}, schemaVersion: SCHEMA_VERSION };
@@ -23,6 +29,30 @@ export function normalizeFilePath(filePath) {
 export function computeFileHash(content) {
     return createHash("sha256").update(content).digest("hex");
 }
+/**
+ * Compute a hash of the description configuration (provider, model, baseUrl,
+ * systemPrompt, image prompt, etc.) so that files are only re-described when
+ * the config actually changes.
+ *
+ * Returns `undefined` when neither `description` nor `imageDescription` is
+ * configured — callers treat this as "no descriptions needed".
+ */
+export function computeDescriptionConfigHash(config) {
+    const desc = config.description;
+    const img = config.imageDescription;
+    if (!desc && !img)
+        return undefined;
+    const parts = [];
+    if (desc) {
+        parts.push(`desc:${desc.provider}|${desc.model}|${desc.baseUrl}|${desc.systemPrompt}`);
+    }
+    if (img) {
+        parts.push(`img:${img.provider}|${img.model}|${img.baseUrl}|${img.prompt}`);
+    }
+    if (parts.length === 0)
+        return undefined;
+    return createHash("sha256").update(parts.join("||")).digest("hex").slice(0, 16);
+}
 /** Load a manifest from disk, handling missing or corrupt files gracefully. */
 export async function loadManifest(dbPath) {
     const filePath = manifestPathFor(dbPath);
@@ -32,14 +62,15 @@ export async function loadManifest(dbPath) {
         if (!parsed || typeof parsed !== "object" || !parsed.files || typeof parsed.files !== "object") {
             return { manifest: createEmptyManifest(), path: filePath, status: "corrupt" };
         }
+        const version = parsed.schemaVersion ?? 0;
         return {
             manifest: {
                 lastIndexedAt: typeof parsed.lastIndexedAt === "number" ? parsed.lastIndexedAt : undefined,
-                schemaVersion: parsed.schemaVersion,
+                schemaVersion: version,
                 files: parsed.files,
             },
             path: filePath,
-            status: parsed.schemaVersion === SCHEMA_VERSION ? "ok" : "corrupt",
+            status: version >= MIN_SUPPORTED_SCHEMA_VERSION ? "ok" : "corrupt",
         };
     }
     catch (error) {

package/dist/core/resolve-api-key.js

@@ -41,7 +41,7 @@ function resolveForSection(provider, section, worktree) {
     // so createEmbedder can throw a clear error about the missing key
 }
 function stripJsoncComments(text) {
-    return text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    return text.replace(/("[^"\\]*(?:\\.[^"\\]*)*")|(\/\/[^\n]*|\/\*[\s\S]*?\*\/)/g, (_, string) => string ?? "");
 }
 function readOpenCodeProviderKey(worktree, providerId) {
     const locations = [
@@ -57,7 +57,9 @@ function readOpenCodeProviderKey(worktree, providerId) {
             if (!existsSync(loc))
                 continue;
             const raw = readFileSync(loc, "utf-8");
-            const cleaned = stripJsoncComments(raw);
+            // Only strip JSONC comments from .jsonc files; plain JSON may contain
+            // "https://" URLs that look like line-comment markers after "//".
+            const cleaned = loc.endsWith(".jsonc") ? stripJsoncComments(raw) : raw;
             const config = JSON.parse(cleaned);
             const providerSection = config.provider;
             if (!providerSection)

package/dist/core/runtime-overrides.js

@@ -11,7 +11,9 @@ export function loadRuntimeOverrides(storePath) {
     if (!existsSync(overridePath))
         return {};
     try {
-        return JSON.parse(readFileSync(overridePath, "utf-8"));
+        const raw = readFileSync(overridePath, "utf-8");
+        const stripped = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+        return JSON.parse(stripped);
     }
     catch {
         return {};
@@ -80,41 +82,43 @@ export function applyRuntimeOverrides(cfg, overrides) {
             merged.embedding.baseUrl = overrides.embedding.baseUrl;
     }
     if (overrides.description) {
+        const defaultDesc = DEFAULT_CONFIG.description;
         if (overrides.description.enabled !== undefined) {
             if (!merged.description)
-                merged.description = { enabled: true, provider: "ollama", baseUrl: "http://127.0.0.1:11434/api", model: "qwen2.5:3b", systemPrompt: "" };
+                merged.description = { ...defaultDesc };
             merged.description.enabled = overrides.description.enabled;
         }
         if (overrides.description.provider !== undefined) {
             if (!merged.description)
-                merged.description = { enabled: true, provider: "ollama", baseUrl: "http://127.0.0.1:11434/api", model: "qwen2.5:3b", systemPrompt: "" };
+                merged.description = { ...defaultDesc };
             merged.description.provider = overrides.description.provider;
         }
         if (overrides.description.model !== undefined) {
             if (!merged.description)
-                merged.description = { enabled: true, provider: "ollama", baseUrl: "http://127.0.0.1:11434/api", model: "qwen2.5:3b", systemPrompt: "" };
+                merged.description = { ...defaultDesc };
             merged.description.model = overrides.description.model;
         }
         if (overrides.description.baseUrl !== undefined) {
             if (!merged.description)
-                merged.description = { enabled: true, provider: "ollama", baseUrl: "http://127.0.0.1:11434/api", model: "qwen2.5:3b", systemPrompt: "" };
+                merged.description = { ...defaultDesc };
             merged.description.baseUrl = overrides.description.baseUrl;
         }
     }
     if (overrides.imageDescription) {
+        const defaultImg = DEFAULT_CONFIG.imageDescription;
         if (overrides.imageDescription.enabled !== undefined) {
             if (!merged.imageDescription)
-                merged.imageDescription = { enabled: false, provider: "ollama", model: "llama3.2-vision", baseUrl: "http://127.0.0.1:11434/api", timeoutMs: 60000, prompt: "" };
+                merged.imageDescription = { ...defaultImg };
             merged.imageDescription.enabled = overrides.imageDescription.enabled;
         }
         if (overrides.imageDescription.provider !== undefined) {
             if (!merged.imageDescription)
-                merged.imageDescription = { enabled: false, provider: "ollama", model: "llama3.2-vision", baseUrl: "http://127.0.0.1:11434/api", timeoutMs: 60000, prompt: "" };
+                merged.imageDescription = { ...defaultImg };
             merged.imageDescription.provider = overrides.imageDescription.provider;
         }
         if (overrides.imageDescription.model !== undefined) {
             if (!merged.imageDescription)
-                merged.imageDescription = { enabled: false, provider: "ollama", model: "llama3.2-vision", baseUrl: "http://127.0.0.1:11434/api", timeoutMs: 60000, prompt: "" };
+                merged.imageDescription = { ...defaultImg };
             merged.imageDescription.model = overrides.imageDescription.model;
         }
     }

package/dist/core/setup-runtime.d.ts

@@ -0,0 +1,23 @@
+export interface SetupResult {
+    success: boolean;
+    errors: string[];
+}
+export declare function getRuntimeDir(): string;
+export declare function getNpmGlobalRoot(): string;
+export declare function getVersionFile(runtimeDir: string): string;
+export declare function readVersionFile(versionFile: string): string | null;
+/**
+ * npm-generated .cmd / .ps1 wrappers on Windows invoke `.js` files directly
+ * via file association. If the `.js` association points to a text editor
+ * (e.g. Notepad++) instead of Node.js, the CLI opens the editor instead of
+ * running. This function patches the wrappers to call `node` explicitly.
+ *
+ * Runs only on Windows. Safe to call on every setup — detects already-patched
+ * wrappers by checking for the `node` prefix.
+ */
+export declare function patchWindowsWrappers(npmGlobalRoot: string): void;
+export declare function setupRuntime(options?: {
+    force?: boolean;
+    silent?: boolean;
+    version?: string;
+}): Promise<SetupResult>;

package/dist/core/setup-runtime.js

@@ -0,0 +1,231 @@
+import path from "node:path";
+import os from "node:os";
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, symlinkSync, lstatSync, } from "node:fs";
+import { execSync } from "node:child_process";
+const PLUGIN_NAME = "opencode-rag-plugin";
+export function getRuntimeDir() {
+    return path.join(os.homedir(), ".opencode");
+}
+export function getNpmGlobalRoot() {
+    return execSync("npm root -g", {
+        encoding: "utf-8",
+        timeout: 10_000,
+    }).trim();
+}
+function createJunction(targetPath, linkPath) {
+    const type = process.platform === "win32" ? "junction" : "dir";
+    symlinkSync(targetPath, linkPath, type);
+}
+function removeIfExists(targetPath) {
+    if (existsSync(targetPath)) {
+        rmSync(targetPath, { recursive: true, force: true });
+    }
+}
+export function getVersionFile(runtimeDir) {
+    return path.join(runtimeDir, ".bundle-version");
+}
+export function readVersionFile(versionFile) {
+    try {
+        return readFileSync(versionFile, "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Bin name npm generates for this package (without .cmd/.ps1). */
+function getBinName() {
+    const pkgJson = path.join(getNpmGlobalRoot(), PLUGIN_NAME, "package.json");
+    try {
+        const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+        if (pkg.bin && typeof pkg.bin === "object") {
+            return Object.keys(pkg.bin)[0] ?? PLUGIN_NAME;
+        }
+        if (typeof pkg.bin === "string") {
+            return PLUGIN_NAME;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return PLUGIN_NAME;
+}
+/**
+ * npm-generated .cmd / .ps1 wrappers on Windows invoke `.js` files directly
+ * via file association. If the `.js` association points to a text editor
+ * (e.g. Notepad++) instead of Node.js, the CLI opens the editor instead of
+ * running. This function patches the wrappers to call `node` explicitly.
+ *
+ * Runs only on Windows. Safe to call on every setup — detects already-patched
+ * wrappers by checking for the `node` prefix.
+ */
+export function patchWindowsWrappers(npmGlobalRoot) {
+    if (process.platform !== "win32")
+        return;
+    const binDir = path.resolve(npmGlobalRoot, "..");
+    const binName = getBinName();
+    // ── .cmd wrapper ──────────────────────────────────────────────
+    const cmdFile = path.join(binDir, `${binName}.cmd`);
+    if (existsSync(cmdFile)) {
+        const content = readFileSync(cmdFile, "utf-8");
+        // npm generates: "%dp0%\node_modules\opencode-rag-plugin\dist\cli\index.js"   %*
+        // We want:       node "%dp0%\node_modules\opencode-rag-plugin\dist\cli\index.js"   %*
+        const cmdJsLine = /^(?!node\s)("[^"]+\.js"\s+%\*)$/m;
+        if (cmdJsLine.test(content)) {
+            const patched = content.replace(cmdJsLine, "node $1");
+            writeFileSync(cmdFile, patched, "utf-8");
+        }
+    }
+    // ── PowerShell wrapper ────────────────────────────────────────
+    const ps1File = path.join(binDir, `${binName}.ps1`);
+    if (existsSync(ps1File)) {
+        let content = readFileSync(ps1File, "utf-8");
+        // Skip if already patched
+        if (content.includes('node "$basedir'))
+            return;
+        // npm generates:
+        //   $input | & "$basedir/node_modules/.../index.js"   $args
+        //   & "$basedir/node_modules/.../index.js"   $args
+        // Replace to: & node "$basedir/.../index.js"   $args
+        const ps1DirectLine = /(&\s+)("\$basedir\/[^"]+\.js"\s+\$args)/g;
+        if (ps1DirectLine.test(content)) {
+            content = content.replace(ps1DirectLine, "$1node $2");
+            writeFileSync(ps1File, content, "utf-8");
+        }
+    }
+}
+export async function setupRuntime(options) {
+    const errors = [];
+    const pluginVersion = options?.version || process.env.OPCODE_RAG_VERSION || "0.0.0";
+    const runtimeDir = getRuntimeDir();
+    const versionFile = getVersionFile(runtimeDir);
+    const runtimePluginDir = path.join(runtimeDir, "node_modules", PLUGIN_NAME);
+    const runtimeSdkDir = path.join(runtimeDir, "node_modules", "@opencode-ai");
+    const runtimeSdkPluginDir = path.join(runtimeSdkDir, "plugin");
+    const installedVersion = readVersionFile(versionFile);
+    const runtimeDist = path.join(runtimePluginDir, "dist");
+    const alreadyInstalled = existsSync(runtimeDist);
+    if (alreadyInstalled && installedVersion === pluginVersion && !options?.force) {
+        return { success: true, errors: [] };
+    }
+    let npmGlobalRoot;
+    try {
+        npmGlobalRoot = getNpmGlobalRoot();
+    }
+    catch {
+        errors.push("npm is not available on PATH. Cannot determine global package location.");
+        return { success: false, errors };
+    }
+    const globalPluginDir = path.join(npmGlobalRoot, PLUGIN_NAME);
+    const globalSdkPluginDir = path.join(npmGlobalRoot, "@opencode-ai", "plugin");
+    if (!existsSync(globalPluginDir)) {
+        errors.push(`Plugin not found at: ${globalPluginDir}`);
+        return { success: false, errors };
+    }
+    if (!existsSync(path.join(globalPluginDir, "dist", "cli.js"))) {
+        errors.push(`Global install seems incomplete: dist/ not found in ${globalPluginDir}`);
+        return { success: false, errors };
+    }
+    mkdirSync(runtimeDir, { recursive: true });
+    const runtimePkg = path.join(runtimeDir, "package.json");
+    if (!existsSync(runtimePkg)) {
+        writeFileSync(runtimePkg, JSON.stringify({ private: true, type: "module" }, null, 2) + "\n", "utf-8");
+    }
+    removeIfExists(runtimePluginDir);
+    // Ensure stale directory is fully gone before creating junction
+    let retries = 3;
+    while (retries > 0 && existsSync(runtimePluginDir)) {
+        try {
+            rmSync(runtimePluginDir, { recursive: true, force: true });
+        }
+        catch { /* retry */ }
+        retries--;
+    }
+    mkdirSync(path.dirname(runtimePluginDir), { recursive: true });
+    let junctionOk = false;
+    try {
+        createJunction(globalPluginDir, runtimePluginDir);
+        junctionOk = process.platform !== "win32";
+        if (process.platform === "win32") {
+            const stat = lstatSync(runtimePluginDir);
+            junctionOk = stat.isSymbolicLink();
+        }
+    }
+    catch {
+        // fall through to cpSync
+    }
+    if (!junctionOk) {
+        if (!options?.silent) {
+            console.error("  [warn] Junction not supported, falling back to copy...");
+        }
+        const { cpSync } = await import("node:fs");
+        cpSync(globalPluginDir, runtimePluginDir, { recursive: true });
+    }
+    // Ensure the @opencode-ai/plugin SDK is available globally.
+    // We must NOT run `npm install` inside the runtime dir because npm
+    // re-resolves all of node_modules/ and replaces the plugin junction
+    // with the published npm version (corrupting the local link).
+    if (!existsSync(globalSdkPluginDir)) {
+        try {
+            execSync(`npm install -g @opencode-ai/plugin`, {
+                stdio: "pipe",
+                timeout: 60_000,
+            });
+        }
+        catch (cause) {
+            errors.push(`Failed to install @opencode-ai/plugin SDK globally: ${cause.message}`);
+            return { success: false, errors };
+        }
+    }
+    // Create junction from global SDK to runtime (same pattern as plugin above)
+    if (existsSync(globalSdkPluginDir)) {
+        removeIfExists(runtimeSdkPluginDir);
+        retries = 3;
+        while (retries > 0 && existsSync(runtimeSdkPluginDir)) {
+            try {
+                rmSync(runtimeSdkPluginDir, { recursive: true, force: true });
+            }
+            catch { /* retry */ }
+            retries--;
+        }
+        mkdirSync(runtimeSdkDir, { recursive: true });
+        let sdkJunctionOk = false;
+        try {
+            createJunction(globalSdkPluginDir, runtimeSdkPluginDir);
+            sdkJunctionOk = process.platform !== "win32";
+            if (process.platform === "win32") {
+                const stat = lstatSync(runtimeSdkPluginDir);
+                sdkJunctionOk = stat.isSymbolicLink();
+            }
+        }
+        catch {
+            // fall through to cpSync
+        }
+        if (!sdkJunctionOk) {
+            if (!options?.silent) {
+                console.error("  [warn] SDK junction not supported, falling back to copy...");
+            }
+            const { cpSync } = await import("node:fs");
+            cpSync(globalSdkPluginDir, runtimeSdkPluginDir, { recursive: true });
+        }
+    }
+    else {
+        errors.push(`@opencode-ai/plugin SDK not available after global install`);
+        return { success: false, errors };
+    }
+    writeFileSync(versionFile, pluginVersion, "utf-8");
+    patchWindowsWrappers(npmGlobalRoot);
+    const cliEntry = path.join(runtimePluginDir, "dist", "cli.js");
+    const pluginEntry = path.join(runtimePluginDir, "dist", "plugin-entry.js");
+    const sdkPkg = path.join(runtimeSdkPluginDir, "package.json");
+    const success = existsSync(cliEntry) && existsSync(pluginEntry) && existsSync(sdkPkg);
+    if (!success) {
+        if (!existsSync(cliEntry))
+            errors.push(`CLI entry missing: ${cliEntry}`);
+        if (!existsSync(pluginEntry))
+            errors.push(`Plugin entry missing: ${pluginEntry}`);
+        if (!existsSync(sdkPkg))
+            errors.push(`Plugin SDK missing: ${sdkPkg}`);
+    }
+    return { success, errors };
+}
+//# sourceMappingURL=setup-runtime.js.map

package/dist/core/version-check.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Version check and self-update functionality. Checks GitHub
+ * releases for new versions and installs the newest version via npm, then
+ * re-syncs the OpenCode runtime junctions.
+ */
+import { setupRuntime } from "./setup-runtime.js";
+/** Information about an available update. */
+export interface UpdateInfo {
+    /** The currently installed version string. */
+    currentVersion: string;
+    /** The latest available version on GitHub. */
+    latestVersion: string;
+    /** Whether a newer version than the current one exists. */
+    updateAvailable: boolean;
+    /** URL to the GitHub release page. */
+    releaseUrl: string;
+    /** ISO date string of when the release was published. */
+    publishedAt: string;
+}
+/** Result of an install-update attempt. */
+export interface InstallUpdateResult {
+    /** Whether the install completed successfully. */
+    success: boolean;
+    /** Human-readable status message. */
+    message: string;
+    /** Version before the update. */
+    fromVersion: string;
+    /** Version after the update (undefined if the install failed). */
+    toVersion?: string;
+}
+/** Callable shape for the npm runner (a subset of execSync's signature). */
+type NpmRunner = (command: string, options: {
+    stdio: "inherit" | "pipe";
+    timeout: number;
+}) => unknown;
+/**
+ * Read the current version from the package.json sitting next to this module.
+ *
+ * Resolves the package root via `import.meta.url` so it works both from the
+ * source tree and from the compiled `dist/` output. Returns `"0.0.0"` if the
+ * file cannot be read or parsed (best-effort — never throws).
+ *
+ * @returns The current package version string.
+ */
+export declare function getCurrentVersion(): string;
+/**
+ * Compare two semver-ish strings.
+ * @returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Check the GitHub releases API for a newer version of OpenCodeRAG.
+ *
+ * Uses a 5-second timeout; failures (network errors, non-OK responses, missing
+ * `tag_name`) are silently caught and reported as "no update available" so the
+ * caller never has to handle a rejection.
+ *
+ * @param currentVersion - The version string to compare against.
+ * @returns UpdateInfo indicating whether an update is available.
+ */
+export declare function checkForUpdate(currentVersion: string): Promise<UpdateInfo>;
+/**
+ * Install the newest published version of OpenCodeRAG.
+ *
+ * Runs `npm install -g <package>@latest` to refresh the global install, then
+ * calls {@link setupRuntime} with `force: true` to re-create the
+ * `~/.opencode/node_modules/` junctions so OpenCode picks up the new build on
+ * the next restart.
+ *
+ * @param options - Optional verbosity flag. When `verbose` is true, npm output
+ *   is streamed to the console; otherwise it is captured silently. The
+ *   `_execSync` and `_setupRuntime` seams are for testing only.
+ * @returns An {@link InstallUpdateResult} with success status, message, and the
+ *   from/to versions.
+ */
+export declare function installLatestUpdate(options?: {
+    verbose?: boolean;
+    /** Test seam: override the npm runner. */
+    _execSync?: NpmRunner;
+    /** Test seam: override the runtime sync. */
+    _setupRuntime?: typeof setupRuntime;
+    /** Test seam: override the version reader for the "to" version. */
+    _getCurrentVersion?: typeof getCurrentVersion;
+}): Promise<InstallUpdateResult>;
+export {};