@caupulican/pi-adaptative 0.80.94 → 0.80.96

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

@@ -22,6 +22,10 @@ import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/htt
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
 import { cliProviderAliases, defaultModelPerProvider, findExactModelReferenceMatch, resolveCliModel, resolveModelScope, } from "../../core/model-resolver.js";
+import { FitnessStore } from "../../core/models/fitness-store.js";
+import { registerLocalModel, unregisterLocalModel } from "../../core/models/local-registration.js";
+import { OllamaRuntime } from "../../core/models/local-runtime.js";
+import { normalizeModelSource } from "../../core/models/model-ref.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
 import { getPendingReloadBlockers } from "../../core/reload-blockers.js";
@@ -2478,6 +2482,11 @@ export class InteractiveMode {
                 }
                 return;
             }
+            if (text === "/models" || text.startsWith("/models ")) {
+                void this.handleModelsCommand(text.slice("/models".length).trim());
+                this.editor.setText("");
+                return;
+            }
             if (text === "/context") {
                 this.showStatus(this.session.formatContextCompositionDashboard());
                 this.editor.setText("");
@@ -5129,6 +5138,172 @@ export class InteractiveMode {
         this.settingsManager.setAutoLearnSettings(preset, scope);
         this.updateAutoLearnFooter();
     }
+    _localRuntime;
+    get localRuntime() {
+        this._localRuntime ??= new OllamaRuntime({ agentDir: getAgentDir() });
+        return this._localRuntime;
+    }
+    /**
+     * /models — USER-invoked local model lifecycle (never a model-invokable tool):
+     * list/add/remove/stop per local-model-lifecycle-design.md. Removal is explicit-only with
+     * full disclosure; a pasted install command is parsed for its ref, never executed.
+     */
+    async handleModelsCommand(argsText) {
+        const [action = "list", ...rest] = argsText.split(/\s+/).filter(Boolean);
+        try {
+            if (action === "stop") {
+                const stopped = this.localRuntime.stop();
+                this.showStatus(stopped.stopped
+                    ? "Pi-managed local model server stopped (models remain installed)."
+                    : "No pi-managed server running (a system server, if any, is not pi's to stop).");
+                return;
+            }
+            if (action === "add") {
+                const rawRef = rest.join(" ");
+                if (!rawRef) {
+                    this.showStatus("Usage: /models add <ollama-tag | hf.co/org/repo[:quant] | huggingface URL | pasted install command>");
+                    return;
+                }
+                const source = normalizeModelSource(rawRef);
+                if (source.type === "rejected") {
+                    this.showStatus(`Not added: ${source.reason}`);
+                    return;
+                }
+                if (source.type === "api") {
+                    this.showStatus(`${source.ref} is an API model — nothing to install. Configure auth for the provider, then probe it with /fitness ${source.ref}.`);
+                    return;
+                }
+                await this.addLocalModel(source.pullRef);
+                return;
+            }
+            if (action === "remove") {
+                const ref = rest[0];
+                const confirmed = rest[1] === "confirm";
+                if (!ref) {
+                    this.showStatus("Usage: /models remove <ref> confirm");
+                    return;
+                }
+                await this.removeLocalModel(ref, confirmed);
+                return;
+            }
+            await this.listLocalModels();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async ensureLocalServer() {
+        const status = await this.localRuntime.detect();
+        if (status.serverUp)
+            return true;
+        if (!status.binaryPath) {
+            for (const line of this.localRuntime.installGuide())
+                this.showStatus(line);
+            return false;
+        }
+        this.showStatus(`Starting local model server (${status.binarySource} binary, owned storage: ${status.ownedModelsDir})…`);
+        const started = await this.localRuntime.start();
+        if (!started.started) {
+            this.showStatus(`Could not start the local server: ${started.reason}`);
+            return false;
+        }
+        return true;
+    }
+    async listLocalModels() {
+        const status = await this.localRuntime.detect();
+        if (!status.serverUp) {
+            if (!status.binaryPath) {
+                for (const line of this.localRuntime.installGuide())
+                    this.showStatus(line);
+                return;
+            }
+            this.showStatus(`Local server not running (binary: ${status.binarySource}). /models add starts it on demand; /fitness probes registered models.`);
+            return;
+        }
+        const models = await this.localRuntime.list();
+        const fitness = FitnessStore.forAgentDir(getAgentDir()).getForHost();
+        const lines = [
+            `Local models (${status.managedByPi ? `pi-managed server, storage: ${status.ownedModelsDir}` : "system server — storage owned by the system daemon"}):`,
+            ...(models.length === 0 ? ["  (none installed — /models add <ref>)"] : []),
+            ...models.map((model) => {
+                const report = fitness.find((entry) => entry.model === `ollama/${model.name}`);
+                const gb = (model.sizeBytes / 1e9).toFixed(2);
+                const probe = report
+                    ? `probed ${report.at.slice(0, 10)}: digest ${report.report.digest?.succeeded ?? "?"}/${report.report.digest?.total ?? "?"}, tool-calls ${report.report.toolCall.succeeded}/${report.report.toolCall.total}${report.report.tokensPerSecond ? `, ~${report.report.tokensPerSecond} tok/s` : ""}`
+                    : `unprobed — run /fitness ollama/${model.name}`;
+                return `  - ${model.name} (${gb} GB) · ${probe}`;
+            }),
+            "Commands: /models add <ref> · /models remove <ref> confirm · /models stop",
+        ];
+        for (const line of lines)
+            this.showStatus(line);
+    }
+    async addLocalModel(pullRef) {
+        if (!(await this.ensureLocalServer()))
+            return;
+        this.showStatus(`Pulling ${pullRef}… (weights land in the server's model storage)`);
+        let lastShown = 0;
+        const pulled = await this.localRuntime.pull(pullRef, (progress) => {
+            const now = Date.now();
+            if (now - lastShown > 2000) {
+                lastShown = now;
+                this.showStatus(`  ${pullRef}: ${progress}`);
+            }
+        });
+        if (!pulled.ok) {
+            this.showStatus(`Pull failed: ${pulled.error}`);
+            return;
+        }
+        const registration = registerLocalModel({
+            agentDir: getAgentDir(),
+            ref: pullRef,
+            baseUrl: this.localRuntime.baseUrl,
+        });
+        if (!registration.ok) {
+            this.showStatus(`Pulled, but not auto-registered: ${registration.reason}`);
+            if (registration.manualSnippet) {
+                this.showStatus(`Add this to ${registration.modelsJsonPath} yourself:\n${registration.manualSnippet}`);
+            }
+            return;
+        }
+        this.session.modelRegistry.refresh();
+        this.showStatus(`${pullRef} installed and registered as ollama/${pullRef}. Probing fitness…`);
+        await this.runFitnessAndAssign(`ollama/${pullRef}`);
+    }
+    async removeLocalModel(ref, confirmed) {
+        const status = await this.localRuntime.detect();
+        if (!status.serverUp) {
+            this.showStatus("Local server not running — start it (any /models action) before removing.");
+            return;
+        }
+        const models = await this.localRuntime.list();
+        const target = models.find((model) => model.name === ref);
+        if (!target) {
+            this.showStatus(`${ref} is not installed. Installed: ${models.map((model) => model.name).join(", ") || "(none)"}`);
+            return;
+        }
+        if (!confirmed) {
+            // EXPLICIT USER ACTION ONLY: full disclosure, then require the confirm token.
+            const gb = (target.sizeBytes / 1e9).toFixed(2);
+            this.showStatus([
+                `Removing ${ref} will delete:`,
+                `  - model weights (${gb} GB) from ${status.managedByPi ? status.ownedModelsDir : "the system server's storage"}`,
+                `  - the ollama/${ref} entry in models.json`,
+                `  - its cached fitness report for this host`,
+                `Run: /models remove ${ref} confirm`,
+            ].join("\n"));
+            return;
+        }
+        const removed = await this.localRuntime.remove(ref);
+        if (!removed.ok) {
+            this.showStatus(`Remove failed: ${removed.error}`);
+            return;
+        }
+        unregisterLocalModel({ agentDir: getAgentDir(), ref });
+        FitnessStore.forAgentDir(getAgentDir()).remove(`ollama/${ref}`);
+        this.session.modelRegistry.refresh();
+        this.showStatus(`${ref} removed: weights deleted, registration and fitness report dropped.`);
+    }
     /** /fitness with no args: pick a model from the configured registry, probe it, assign a role. */
     showFitnessModelSelector() {
         this.showSelector((done) => {