@caupulican/pi-adaptative 0.80.44 → 0.80.46

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

@@ -24,6 +24,7 @@ import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-nam
 import { getPendingReloadBlockers } from "../../core/reload-blockers.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { isAutoLearnSessionId, SessionManager } from "../../core/session-manager.js";
+import { validateSkillName } from "../../core/skills.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { isInstallTelemetryEnabled } from "../../core/telemetry.js";
 import { allToolNames } from "../../core/tools/index.js";
@@ -61,7 +62,7 @@ import { ProfileResourceEditorComponent, } from "./components/profile-resource-e
 import { ProfileSelectorComponent } from "./components/profile-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
-import { SettingsSelectorComponent } from "./components/settings-selector.js";
+import { SelectSubmenu, SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { ToolGroupComponent } from "./components/tool-group.js";
@@ -4925,6 +4926,8 @@ export class InteractiveMode {
                     : undefined,
                 activeProfileName: this.settingsManager.getActiveResourceProfileNames()[0],
                 profileOptions,
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
+                trustedResourceRoots: this.settingsManager.getTrustedResourceRoots(),
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -5071,6 +5074,10 @@ export class InteractiveMode {
                     done();
                     void this.applyProfile(profile);
                 },
+                onProfileCreate: () => {
+                    done();
+                    void this.createProfileFlow();
+                },
                 onProfileEdit: (profileName) => {
                     done();
                     void this.openProfileResourceEditor(profileName);
@@ -5083,6 +5090,14 @@ export class InteractiveMode {
                     done();
                     this.deleteProfileFromSource(profileName);
                 },
+                onAddExternalResourceRoot: () => {
+                    done();
+                    void this.addExternalResourceRootFlow();
+                },
+                onRemoveExternalResourceRoot: (root) => {
+                    done();
+                    void this.removeExternalResourceRootFlow(root);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -5224,6 +5239,73 @@ export class InteractiveMode {
             this.updateEditorBorderColor();
         }
     }
+    async createProfileFlow() {
+        const name = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Create Profile", "Enter profile name", (value) => {
+                    done();
+                    resolve(value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (name === undefined) {
+            this.ui.requestRender();
+            return;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            this.showError("Profile name cannot be empty");
+            return this.createProfileFlow();
+        }
+        // Validate name rules using validateSkillName
+        const errors = validateSkillName(trimmed);
+        if (errors.length > 0) {
+            this.showError(`Invalid profile name: ${errors.join(", ")}`);
+            return this.createProfileFlow();
+        }
+        // Collision check
+        const existing = this.settingsManager.getProfileRegistry().getProfile(trimmed);
+        if (existing) {
+            this.showError(`Profile "${trimmed}" already exists`);
+            return this.createProfileFlow();
+        }
+        // Open the resource editor on the NEW profile
+        void this.openNewProfileEditor(trimmed);
+    }
+    async openNewProfileEditor(profileName) {
+        const scope = "reusable-file";
+        const kinds = await this.getProfileResourceKinds();
+        this.showSelector((done) => {
+            const editor = new ProfileResourceEditorComponent({
+                profileName,
+                initialResources: {},
+                kinds,
+                onSave: (resources) => {
+                    done();
+                    try {
+                        this.settingsManager.setProfileDefinition(profileName, {
+                            name: profileName,
+                            resources,
+                        }, scope);
+                        this.showStatus(`Saved profile "${profileName}" to ${scope}.`);
+                        this.ui.requestRender();
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: editor, focus: editor };
+        });
+    }
     async openProfileResourceEditor(profileName) {
         const profile = this.settingsManager.getProfileRegistry().getProfile(profileName);
         if (!profile) {
@@ -5316,6 +5398,81 @@ export class InteractiveMode {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
+    async addExternalResourceRootFlow() {
+        const rootPath = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Add External Root", "Enter external root directory path", (value) => {
+                    done();
+                    resolve(value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (rootPath === undefined) {
+            this.ui.requestRender();
+            return;
+        }
+        const trimmed = rootPath.trim();
+        if (!trimmed) {
+            this.showError("Directory path cannot be empty");
+            return;
+        }
+        const canonical = this.settingsManager.canonicalizePath(trimmed);
+        if (!canonical) {
+            this.showError(`Invalid path: ${trimmed}`);
+            return;
+        }
+        // Prompt for trust confirmation (Yes/No)
+        const trust = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const submenu = new SelectSubmenu("Trust external source?", "This directory can load custom extensions that execute arbitrary code on your machine.", [
+                    { value: "yes", label: "Yes", description: "Trust this directory and enable loading resources." },
+                    { value: "no", label: "No", description: "Do not trust this directory. Skip loading resources." },
+                ], "no", (value) => {
+                    done();
+                    resolve(value === "yes");
+                }, () => {
+                    done();
+                    resolve(false);
+                });
+                return { component: submenu, focus: submenu.getSelectList() };
+            });
+        });
+        if (!trust) {
+            this.showStatus("Aborted. External root was not trusted.");
+            return;
+        }
+        try {
+            const currentRoots = this.settingsManager.getExternalResourceRoots();
+            if (!currentRoots.includes(canonical)) {
+                this.settingsManager.setExternalResourceRoots([...currentRoots, canonical], "global");
+            }
+            this.settingsManager.addTrustedResourceRoot(canonical, "global");
+            this.showStatus(`Added trusted external root: ${canonical}`);
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async removeExternalResourceRootFlow(root) {
+        try {
+            const currentRoots = this.settingsManager.getExternalResourceRoots();
+            const currentTrusted = this.settingsManager.getTrustedResourceRoots();
+            const newRoots = currentRoots.filter((r) => r !== root);
+            const newTrusted = currentTrusted.filter((r) => r !== root);
+            this.settingsManager.setExternalResourceRoots(newRoots, "global");
+            this.settingsManager.setTrustedResourceRoots(newTrusted, "global");
+            this.showStatus(`Removed external root: ${root}`);
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
     async handleModelCommand(searchTerm) {
         if (!searchTerm) {
             await this.showModelSelector();