iosm-cli 0.1.2 → 0.1.3

package/dist/modes/interactive/interactive-mode.js

@@ -19,6 +19,7 @@ import { ModelRegistry } from "../../core/model-registry.js";
 import { resolveModelScope } from "../../core/model-resolver.js";
 import { getMcpCommandHelp, parseMcpAddCommand, parseMcpTargetCommand, } from "../../core/mcp/index.js";
 import { addMemoryEntry, getMemoryFilePath, readMemoryEntries, removeMemoryEntry, updateMemoryEntry, } from "../../core/memory.js";
+import { getDefaultSemanticSearchConfig, getSemanticConfigPath, getSemanticIndexDir, isLikelyEmbeddingModelId, listOllamaLocalModels, listOpenRouterEmbeddingModels, loadMergedSemanticConfig, SemanticConfigMissingError, SemanticRebuildRequiredError, SemanticSearchRuntime, upsertScopedSemanticSearchConfig, } from "../../core/semantic/index.js";
 import { DefaultResourceLoader } from "../../core/resource-loader.js";
 import { createAgentSession } from "../../core/sdk.js";
 import { createTeamRun, getTeamRun, listTeamRuns } from "../../core/agent-teams.js";
@@ -797,6 +798,42 @@ export class InteractiveMode {
         }
         return null;
     }
+    getSemanticArgumentCompletions(prefix) {
+        const subcommands = ["ui", "setup", "status", "index", "rebuild", "query", "help"];
+        const queryFlags = ["--top-k"];
+        const topKValues = ["5", "8", "10", "20"];
+        const hasTrailingSpace = /\\s$/.test(prefix);
+        const tokens = this.parseSlashArgs(prefix);
+        const first = tokens[0]?.toLowerCase();
+        if (!first || (tokens.length === 1 && !hasTrailingSpace)) {
+            const query = first ?? "";
+            const candidates = subcommands.filter((item) => item.includes(query));
+            return candidates.map((item) => ({ value: item, label: item }));
+        }
+        if (first !== "query") {
+            return null;
+        }
+        const topKIndex = tokens.findIndex((token) => token === "--top-k");
+        if (topKIndex >= 0) {
+            const currentValue = tokens[topKIndex + 1];
+            if (!currentValue) {
+                return topKValues.map((value) => ({ value, label: value }));
+            }
+            return topKValues
+                .filter((value) => value.startsWith(currentValue))
+                .map((value) => ({ value, label: value }));
+        }
+        const query = hasTrailingSpace ? "" : (tokens[tokens.length - 1] ?? "");
+        if (query.startsWith("--")) {
+            return queryFlags
+                .filter((flag) => flag.includes(query))
+                .map((flag) => ({ value: flag, label: flag }));
+        }
+        if (hasTrailingSpace) {
+            return queryFlags.map((flag) => ({ value: flag, label: flag }));
+        }
+        return null;
+    }
     setupAutocomplete(fdPath) {
         // Define commands for autocomplete
         const builtinCommands = BUILTIN_SLASH_COMMANDS.filter((command) => this.activeProfileName === "iosm" || !IOSM_PROFILE_ONLY_COMMANDS.has(command.name));
@@ -838,6 +875,10 @@ export class InteractiveMode {
         if (memoryCommand) {
             memoryCommand.getArgumentCompletions = (prefix) => this.getMemoryArgumentCompletions(prefix);
         }
+        const semanticCommand = slashCommands.find((command) => command.name === "semantic");
+        if (semanticCommand) {
+            semanticCommand.getArgumentCompletions = (prefix) => this.getSemanticArgumentCompletions(prefix);
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -1091,7 +1132,9 @@ export class InteractiveMode {
         }
         // Commands and keys
         const commandsLine = `${pad}${theme.fg("dim", "cmds")}  ` +
-            ["model", "login", "mcp", "memory", "doctor", "new"].map((c) => theme.fg("accent", `/${c}`)).join(theme.fg("dim", "  "));
+            ["model", "login", "mcp", "semantic", "memory", "doctor", "new"]
+                .map((c) => theme.fg("accent", `/${c}`))
+                .join(theme.fg("dim", "  "));
         const keysLine = `${pad}${theme.fg("dim", "keys")}  ` +
             appKeyHint(kb, "interrupt", "stop") +
             theme.fg("dim", "  ") +
@@ -1985,6 +2028,28 @@ export class InteractiveMode {
         const result = await this.showExtensionSelector(`${title}\n${message}`, ["Yes", "No"], opts);
         return result === "Yes";
     }
+    async runWithExtensionLoader(message, task) {
+        const loader = new BorderedLoader(this.ui, theme, message, {
+            cancellable: false,
+        });
+        this.editorContainer.clear();
+        this.editorContainer.addChild(loader);
+        this.ui.setFocus(loader);
+        this.ui.requestRender();
+        const restoreEditor = () => {
+            loader.dispose();
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            return await task();
+        }
+        finally {
+            restoreEditor();
+        }
+    }
     /**
      * Show a text input for extensions.
      */
@@ -2384,6 +2449,11 @@ export class InteractiveMode {
                 await this.handleMemoryCommand(text);
                 return;
             }
+            if (text === "/semantic" || text.startsWith("/semantic ")) {
+                this.editor.setText("");
+                await this.handleSemanticCommand(text);
+                return;
+            }
             if (text === "/settings") {
                 this.showSettingsSelector();
                 this.editor.setText("");
@@ -5018,7 +5088,8 @@ export class InteractiveMode {
         const providerInfo = this.session.modelRegistry.authStorage.getOAuthProviders().find((p) => p.id === providerId);
         return providerInfo?.name || providerId;
     }
-    async handleOpenRouterApiKeyLogin() {
+    async handleOpenRouterApiKeyLogin(options) {
+        const openModelSelector = options?.openModelSelector ?? true;
         const providerName = this.getProviderDisplayName(OPENROUTER_PROVIDER_ID);
         const existingCredential = this.session.modelRegistry.authStorage.get(OPENROUTER_PROVIDER_ID);
         if (existingCredential) {
@@ -5041,7 +5112,9 @@ export class InteractiveMode {
         this.session.modelRegistry.authStorage.set(OPENROUTER_PROVIDER_ID, { type: "api_key", key: apiKey });
         await this.updateAvailableProviderCount();
         this.showStatus(`${providerName} API key saved to ${getAuthPath()}`);
-        await this.showModelProviderSelector(OPENROUTER_PROVIDER_ID);
+        if (openModelSelector) {
+            await this.showModelProviderSelector(OPENROUTER_PROVIDER_ID);
+        }
     }
     async showLoginDialog(providerId) {
         const providerInfo = this.session.modelRegistry.authStorage.getOAuthProviders().find((p) => p.id === providerId);
@@ -5499,6 +5572,567 @@ export class InteractiveMode {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
+    createSemanticRuntime() {
+        return new SemanticSearchRuntime({
+            cwd: this.sessionManager.getCwd(),
+            agentDir: getAgentDir(),
+            authStorage: this.session.modelRegistry.authStorage,
+        });
+    }
+    parseSemanticScopeOptions(args) {
+        let scope;
+        const rest = [];
+        for (let index = 0; index < args.length; index++) {
+            const token = args[index] ?? "";
+            const normalized = token.toLowerCase();
+            if (normalized === "--scope") {
+                const value = (args[index + 1] ?? "").toLowerCase();
+                if (!value) {
+                    return { scope, rest, error: "Usage: /semantic setup --scope <user|project>" };
+                }
+                if (value !== "user" && value !== "project") {
+                    return { scope, rest, error: `Invalid semantic scope "${value}". Use user or project.` };
+                }
+                scope = value;
+                index += 1;
+                continue;
+            }
+            rest.push(token);
+        }
+        return { scope, rest };
+    }
+    parseSemanticTopKOptions(args) {
+        let topK;
+        const rest = [];
+        for (let index = 0; index < args.length; index++) {
+            const token = args[index] ?? "";
+            const normalized = token.toLowerCase();
+            if (normalized === "--top-k" || normalized === "--topk") {
+                const raw = (args[index + 1] ?? "").trim();
+                if (!raw) {
+                    return { topK, rest, error: "Usage: /semantic query <text> [--top-k 1..20]" };
+                }
+                const parsed = Number.parseInt(raw, 10);
+                if (!Number.isFinite(parsed) || `${parsed}` !== raw || parsed < 1 || parsed > 20) {
+                    return { topK, rest, error: "--top-k must be an integer between 1 and 20." };
+                }
+                topK = parsed;
+                index += 1;
+                continue;
+            }
+            rest.push(token);
+        }
+        return { topK, rest };
+    }
+    formatSemanticStatusReport(status) {
+        const lines = [
+            `configured: ${status.configured ? "yes" : "no"}`,
+            `enabled: ${status.enabled ? "yes" : "no"}`,
+            `indexed: ${status.indexed ? "yes" : "no"}`,
+            `stale: ${status.stale ? `yes${status.staleReason ? ` (${status.staleReason})` : ""}` : "no"}`,
+        ];
+        if (status.provider)
+            lines.push(`provider: ${status.provider}`);
+        if (status.model)
+            lines.push(`model: ${status.model}`);
+        lines.push(`files: ${status.files}`);
+        lines.push(`chunks: ${status.chunks}`);
+        if (status.dimension !== undefined)
+            lines.push(`dimension: ${status.dimension}`);
+        if (status.ageSeconds !== undefined)
+            lines.push(`age_seconds: ${status.ageSeconds}`);
+        lines.push(`index_path: ${status.indexPath}`);
+        lines.push(`config_user: ${status.configPathUser}`);
+        lines.push(`config_project: ${status.configPathProject}`);
+        if (!status.configured) {
+            lines.push("hint: run /semantic setup");
+        }
+        return lines.join("\n");
+    }
+    formatSemanticIndexReport(result) {
+        return [
+            `action: ${result.action}`,
+            `processed_files: ${result.processedFiles}`,
+            `reused_files: ${result.reusedFiles}`,
+            `new_files: ${result.newFiles}`,
+            `changed_files: ${result.changedFiles}`,
+            `removed_files: ${result.removedFiles}`,
+            `chunks: ${result.chunks}`,
+            `dimension: ${result.dimension}`,
+            `duration_ms: ${result.durationMs}`,
+            `built_at: ${result.builtAt}`,
+            `index_path: ${result.indexPath}`,
+        ].join("\n");
+    }
+    formatSemanticQueryReport(result) {
+        const lines = [
+            `query: ${result.query}`,
+            `top_k: ${result.topK}`,
+            `auto_refreshed: ${result.autoRefreshed ? "yes" : "no"}`,
+        ];
+        if (result.hits.length === 0) {
+            lines.push("hits: none");
+            return lines.join("\n");
+        }
+        lines.push("hits:");
+        for (let index = 0; index < result.hits.length; index++) {
+            const hit = result.hits[index];
+            lines.push(`${index + 1}. score=${hit.score.toFixed(4)} ${hit.path}:${hit.lineStart}-${hit.lineEnd}`);
+            lines.push(`   ${hit.snippet}`);
+        }
+        return lines.join("\n");
+    }
+    getSemanticSetupProviderLabel(type) {
+        if (type === "openrouter")
+            return "openrouter";
+        if (type === "ollama")
+            return "ollama";
+        return "custom_openai";
+    }
+    async ensureOpenRouterSemanticCredentials() {
+        const existing = await this.session.modelRegistry.authStorage.getApiKey(OPENROUTER_PROVIDER_ID);
+        if (existing)
+            return;
+        const shouldLogin = await this.showExtensionConfirm("Semantic setup: OpenRouter key missing", "No OpenRouter API key found. Open login flow now?");
+        if (!shouldLogin) {
+            this.showWarning("OpenRouter key is missing. semantic index/query will fail until credentials are added.");
+            return;
+        }
+        await this.handleOpenRouterApiKeyLogin({ openModelSelector: false });
+        const afterLogin = await this.session.modelRegistry.authStorage.getApiKey(OPENROUTER_PROVIDER_ID);
+        if (!afterLogin) {
+            this.showWarning("OpenRouter key is still missing. You can run /login later.");
+        }
+    }
+    async selectSemanticModelFromCatalog(title, catalogModels, currentModel, options) {
+        const normalizedCurrent = currentModel.trim();
+        const uniqueModels = [];
+        const seen = new Set();
+        for (const model of catalogModels) {
+            const normalized = model.trim();
+            if (!normalized || seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            uniqueModels.push(normalized);
+        }
+        const optionToModel = new Map();
+        const selectorOptions = [];
+        const addOption = (label, modelId) => {
+            let uniqueLabel = label;
+            let suffix = 2;
+            while (optionToModel.has(uniqueLabel)) {
+                uniqueLabel = `${label} (${suffix})`;
+                suffix += 1;
+            }
+            optionToModel.set(uniqueLabel, modelId);
+            selectorOptions.push(uniqueLabel);
+        };
+        if (normalizedCurrent) {
+            addOption(`Current: ${normalizedCurrent}`, normalizedCurrent);
+        }
+        for (const modelId of uniqueModels) {
+            const marker = options?.highlightLikelyEmbedding && isLikelyEmbeddingModelId(modelId) ? " [embedding]" : "";
+            addOption(`${modelId}${marker}`, modelId);
+        }
+        const manualOption = "Enter model manually";
+        selectorOptions.push(manualOption);
+        const selected = await this.showExtensionSelector(title, selectorOptions);
+        if (!selected)
+            return undefined;
+        if (selected === manualOption) {
+            const modelInput = await this.showExtensionInput(`${title}: model`, normalizedCurrent || "model-id");
+            if (modelInput === undefined)
+                return undefined;
+            const model = modelInput.trim();
+            if (!model) {
+                this.showWarning("Model cannot be empty.");
+                return undefined;
+            }
+            return model;
+        }
+        return optionToModel.get(selected);
+    }
+    async runSemanticSetupWizard(initialScope) {
+        const cwd = this.sessionManager.getCwd();
+        const agentDir = getAgentDir();
+        const merged = loadMergedSemanticConfig(cwd, agentDir);
+        const config = merged.config ?? getDefaultSemanticSearchConfig();
+        let scope = initialScope;
+        if (!scope) {
+            const pickedScope = await this.showExtensionSelector("/semantic setup: scope", [
+                "user (Recommended)",
+                "project",
+            ]);
+            if (!pickedScope) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            scope = pickedScope.startsWith("project") ? "project" : "user";
+        }
+        const providerOption = await this.showExtensionSelector("/semantic setup: provider", [
+            "openrouter (Recommended)",
+            "ollama",
+            "custom_openai",
+        ]);
+        if (!providerOption) {
+            this.showStatus("Semantic setup cancelled");
+            return;
+        }
+        const providerType = providerOption.startsWith("ollama")
+            ? "ollama"
+            : providerOption.startsWith("custom_openai")
+                ? "custom_openai"
+                : "openrouter";
+        const providerDefaults = {
+            openrouter: "openai/text-embedding-3-small",
+            ollama: "nomic-embed-text",
+            custom_openai: "text-embedding-3-small",
+        };
+        const currentModel = (config.provider.type === providerType ? config.provider.model : providerDefaults[providerType]).trim();
+        let model = currentModel;
+        const nextProvider = {
+            ...config.provider,
+            type: providerType,
+            model: model || providerDefaults[providerType],
+        };
+        if (providerType === "ollama") {
+            const defaultBase = (config.provider.type === "ollama" ? config.provider.baseUrl : undefined) ?? "http://127.0.0.1:11434";
+            const baseUrlInput = await this.showExtensionInput("/semantic setup: ollama base URL", defaultBase);
+            if (baseUrlInput === undefined) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            const baseUrl = baseUrlInput.trim();
+            nextProvider.baseUrl = baseUrl || undefined;
+            nextProvider.apiKeyEnv = undefined;
+            let ollamaModels = [];
+            try {
+                ollamaModels = await listOllamaLocalModels({
+                    baseUrl: nextProvider.baseUrl,
+                    headers: config.provider.type === "ollama" ? config.provider.headers : undefined,
+                    timeoutMs: nextProvider.timeoutMs,
+                });
+                if (ollamaModels.length === 0) {
+                    this.showWarning("No local Ollama models found at /api/tags. You can enter model manually.");
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.showWarning(`Failed to load Ollama models automatically: ${errorMsg}`);
+            }
+            const selectedModel = await this.selectSemanticModelFromCatalog("/semantic setup: ollama model", ollamaModels, currentModel || providerDefaults.ollama, { highlightLikelyEmbedding: true });
+            if (!selectedModel) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            model = selectedModel;
+        }
+        else if (providerType === "custom_openai") {
+            const defaultBase = (config.provider.type === "custom_openai" ? config.provider.baseUrl : undefined) ?? "http://127.0.0.1:8000/v1";
+            const baseUrlInput = await this.showExtensionInput("/semantic setup: custom base URL", defaultBase);
+            if (baseUrlInput === undefined) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            const baseUrl = baseUrlInput.trim();
+            if (!baseUrl) {
+                this.showWarning("Custom provider base URL cannot be empty.");
+                return;
+            }
+            nextProvider.baseUrl = baseUrl;
+            const defaultApiKeyEnv = (config.provider.type === "custom_openai" ? config.provider.apiKeyEnv : undefined) ?? "OPENAI_API_KEY";
+            const apiKeyEnvInput = await this.showExtensionInput("/semantic setup: custom API key env (optional)", defaultApiKeyEnv);
+            if (apiKeyEnvInput === undefined) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            nextProvider.apiKeyEnv = apiKeyEnvInput.trim() || undefined;
+            const modelInput = await this.showExtensionInput("/semantic setup: custom model", currentModel);
+            if (modelInput === undefined) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            const normalizedModel = modelInput.trim();
+            if (!normalizedModel) {
+                this.showWarning("Model cannot be empty.");
+                return;
+            }
+            model = normalizedModel;
+        }
+        else {
+            nextProvider.baseUrl = undefined;
+            nextProvider.apiKeyEnv = undefined;
+            let openRouterModels = [];
+            try {
+                openRouterModels = await listOpenRouterEmbeddingModels({
+                    timeoutMs: nextProvider.timeoutMs,
+                    authStorage: this.session.modelRegistry.authStorage,
+                });
+                if (openRouterModels.length === 0) {
+                    this.showWarning("OpenRouter embeddings catalog is empty. You can enter model manually.");
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.showWarning(`Failed to load OpenRouter embedding models automatically: ${errorMsg}`);
+            }
+            const selectedModel = await this.selectSemanticModelFromCatalog("/semantic setup: openrouter model", openRouterModels, currentModel || providerDefaults.openrouter);
+            if (!selectedModel) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            model = selectedModel;
+        }
+        nextProvider.model = model;
+        while (true) {
+            const headersInput = await this.showExtensionInput("/semantic setup: headers (optional KEY=VALUE,CSV; press Enter to skip)", "");
+            if (headersInput === undefined) {
+                this.showStatus("Semantic setup cancelled");
+                return;
+            }
+            const parsedHeaders = this.parseMcpKeyValueMapInput(headersInput);
+            if (parsedHeaders.error) {
+                this.showWarning(parsedHeaders.error);
+                continue;
+            }
+            nextProvider.headers = parsedHeaders.value;
+            break;
+        }
+        const nextConfig = {
+            ...config,
+            enabled: true,
+            provider: nextProvider,
+        };
+        const savedPath = upsertScopedSemanticSearchConfig(scope, nextConfig, cwd, agentDir);
+        if (providerType === "openrouter") {
+            await this.ensureOpenRouterSemanticCredentials();
+        }
+        this.showStatus(`Semantic setup saved (${scope})`);
+        this.showCommandTextBlock("Semantic Setup", [
+            `scope: ${scope}`,
+            `provider: ${this.getSemanticSetupProviderLabel(providerType)}`,
+            `model: ${nextProvider.model}`,
+            `config: ${savedPath}`,
+            `index_dir: ${getSemanticIndexDir(cwd, agentDir)}`,
+        ].join("\n"));
+    }
+    async runSemanticInteractiveMenu() {
+        while (true) {
+            let status;
+            try {
+                status = await this.createSemanticRuntime().status();
+            }
+            catch (error) {
+                this.reportSemanticError(error, "status");
+            }
+            const summary = status
+                ? `configured=${status.configured ? "yes" : "no"} indexed=${status.indexed ? "yes" : "no"} stale=${status.stale ? "yes" : "no"}`
+                : "status unavailable";
+            const selected = await this.showExtensionSelector(`/semantic manager\n${summary}`, [
+                "Configure provider/model",
+                "Show status",
+                "Index now",
+                "Rebuild index",
+                "Query index",
+                "Show config/index paths",
+                "Close",
+            ]);
+            if (!selected || selected === "Close") {
+                return;
+            }
+            if (selected === "Configure provider/model") {
+                await this.runSemanticSetupWizard();
+                continue;
+            }
+            if (selected === "Show status") {
+                try {
+                    const result = await this.runWithExtensionLoader("Checking semantic index status...", async () => this.createSemanticRuntime().status());
+                    this.showCommandTextBlock("Semantic Status", this.formatSemanticStatusReport(result));
+                }
+                catch (error) {
+                    this.reportSemanticError(error, "status");
+                }
+                continue;
+            }
+            if (selected === "Index now") {
+                try {
+                    const result = await this.runWithExtensionLoader("Indexing semantic embeddings...", async () => this.createSemanticRuntime().index());
+                    this.showStatus(`Semantic index updated (${result.processedFiles} files).`);
+                    this.showCommandTextBlock("Semantic Index", this.formatSemanticIndexReport(result));
+                }
+                catch (error) {
+                    this.reportSemanticError(error, "index");
+                }
+                continue;
+            }
+            if (selected === "Rebuild index") {
+                try {
+                    const result = await this.runWithExtensionLoader("Rebuilding semantic index...", async () => this.createSemanticRuntime().rebuild());
+                    this.showStatus(`Semantic index rebuilt (${result.processedFiles} files).`);
+                    this.showCommandTextBlock("Semantic Rebuild", this.formatSemanticIndexReport(result));
+                }
+                catch (error) {
+                    this.reportSemanticError(error, "rebuild");
+                }
+                continue;
+            }
+            if (selected === "Query index") {
+                const queryInput = await this.showExtensionInput("/semantic query", "where auth token is validated");
+                if (queryInput === undefined)
+                    continue;
+                const query = queryInput.trim();
+                if (!query) {
+                    this.showWarning("Semantic query cannot be empty.");
+                    continue;
+                }
+                const topKInput = await this.showExtensionInput("/semantic query: top-k (optional, 1..20)", "8");
+                if (topKInput === undefined)
+                    continue;
+                const topKRaw = topKInput.trim();
+                let topK = undefined;
+                if (topKRaw) {
+                    const parsed = Number.parseInt(topKRaw, 10);
+                    if (!Number.isFinite(parsed) || parsed < 1 || parsed > 20) {
+                        this.showWarning("top-k must be an integer between 1 and 20.");
+                        continue;
+                    }
+                    topK = parsed;
+                }
+                try {
+                    const result = await this.runWithExtensionLoader("Querying semantic index...", async () => this.createSemanticRuntime().query(query, topK));
+                    this.showCommandTextBlock("Semantic Query", this.formatSemanticQueryReport(result));
+                }
+                catch (error) {
+                    this.reportSemanticError(error, "query");
+                }
+                continue;
+            }
+            if (selected === "Show config/index paths") {
+                const runtime = this.createSemanticRuntime();
+                const cwd = this.sessionManager.getCwd();
+                const agentDir = getAgentDir();
+                try {
+                    const semanticStatus = await this.runWithExtensionLoader("Loading semantic paths...", async () => runtime.status());
+                    this.showCommandTextBlock("Semantic Paths", [
+                        `user_config: ${getSemanticConfigPath("user", cwd, agentDir)}`,
+                        `project_config: ${getSemanticConfigPath("project", cwd, agentDir)}`,
+                        `index_dir: ${semanticStatus.indexPath}`,
+                    ].join("\n"));
+                }
+                catch (error) {
+                    this.reportSemanticError(error, "status");
+                }
+                continue;
+            }
+        }
+    }
+    reportSemanticError(error, context) {
+        if (error instanceof SemanticConfigMissingError) {
+            this.showWarning("Semantic search is not configured. Run /semantic setup.");
+            this.showCommandTextBlock("Semantic Config", [
+                `user_config: ${error.userConfigPath}`,
+                `project_config: ${error.projectConfigPath}`,
+                "next: /semantic setup",
+            ].join("\n"));
+            return;
+        }
+        if (error instanceof SemanticRebuildRequiredError) {
+            this.showWarning(error.message);
+            this.showWarning("Run /semantic rebuild.");
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.showError(`Semantic ${context} failed: ${message}`);
+    }
+    async handleSemanticCommand(text) {
+        const args = this.parseSlashArgs(text).slice(1);
+        if (args.length === 0 || (args[0]?.toLowerCase() ?? "") === "ui") {
+            await this.runSemanticInteractiveMenu();
+            return;
+        }
+        const subcommand = (args[0] ?? "").toLowerCase();
+        const rest = args.slice(1);
+        if (subcommand === "help" || subcommand === "-h" || subcommand === "--help") {
+            this.showCommandTextBlock("Semantic Help", [
+                "Usage:",
+                "  /semantic",
+                "  /semantic ui",
+                "  /semantic setup [--scope user|project]",
+                "  /semantic status",
+                "  /semantic index",
+                "  /semantic rebuild",
+                "  /semantic query <text> [--top-k N]",
+                "  /semantic help",
+            ].join("\n"));
+            return;
+        }
+        if (subcommand === "setup") {
+            const parsedScope = this.parseSemanticScopeOptions(rest);
+            if (parsedScope.error) {
+                this.showWarning(parsedScope.error);
+                return;
+            }
+            if (parsedScope.rest.length > 0) {
+                this.showWarning(`Unexpected arguments for /semantic setup: ${parsedScope.rest.join(" ")}`);
+                return;
+            }
+            await this.runSemanticSetupWizard(parsedScope.scope);
+            return;
+        }
+        if (subcommand === "status") {
+            try {
+                const result = await this.runWithExtensionLoader("Checking semantic index status...", async () => this.createSemanticRuntime().status());
+                this.showCommandTextBlock("Semantic Status", this.formatSemanticStatusReport(result));
+            }
+            catch (error) {
+                this.reportSemanticError(error, "status");
+            }
+            return;
+        }
+        if (subcommand === "index") {
+            try {
+                const result = await this.runWithExtensionLoader("Indexing semantic embeddings...", async () => this.createSemanticRuntime().index());
+                this.showStatus(`Semantic index updated (${result.processedFiles} files).`);
+                this.showCommandTextBlock("Semantic Index", this.formatSemanticIndexReport(result));
+            }
+            catch (error) {
+                this.reportSemanticError(error, "index");
+            }
+            return;
+        }
+        if (subcommand === "rebuild") {
+            try {
+                const result = await this.runWithExtensionLoader("Rebuilding semantic index...", async () => this.createSemanticRuntime().rebuild());
+                this.showStatus(`Semantic index rebuilt (${result.processedFiles} files).`);
+                this.showCommandTextBlock("Semantic Rebuild", this.formatSemanticIndexReport(result));
+            }
+            catch (error) {
+                this.reportSemanticError(error, "rebuild");
+            }
+            return;
+        }
+        if (subcommand === "query") {
+            const parsed = this.parseSemanticTopKOptions(rest);
+            if (parsed.error) {
+                this.showWarning(parsed.error);
+                return;
+            }
+            const query = parsed.rest.join(" ").trim();
+            if (!query) {
+                this.showWarning("Usage: /semantic query <text> [--top-k N]");
+                return;
+            }
+            try {
+                const result = await this.runWithExtensionLoader("Querying semantic index...", async () => this.createSemanticRuntime().query(query, parsed.topK));
+                this.showCommandTextBlock("Semantic Query", this.formatSemanticQueryReport(result));
+            }
+            catch (error) {
+                this.reportSemanticError(error, "query");
+            }
+            return;
+        }
+        this.showWarning(`Unknown /semantic subcommand "${subcommand}". Use /semantic help.`);
+    }
     parseCheckpointNameFromLabel(label) {
         if (!label)
             return undefined;
@@ -5680,6 +6314,7 @@ export class InteractiveMode {
         const hasModelIssues = checks.some((check) => (check.label === "Active model" || check.label === "Active model auth" || check.label === "Available models") &&
             check.level === "fail");
         const hasMcpIssues = checks.some((check) => check.label === "MCP servers" && check.level !== "ok");
+        const hasSemanticIssues = checks.some((check) => check.label === "Semantic index" && check.level !== "ok");
         const hasResourceIssues = checks.some((check) => check.label === "Resources" && check.level !== "ok");
         while (true) {
             const options = [];
@@ -5693,6 +6328,9 @@ export class InteractiveMode {
                 }
                 options.push("Refresh MCP runtime");
             }
+            if (hasSemanticIssues) {
+                options.push("Open semantic manager");
+            }
             if (this.permissionMode === "yolo") {
                 options.push("Set permissions mode to ask");
             }
@@ -5723,6 +6361,10 @@ export class InteractiveMode {
                 this.showStatus("MCP servers refreshed");
                 continue;
             }
+            if (selected === "Open semantic manager") {
+                await this.handleSemanticCommand("/semantic");
+                return;
+            }
             if (selected === "Set permissions mode to ask") {
                 this.permissionMode = "ask";
                 this.settingsManager.setPermissionMode("ask");
@@ -5734,7 +6376,15 @@ export class InteractiveMode {
                 return;
             }
             if (selected === "Show auth/models paths") {
-                this.showCommandTextBlock("Runtime Paths", [`auth.json: ${getAuthPath()}`, `models.json: ${getModelsPath()}`].join("\n"));
+                const cwd = this.sessionManager.getCwd();
+                const agentDir = getAgentDir();
+                this.showCommandTextBlock("Runtime Paths", [
+                    `auth.json: ${getAuthPath()}`,
+                    `models.json: ${getModelsPath()}`,
+                    `semantic(user): ${getSemanticConfigPath("user", cwd, agentDir)}`,
+                    `semantic(project): ${getSemanticConfigPath("project", cwd, agentDir)}`,
+                    `semantic(index): ${getSemanticIndexDir(cwd, agentDir)}`,
+                ].join("\n"));
                 continue;
             }
         }
@@ -5761,6 +6411,14 @@ export class InteractiveMode {
         const mcpDisabled = mcpStatuses.filter((status) => !status.enabled).length;
         const cliToolStatuses = resolveDoctorCliToolStatuses();
         const missingCliTools = cliToolStatuses.filter((status) => !status.available).map((status) => status.tool);
+        let semanticStatus;
+        let semanticStatusError;
+        try {
+            semanticStatus = await this.createSemanticRuntime().status();
+        }
+        catch (error) {
+            semanticStatusError = error instanceof Error ? error.message : String(error);
+        }
         const checks = [];
         const addCheck = (level, label, detail, fix) => checks.push({ level, label, detail, fix });
         if (!model) {
@@ -5802,6 +6460,31 @@ export class InteractiveMode {
         else {
             addCheck("ok", "MCP servers", `${mcpConnected} connected, ${mcpDisabled} disabled`);
         }
+        if (semanticStatusError) {
+            addCheck("fail", "Semantic index", semanticStatusError, "Run /semantic setup and retry /semantic status.");
+        }
+        else if (!semanticStatus) {
+            addCheck("warn", "Semantic index", "Status unavailable", "Run /semantic setup.");
+        }
+        else if (!semanticStatus.configured) {
+            addCheck("warn", "Semantic index", "Not configured", `Run /semantic setup (user: ${semanticStatus.configPathUser} or project: ${semanticStatus.configPathProject}).`);
+        }
+        else if (!semanticStatus.enabled) {
+            addCheck("warn", "Semantic index", "Configured but disabled", "Enable semanticSearch.enabled or rerun /semantic setup.");
+        }
+        else if (!semanticStatus.indexed) {
+            addCheck("warn", "Semantic index", "Configured but index is missing", "Run /semantic index.");
+        }
+        else if (semanticStatus.stale) {
+            const requiresRebuild = semanticStatus.staleReason === "provider_changed" ||
+                semanticStatus.staleReason === "chunking_changed" ||
+                semanticStatus.staleReason === "index_filters_changed" ||
+                semanticStatus.staleReason === "dimension_mismatch";
+            addCheck("warn", "Semantic index", `Indexed but stale${semanticStatus.staleReason ? ` (${semanticStatus.staleReason})` : ""}`, requiresRebuild ? "Run /semantic rebuild." : "Run /semantic index.");
+        }
+        else {
+            addCheck("ok", "Semantic index", `${semanticStatus.provider}/${semanticStatus.model} · files=${semanticStatus.files} chunks=${semanticStatus.chunks}`);
+        }
         if (missingCliTools.length > 0) {
             addCheck("warn", "CLI toolchain", `${cliToolStatuses.length - missingCliTools.length}/${cliToolStatuses.length} available (missing: ${missingCliTools.join(", ")})`, `Install missing CLI tools: ${missingCliTools.join(", ")}.`);
         }