@agenthippo-ai/agenthippo 0.1.0

package/out/store/oramaIndex.js

@@ -0,0 +1,884 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStoreIndex = getStoreIndex;
+exports.searchStore = searchStore;
+exports.listArtifacts = listArtifacts;
+exports.forceRefresh = forceRefresh;
+exports.invalidateLocalIndex = invalidateLocalIndex;
+exports.searchMerged = searchMerged;
+exports.listMergedArtifacts = listMergedArtifacts;
+exports.isStale = isStale;
+exports.isRemoteStoreMetaNewer = isRemoteStoreMetaNewer;
+exports.isRemoteIndexNewerThanCache = isRemoteIndexNewerThanCache;
+exports.getLastSyncTime = getLastSyncTime;
+exports.getIndexMeta = getIndexMeta;
+exports.initializeStoreIndex = initializeStoreIndex;
+/**
+ * Orama-based Store Index
+ *
+ * Provides fast, offline-capable full-text search over the store artifacts.
+ * The index is pre-built via GitHub Actions and cached locally.
+ *
+ * Features:
+ * - Background sync on activation (if stale)
+ * - Instant local search (no network for queries)
+ * - Typo tolerance and fuzzy matching
+ * - Agent API for skill scripts
+ */
+const vscode = __importStar(require("vscode"));
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const orama_1 = require("@orama/orama");
+const github_1 = require("../agentpack/github");
+const paths_1 = require("../agentpack/paths");
+const index_1 = require("../registry/index");
+const install_1 = require("../engines/install");
+const install_2 = require("../spotlight/install");
+// -----------------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------------
+/** Local store index cache under {@link getAgentideHome} (default ~/.agent-hippo/store-cache). */
+function getStoreCacheDir() {
+    return path.join((0, paths_1.getAgentideHome)(), 'store-cache');
+}
+const DEFAULT_STORE_OWNER = 'agenthippoai';
+const DEFAULT_STORE_REPO = 'agenthippo-store';
+function getConfig() {
+    const config = vscode.workspace.getConfiguration('agentide');
+    const storeRepo = config.get('storeRepo', '');
+    const [owner, repo] = storeRepo
+        ? storeRepo.split('/')
+        : [DEFAULT_STORE_OWNER, DEFAULT_STORE_REPO];
+    const indexUrl = config.get('store.indexUrl', '') ||
+        `https://${owner}.github.io/${repo}`;
+    const syncIntervalHours = config.get('store.syncIntervalHours', 24);
+    const checkUpdatesOnStartup = config.get('store.checkUpdatesOnStartup', true);
+    return {
+        owner,
+        repo,
+        indexUrl,
+        oramaIndexUrl: `${indexUrl}/store-orama.json`,
+        metaUrl: `${indexUrl}/store-meta.json`,
+        rawIndexUrl: `${indexUrl}/store-index.json`,
+        syncIntervalMs: syncIntervalHours * 60 * 60 * 1000,
+        checkUpdatesOnStartup,
+    };
+}
+function getConfigKey(config) {
+    return `${config.owner}/${config.repo}|${config.rawIndexUrl}`;
+}
+// -----------------------------------------------------------------------------
+// Orama Schema
+// -----------------------------------------------------------------------------
+const ORAMA_SCHEMA = {
+    id: 'string',
+    type: 'enum',
+    slug: 'string',
+    displayName: 'string',
+    description: 'string',
+    tags: 'string[]',
+    author: 'string',
+    latestVersion: 'string',
+};
+// -----------------------------------------------------------------------------
+// State
+// -----------------------------------------------------------------------------
+// Remote store index state
+let cachedDb = null;
+let cachedConfigKey = null;
+let syncInProgress = null;
+let lastSyncAttempt = 0;
+const SYNC_COOLDOWN_MS = 60_000; // Don't retry sync more than once per minute
+/** Minimum interval between remote store-meta.json fetches when cache is time-fresh. */
+const REMOTE_META_CHECK_INTERVAL_MS = 10 * 60 * 1000;
+let lastRemoteMetaCheckAt = 0;
+let lastRemoteMetaConfigKey = null;
+let lastRemoteMetaCached;
+// Local library index state (Option B: separate index for user's installed items)
+let localDb = null;
+let localDbVersion = 0; // Incremented when registry changes
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Get the store index, loading from cache or fetching if needed.
+ * This is the main entry point for accessing the index.
+ */
+async function getStoreIndex(outputChannel) {
+    const config = getConfig();
+    const configKey = getConfigKey(config);
+    // If config changed, clear in-memory cache so we fetch from the new source
+    if (cachedDb && cachedConfigKey && cachedConfigKey !== configKey) {
+        outputChannel?.appendLine('[Store Index] Store config changed, clearing in-memory cache');
+        cachedDb = null;
+        clearRemoteMetaCheckCache();
+    }
+    if (cachedDb) {
+        await maybeRefreshStoreIndex(outputChannel);
+        return cachedDb;
+    }
+    // Try to load from cache first
+    const cached = await loadCachedIndex(configKey, outputChannel);
+    if (cached) {
+        cachedDb = cached;
+        await maybeRefreshStoreIndex(outputChannel);
+        return cachedDb;
+    }
+    // No cache, must fetch synchronously
+    await refreshIndex(outputChannel);
+    if (!cachedDb) {
+        // Create empty index as fallback
+        cachedDb = await (0, orama_1.create)({ schema: ORAMA_SCHEMA });
+    }
+    return cachedDb;
+}
+/**
+ * Search the store index.
+ */
+async function searchStore(query, options, outputChannel) {
+    const db = await getStoreIndex(outputChannel);
+    const searchOptions = {
+        term: query,
+        properties: ['displayName', 'description', 'slug', 'tags'],
+        limit: options?.limit ?? 20,
+        tolerance: 1, // Allow 1 typo
+    };
+    if (options?.type) {
+        searchOptions.where = { type: options.type };
+    }
+    const results = await (0, orama_1.search)(db, searchOptions);
+    return results.hits.map((hit) => ({
+        id: hit.document.id,
+        type: hit.document.type,
+        slug: hit.document.slug,
+        displayName: hit.document.displayName,
+        description: hit.document.description,
+        tags: hit.document.tags,
+        author: hit.document.author,
+        latestVersion: hit.document.latestVersion,
+        score: hit.score,
+    }));
+}
+/**
+ * Get all artifacts of a specific type.
+ */
+async function listArtifacts(type, outputChannel) {
+    const db = await getStoreIndex(outputChannel);
+    const searchOptions = {
+        term: '',
+        limit: 1000,
+    };
+    if (type) {
+        searchOptions.where = { type };
+    }
+    const results = await (0, orama_1.search)(db, searchOptions);
+    return results.hits.map((hit) => ({
+        id: hit.document.id,
+        type: hit.document.type,
+        slug: hit.document.slug,
+        displayName: hit.document.displayName,
+        description: hit.document.description,
+        tags: hit.document.tags,
+        author: hit.document.author,
+        latestVersion: hit.document.latestVersion,
+        score: hit.score,
+    }));
+}
+/**
+ * Force refresh the index from remote.
+ */
+async function forceRefresh(outputChannel) {
+    await refreshIndex(outputChannel);
+}
+// -----------------------------------------------------------------------------
+// Local Library Index (Option B: Two Indexes)
+// -----------------------------------------------------------------------------
+/**
+ * Build or get the local library Orama index from the user's registry.
+ * This index contains installed packs, skills, MCP servers, and custom engines.
+ */
+async function getLocalIndex(outputChannel) {
+    // Check if we need to rebuild (registry might have changed)
+    const registry = (0, index_1.getRegistry)();
+    const packs = await registry.listPacks();
+    const skills = await registry.listSkills();
+    const mcps = await registry.listMcp();
+    const engines = await listInstalledEngines();
+    const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    const views = await (0, install_2.listInstalledSpotlightViews)(workspaceRoot);
+    const totalItems = packs.length + skills.length + mcps.length + engines.length + views.length;
+    // Simple version check: if item count changed, rebuild
+    if (localDb && localDbVersion === totalItems) {
+        return localDb;
+    }
+    outputChannel?.appendLine(`[Store Index] Building local library index (${totalItems} items)...`);
+    const db = await (0, orama_1.create)({ schema: ORAMA_SCHEMA });
+    // Insert packs
+    for (const pack of packs) {
+        await (0, orama_1.insert)(db, {
+            id: `pack/${pack.slug}`,
+            type: 'pack',
+            slug: pack.slug,
+            displayName: pack.displayName,
+            description: pack.description || '',
+            tags: pack.tags || [],
+            author: pack.githubOwner || '',
+            latestVersion: pack.latestVersion,
+        });
+    }
+    // Insert skills
+    for (const skill of skills) {
+        await (0, orama_1.insert)(db, {
+            id: `skill/${skill.slug}`,
+            type: 'skill',
+            slug: skill.slug,
+            displayName: skill.displayName,
+            description: skill.description || '',
+            tags: skill.tags || [],
+            author: skill.githubOwner || '',
+            latestVersion: skill.latestVersion,
+        });
+    }
+    // Insert MCP servers
+    for (const mcp of mcps) {
+        await (0, orama_1.insert)(db, {
+            id: `mcp/${mcp.slug}`,
+            type: 'mcp',
+            slug: mcp.slug,
+            displayName: mcp.displayName,
+            description: mcp.description || '',
+            tags: mcp.tags || [],
+            author: mcp.githubOwner || '',
+            latestVersion: mcp.latestVersion,
+        });
+    }
+    // Insert custom engines
+    for (const engine of engines) {
+        await (0, orama_1.insert)(db, {
+            id: `engine/${engine.slug}`,
+            type: 'engine',
+            slug: engine.slug,
+            displayName: engine.displayName,
+            description: engine.description || '',
+            tags: engine.tags || [],
+            author: '',
+            latestVersion: engine.latestVersion,
+        });
+    }
+    // Insert installed Spotlight views
+    for (const view of views) {
+        await (0, orama_1.insert)(db, {
+            id: `view/${view.slug}`,
+            type: 'view',
+            slug: view.slug,
+            displayName: view.displayName,
+            description: view.description || '',
+            tags: view.tags || ['spotlight'],
+            author: '',
+            latestVersion: view.latestVersion,
+        });
+    }
+    localDb = db;
+    localDbVersion = totalItems;
+    outputChannel?.appendLine(`[Store Index] Local library index built (${totalItems} items)`);
+    return db;
+}
+async function listInstalledEngines() {
+    // Use the same install root the engine installer writes to so that
+    // AGENT_HOME_DIR / AGENTHIPPO_HOME overrides (and any future relocation)
+    // stay consistent between installer and library index.
+    const root = (0, install_1.getDefaultCustomEnginesInstallRoot)();
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) {
+            continue;
+        }
+        try {
+            const manifestPath = path.join(root, entry.name, 'engine.manifest.json');
+            const manifest = JSON.parse(await fs_1.promises.readFile(manifestPath, 'utf8'));
+            const slug = typeof manifest.id === 'string' && manifest.id.trim()
+                ? manifest.id.trim().toLowerCase()
+                : entry.name.toLowerCase();
+            const displayName = typeof manifest.displayName === 'string' && manifest.displayName.trim()
+                ? manifest.displayName.trim()
+                : slug;
+            const description = typeof manifest.description === 'string' && manifest.description.trim()
+                ? manifest.description.trim()
+                : undefined;
+            const packageJson = await fs_1.promises.readFile(path.join(root, entry.name, 'package.json'), 'utf8')
+                .then(raw => JSON.parse(raw))
+                .catch(() => undefined);
+            const latestVersion = typeof packageJson?.version === 'string' && packageJson.version.trim()
+                ? packageJson.version.trim()
+                : 'local';
+            engines.push({
+                slug,
+                displayName,
+                description,
+                tags: ['engine'],
+                latestVersion,
+            });
+        }
+        catch {
+            engines.push({
+                slug: entry.name.toLowerCase(),
+                displayName: entry.name,
+                tags: ['engine'],
+                latestVersion: 'local',
+            });
+        }
+    }
+    return engines;
+}
+/**
+ * Get a map of installed items for quick lookup.
+ * Returns { 'pack/my-pack': { version: '1.0.0', installedTo: [...] }, ... }
+ */
+async function getInstalledMap() {
+    const registry = (0, index_1.getRegistry)();
+    const installed = new Map();
+    const packs = await registry.listPacks();
+    for (const pack of packs) {
+        installed.set(`pack/${pack.slug}`, { version: pack.latestVersion });
+    }
+    const skills = await registry.listSkills();
+    for (const skill of skills) {
+        installed.set(`skill/${skill.slug}`, {
+            version: skill.latestVersion,
+            installedTo: skill.installedTo || [],
+        });
+    }
+    const mcps = await registry.listMcp();
+    for (const mcp of mcps) {
+        installed.set(`mcp/${mcp.slug}`, {
+            version: mcp.latestVersion,
+            installedTo: mcp.installedTo || [],
+        });
+    }
+    const engines = await listInstalledEngines();
+    for (const engine of engines) {
+        installed.set(`engine/${engine.slug}`, {
+            version: engine.latestVersion,
+        });
+    }
+    const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    const views = await (0, install_2.listInstalledSpotlightViews)(workspaceRoot);
+    for (const view of views) {
+        installed.set(`view/${view.slug}`, {
+            version: view.latestVersion,
+        });
+    }
+    return installed;
+}
+/**
+ * Invalidate the local library index cache.
+ * Call this after installing/uninstalling items.
+ */
+function invalidateLocalIndex() {
+    localDb = null;
+    localDbVersion = 0;
+}
+/**
+ * Search both local library and remote store, merging results.
+ * Local items appear first and are marked as installed.
+ */
+async function searchMerged(query, options, outputChannel) {
+    const limit = options?.limit ?? 20;
+    // Get both indexes
+    const [localIndex, remoteIndex, installedMap] = await Promise.all([
+        getLocalIndex(outputChannel),
+        getStoreIndex(outputChannel),
+        getInstalledMap(),
+    ]);
+    const searchOptions = {
+        term: query,
+        properties: ['displayName', 'description', 'slug', 'tags'],
+        limit: limit,
+        tolerance: 1,
+    };
+    if (options?.type) {
+        searchOptions.where = { type: options.type };
+    }
+    // Search both indexes in parallel
+    const [localResults, remoteResults] = await Promise.all([
+        (0, orama_1.search)(localIndex, searchOptions),
+        (0, orama_1.search)(remoteIndex, searchOptions),
+    ]);
+    // Merge: local first, then remote (excluding duplicates)
+    const merged = [];
+    const seenIds = new Set();
+    // Add local results first (marked as installed)
+    for (const hit of localResults.hits) {
+        const id = hit.document.id;
+        seenIds.add(id);
+        const info = installedMap.get(id);
+        merged.push({
+            id,
+            type: hit.document.type,
+            slug: hit.document.slug,
+            displayName: hit.document.displayName,
+            description: hit.document.description,
+            tags: hit.document.tags,
+            author: hit.document.author,
+            latestVersion: hit.document.latestVersion,
+            score: hit.score,
+            source: 'local',
+            installed: true,
+            installedVersion: info?.version,
+            installedTo: info?.installedTo,
+        });
+    }
+    // Add remote results (not already in local)
+    for (const hit of remoteResults.hits) {
+        const id = hit.document.id;
+        if (seenIds.has(id)) {
+            continue; // Already added from local
+        }
+        seenIds.add(id);
+        const info = installedMap.get(id);
+        merged.push({
+            id,
+            type: hit.document.type,
+            slug: hit.document.slug,
+            displayName: hit.document.displayName,
+            description: hit.document.description,
+            tags: hit.document.tags,
+            author: hit.document.author,
+            latestVersion: hit.document.latestVersion,
+            score: hit.score,
+            source: 'remote',
+            installed: !!info,
+            installedVersion: info?.version,
+            installedTo: info?.installedTo,
+        });
+    }
+    return merged.slice(0, limit);
+}
+/**
+ * List all artifacts from both local and remote, merged.
+ */
+async function listMergedArtifacts(type, outputChannel) {
+    const [localIndex, remoteIndex, installedMap] = await Promise.all([
+        getLocalIndex(outputChannel),
+        getStoreIndex(outputChannel),
+        getInstalledMap(),
+    ]);
+    const searchOptions = {
+        term: '',
+        limit: 1000,
+    };
+    if (type) {
+        searchOptions.where = { type };
+    }
+    const [localResults, remoteResults] = await Promise.all([
+        (0, orama_1.search)(localIndex, searchOptions),
+        (0, orama_1.search)(remoteIndex, searchOptions),
+    ]);
+    const merged = [];
+    const seenIds = new Set();
+    // Local items first
+    for (const hit of localResults.hits) {
+        const id = hit.document.id;
+        seenIds.add(id);
+        const info = installedMap.get(id);
+        merged.push({
+            id,
+            type: hit.document.type,
+            slug: hit.document.slug,
+            displayName: hit.document.displayName,
+            description: hit.document.description,
+            tags: hit.document.tags,
+            author: hit.document.author,
+            latestVersion: hit.document.latestVersion,
+            score: hit.score,
+            source: 'local',
+            installed: true,
+            installedVersion: info?.version,
+            installedTo: info?.installedTo,
+        });
+    }
+    // Remote items (not duplicates)
+    for (const hit of remoteResults.hits) {
+        const id = hit.document.id;
+        if (seenIds.has(id)) {
+            continue;
+        }
+        seenIds.add(id);
+        const info = installedMap.get(id);
+        merged.push({
+            id,
+            type: hit.document.type,
+            slug: hit.document.slug,
+            displayName: hit.document.displayName,
+            description: hit.document.description,
+            tags: hit.document.tags,
+            author: hit.document.author,
+            latestVersion: hit.document.latestVersion,
+            score: hit.score,
+            source: 'remote',
+            installed: !!info,
+            installedVersion: info?.version,
+            installedTo: info?.installedTo,
+        });
+    }
+    return merged;
+}
+/**
+ * Check if the cached index is stale (time-based).
+ */
+async function isStale() {
+    try {
+        const lastSyncPath = path.join(getStoreCacheDir(), 'last-sync.txt');
+        const lastSync = await fs_1.promises.readFile(lastSyncPath, 'utf8');
+        const { syncIntervalMs } = getConfig();
+        return Date.now() - parseInt(lastSync, 10) > syncIntervalMs;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Compare local cache metadata with remote store metadata (pure, testable).
+ */
+function isRemoteStoreMetaNewer(localMeta, remoteMeta) {
+    if (!localMeta?.generatedAt) {
+        return true;
+    }
+    if (!remoteMeta?.generatedAt) {
+        return false;
+    }
+    const localTime = Date.parse(localMeta.generatedAt);
+    const remoteTime = Date.parse(remoteMeta.generatedAt);
+    if (!Number.isNaN(remoteTime) && !Number.isNaN(localTime) && remoteTime > localTime) {
+        return true;
+    }
+    if (typeof remoteMeta.artifactCount === 'number'
+        && typeof localMeta.artifactCount === 'number'
+        && remoteMeta.artifactCount !== localMeta.artifactCount) {
+        return true;
+    }
+    return false;
+}
+/**
+ * True when GitHub Pages has a newer index than the local cache (e.g. new spotlight views).
+ */
+async function isRemoteIndexNewerThanCache(outputChannel) {
+    const config = getConfig();
+    const configKey = getConfigKey(config);
+    const localMeta = await getIndexMeta();
+    const remoteMeta = await getRemoteIndexMetaCached(config, configKey, outputChannel);
+    const newer = isRemoteStoreMetaNewer(localMeta, remoteMeta ?? undefined);
+    if (newer && remoteMeta && localMeta?.generatedAt) {
+        const localTime = Date.parse(localMeta.generatedAt);
+        const remoteTime = Date.parse(remoteMeta.generatedAt);
+        if (!Number.isNaN(remoteTime) && !Number.isNaN(localTime) && remoteTime > localTime) {
+            outputChannel?.appendLine(`[Store Index] Remote index is newer (${remoteMeta.generatedAt} > ${localMeta.generatedAt})`);
+        }
+        else if (typeof remoteMeta.artifactCount === 'number'
+            && typeof localMeta.artifactCount === 'number'
+            && remoteMeta.artifactCount !== localMeta.artifactCount) {
+            outputChannel?.appendLine(`[Store Index] Remote artifact count changed (${localMeta.artifactCount} -> ${remoteMeta.artifactCount})`);
+        }
+    }
+    return newer;
+}
+/**
+ * Get the last sync timestamp.
+ */
+async function getLastSyncTime() {
+    try {
+        const lastSyncPath = path.join(getStoreCacheDir(), 'last-sync.txt');
+        const lastSync = await fs_1.promises.readFile(lastSyncPath, 'utf8');
+        return new Date(parseInt(lastSync, 10));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get index metadata.
+ */
+async function getIndexMeta() {
+    try {
+        const metaPath = path.join(getStoreCacheDir(), 'store-meta.json');
+        const data = await fs_1.promises.readFile(metaPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+// -----------------------------------------------------------------------------
+// Internal Functions
+// -----------------------------------------------------------------------------
+function clearRemoteMetaCheckCache() {
+    lastRemoteMetaCheckAt = 0;
+    lastRemoteMetaConfigKey = null;
+    lastRemoteMetaCached = undefined;
+}
+async function getRemoteIndexMetaCached(config, configKey, outputChannel) {
+    const now = Date.now();
+    if (lastRemoteMetaConfigKey === configKey
+        && lastRemoteMetaCached !== undefined
+        && now - lastRemoteMetaCheckAt < REMOTE_META_CHECK_INTERVAL_MS) {
+        return lastRemoteMetaCached;
+    }
+    lastRemoteMetaConfigKey = configKey;
+    lastRemoteMetaCheckAt = now;
+    lastRemoteMetaCached = await fetchRemoteIndexMeta(config, outputChannel);
+    return lastRemoteMetaCached;
+}
+async function maybeRefreshStoreIndex(outputChannel) {
+    if (await isStale()) {
+        void refreshIndexBackground(outputChannel);
+        return;
+    }
+    if (await isRemoteIndexNewerThanCache(outputChannel)) {
+        outputChannel?.appendLine('[Store Index] Remote catalog updated, refreshing in background...');
+        void refreshIndexBackground(outputChannel);
+    }
+}
+async function fetchRemoteIndexMeta(config, outputChannel) {
+    try {
+        const response = await fetch(config.metaUrl, {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'AgentHippo',
+            },
+        });
+        if (response.ok) {
+            const meta = await response.json();
+            if (typeof meta.generatedAt === 'string' && meta.generatedAt.trim()) {
+                return {
+                    generatedAt: meta.generatedAt,
+                    artifactCount: typeof meta.artifactCount === 'number' ? meta.artifactCount : 0,
+                };
+            }
+        }
+    }
+    catch (e) {
+        outputChannel?.appendLine(`[Store Index] store-meta.json fetch failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    try {
+        const response = await fetch(config.rawIndexUrl, {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'AgentHippo',
+            },
+        });
+        if (response.ok) {
+            const index = await response.json();
+            if (typeof index.generatedAt === 'string' && index.generatedAt.trim()) {
+                return {
+                    generatedAt: index.generatedAt,
+                    artifactCount: Array.isArray(index.artifacts) ? index.artifacts.length : 0,
+                };
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+async function loadCachedIndex(configKey, outputChannel) {
+    try {
+        // Validate cached metadata matches current config
+        const metaPath = path.join(getStoreCacheDir(), 'store-meta.json');
+        const metaRaw = await fs_1.promises.readFile(metaPath, 'utf8');
+        const meta = JSON.parse(metaRaw);
+        if (!meta.sourceKey || meta.sourceKey !== configKey) {
+            outputChannel?.appendLine('[Store Index] Cache source mismatch; ignoring cached index');
+            return null;
+        }
+        const indexPath = path.join(getStoreCacheDir(), 'store-orama.json');
+        const data = await fs_1.promises.readFile(indexPath, 'utf8');
+        const parsed = JSON.parse(data);
+        // Orama's load function restores the index from serialized state
+        const db = await (0, orama_1.create)({ schema: ORAMA_SCHEMA });
+        // Orama v3 uses a different restore approach - we need to insert records
+        if (parsed.artifacts && Array.isArray(parsed.artifacts)) {
+            for (const artifact of parsed.artifacts) {
+                await (0, orama_1.insert)(db, artifact);
+            }
+        }
+        else if (parsed.docs) {
+            // Handle serialized Orama format
+            for (const doc of Object.values(parsed.docs)) {
+                await (0, orama_1.insert)(db, doc);
+            }
+        }
+        outputChannel?.appendLine(`[Store Index] Loaded ${(await (0, orama_1.search)(db, { term: '', limit: 1 })).count} artifacts from cache`);
+        cachedConfigKey = configKey;
+        return db;
+    }
+    catch (e) {
+        outputChannel?.appendLine(`[Store Index] Failed to load cache: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+async function refreshIndexBackground(outputChannel) {
+    // Debounce: don't spam sync attempts
+    if (Date.now() - lastSyncAttempt < SYNC_COOLDOWN_MS) {
+        return;
+    }
+    // Only one sync at a time
+    if (syncInProgress) {
+        return;
+    }
+    syncInProgress = refreshIndex(outputChannel).finally(() => {
+        syncInProgress = null;
+    });
+}
+async function refreshIndex(outputChannel) {
+    lastSyncAttempt = Date.now();
+    const config = getConfig();
+    const configKey = getConfigKey(config);
+    outputChannel?.appendLine(`[Store Index] Syncing from ${config.rawIndexUrl}...`);
+    try {
+        // Try to fetch the index
+        const indexData = await fetchIndexWithFallback(config, outputChannel);
+        if (!indexData.artifacts || !Array.isArray(indexData.artifacts)) {
+            throw new Error('Invalid index format: missing artifacts array');
+        }
+        // Build Orama index
+        const db = await (0, orama_1.create)({ schema: ORAMA_SCHEMA });
+        for (const artifact of indexData.artifacts) {
+            await (0, orama_1.insert)(db, {
+                id: artifact.id,
+                type: artifact.type,
+                slug: artifact.slug,
+                displayName: artifact.displayName,
+                description: artifact.description || '',
+                tags: artifact.tags || [],
+                author: artifact.author || '',
+                latestVersion: artifact.latestVersion || '',
+            });
+        }
+        // Cache the index
+        const cacheDir = getStoreCacheDir();
+        await fs_1.promises.mkdir(cacheDir, { recursive: true });
+        // Save raw artifacts for easy reload
+        await fs_1.promises.writeFile(path.join(cacheDir, 'store-orama.json'), JSON.stringify({ artifacts: indexData.artifacts }));
+        // Save metadata
+        await fs_1.promises.writeFile(path.join(cacheDir, 'store-meta.json'), JSON.stringify({
+            version: indexData.version,
+            generatedAt: indexData.generatedAt,
+            artifactCount: indexData.artifacts.length,
+            source: {
+                owner: config.owner,
+                repo: config.repo,
+                indexUrl: config.indexUrl,
+                rawIndexUrl: config.rawIndexUrl,
+            },
+            sourceKey: configKey,
+        }));
+        // Save sync timestamp
+        await fs_1.promises.writeFile(path.join(cacheDir, 'last-sync.txt'), Date.now().toString());
+        cachedDb = db;
+        cachedConfigKey = configKey;
+        outputChannel?.appendLine(`[Store Index] Synced ${indexData.artifacts.length} artifacts`);
+    }
+    catch (e) {
+        outputChannel?.appendLine(`[Store Index] Sync failed: ${e instanceof Error ? e.message : String(e)}`);
+        // Don't throw - we might have a cached version to fall back to
+    }
+}
+/**
+ * Fetch the store index, trying GitHub Pages first, then falling back to GitHub API.
+ * This allows both public repos (via CDN) and private repos (via API with auth) to work.
+ */
+async function fetchIndexWithFallback(config, outputChannel) {
+    // Try GitHub Pages first (fast CDN, works for public repos)
+    try {
+        const response = await fetch(config.rawIndexUrl, {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'AgentHippo',
+            },
+        });
+        if (response.ok) {
+            outputChannel?.appendLine(`[Store Index] Fetched from GitHub Pages`);
+            return await response.json();
+        }
+        // If 403/404, might be a private repo - try GitHub API
+        if (response.status === 403 || response.status === 404) {
+            outputChannel?.appendLine(`[Store Index] GitHub Pages not available (${response.status}), trying GitHub API...`);
+        }
+        else {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+    }
+    catch (e) {
+        // Network error or other issue - try GitHub API as fallback
+        outputChannel?.appendLine(`[Store Index] GitHub Pages fetch failed, trying GitHub API...`);
+    }
+    // Fallback: Try GitHub API (works for private repos with VS Code auth)
+    if (await (0, github_1.isGitHubAuthenticated)()) {
+        const fileContent = await (0, github_1.getFileContent)(config.owner, config.repo, 'dist/store-index.json');
+        if (fileContent) {
+            outputChannel?.appendLine(`[Store Index] Fetched from GitHub API (private repo)`);
+            return JSON.parse(fileContent.content);
+        }
+    }
+    throw new Error('Could not fetch store index from GitHub Pages or GitHub API');
+}
+// -----------------------------------------------------------------------------
+// Initialization
+// -----------------------------------------------------------------------------
+/**
+ * Initialize the store index on extension activation.
+ * This preloads the cache and triggers a background refresh if stale.
+ */
+async function initializeStoreIndex(outputChannel) {
+    try {
+        await getStoreIndex(outputChannel);
+        outputChannel?.appendLine('[Store Index] Initialized');
+    }
+    catch (e) {
+        outputChannel?.appendLine(`[Store Index] Initialization warning: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}