@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/integrations/pi/engine/resource-catalog.js

@@ -0,0 +1,289 @@
+import { isRecord, stringProperty } from "./message-values.js";
+import { PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
+/**
+ * The resources pinned Pi's loader discovered for the current runtime (skills, prompt templates,
+ * agent context files, system prompts, themes, extensions) and the slash-command autocomplete
+ * entries derived from them, shaped for the owned shell with the loader's diagnostics carried
+ * along instead of thrown. Reads only; the runtime and session are reached through ports.
+ */
+export class PiResourceCatalog {
+    #ports;
+    #contexts;
+    constructor(options, ports) {
+        this.#contexts = options.contexts;
+        this.#ports = ports;
+    }
+    nonVisualResources() {
+        const loader = this.#ports.runtime()?.services.resourceLoader;
+        if (!loader)
+            return [];
+        const resources = [];
+        const skills = collectionResult(loader.getSkills(), "skills");
+        for (const [index, skill] of skills.values.entries()) {
+            resources.push({
+                kind: "skill",
+                id: `skill-${index}-${stringProperty(skill, "name") ?? "unknown"}`,
+                label: stringProperty(skill, "name") ?? "Unnamed skill",
+                sourcePath: stringProperty(skill, "filePath") ?? stringProperty(skill, "path") ?? stringProperty(skill, "location") ?? null,
+                diagnostic: null,
+            });
+        }
+        resources.push(...skills.diagnostics.map((diagnostic, index) => ({
+            kind: "skill",
+            id: `skill-diagnostic-${index}`,
+            label: "Skill diagnostic",
+            sourcePath: null,
+            diagnostic,
+        })));
+        const prompts = collectionResult(loader.getPrompts(), "prompts");
+        for (const [index, prompt] of prompts.values.entries()) {
+            resources.push({
+                kind: "prompt-template",
+                id: `prompt-${index}-${stringProperty(prompt, "name") ?? "unknown"}`,
+                label: stringProperty(prompt, "name") ?? "Prompt template",
+                sourcePath: stringProperty(prompt, "filePath") ?? stringProperty(prompt, "path") ?? null,
+                diagnostic: null,
+            });
+        }
+        resources.push(...prompts.diagnostics.map((diagnostic, index) => ({
+            kind: "prompt-template",
+            id: `prompt-diagnostic-${index}`,
+            label: "Prompt diagnostic",
+            sourcePath: null,
+            diagnostic,
+        })));
+        const agentsFilesResult = loader.getAgentsFiles();
+        const agentsFiles = unknownArray(isRecord(agentsFilesResult) ? agentsFilesResult.agentsFiles : undefined);
+        for (const [index, file] of agentsFiles.entries()) {
+            resources.push({
+                kind: "agent-context",
+                id: `agent-context-${index}`,
+                label: "Agent context",
+                sourcePath: stringProperty(file, "path") ?? null,
+                diagnostic: null,
+            });
+        }
+        const systemPrompt = loader.getSystemPromptSource();
+        if (isRecord(systemPrompt) && typeof systemPrompt.path === "string") {
+            resources.push({
+                kind: "system-prompt",
+                id: "system-prompt",
+                label: "System prompt",
+                sourcePath: systemPrompt.path,
+                diagnostic: null,
+            });
+        }
+        for (const [index, source] of unknownArray(loader.getAppendSystemPromptSources()).entries()) {
+            resources.push({
+                kind: "system-prompt",
+                id: `append-system-prompt-${index}`,
+                label: "Append system prompt",
+                sourcePath: stringProperty(source, "path") ?? null,
+                diagnostic: null,
+            });
+        }
+        if (loader.getThemes !== undefined) {
+            const themes = collectionResult(loader.getThemes(), "themes");
+            for (const [index, theme] of themes.values.entries()) {
+                const sourcePath = stringProperty(theme, "sourcePath");
+                if (!sourcePath)
+                    continue;
+                resources.push({
+                    kind: "theme",
+                    id: `theme-${index}-${stringProperty(theme, "name") ?? "unknown"}`,
+                    label: stringProperty(theme, "name") ?? compactResourceLabel(sourcePath),
+                    sourcePath,
+                    diagnostic: null,
+                });
+            }
+            resources.push(...themes.diagnostics.map((diagnostic, index) => ({
+                kind: "theme",
+                id: `theme-diagnostic-${index}`,
+                label: "Theme diagnostic",
+                sourcePath: null,
+                diagnostic,
+            })));
+        }
+        return resources;
+    }
+    extensionResources() {
+        const loader = this.#ports.runtime()?.services.resourceLoader;
+        if (loader?.getExtensions === undefined)
+            return [];
+        let result;
+        try {
+            result = loader.getExtensions();
+        }
+        catch (error) {
+            return [extensionResourceDiagnostic(0, null, `Extension discovery failed: ${error instanceof Error ? error.message : String(error)}`)];
+        }
+        if (!isRecord(result))
+            return [extensionResourceDiagnostic(0, null, "Extension discovery returned a malformed result")];
+        const resources = [];
+        if (!Array.isArray(result.extensions)) {
+            resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned a malformed extensions collection"));
+        }
+        else {
+            for (const extension of result.extensions) {
+                if (!isRecord(extension) || typeof extension.path !== "string" || extension.path.length === 0
+                    || typeof extension.resolvedPath !== "string" || extension.resolvedPath.length === 0
+                    || (extension.hidden !== undefined && typeof extension.hidden !== "boolean")) {
+                    resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned malformed extension metadata"));
+                    continue;
+                }
+                resources.push({
+                    kind: "extension",
+                    id: `extension-${resources.length}`,
+                    sourcePath: extension.path,
+                    resolvedPath: extension.resolvedPath,
+                    sourceInfo: extensionSourceSummary(extension.sourceInfo),
+                    loaded: true,
+                    hidden: extension.hidden === true,
+                    diagnostic: null,
+                });
+            }
+        }
+        if (!Array.isArray(result.errors)) {
+            resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned a malformed errors collection"));
+        }
+        else {
+            for (const error of result.errors) {
+                if (!isRecord(error) || typeof error.path !== "string" || typeof error.error !== "string") {
+                    resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned malformed error metadata"));
+                    continue;
+                }
+                resources.push(extensionResourceDiagnostic(resources.length, error.path, error.error));
+            }
+        }
+        return resources;
+    }
+    workflowAutocompleteCommands() {
+        const commands = [
+            {
+                name: "model",
+                description: "Select model (opens selector UI)",
+                argumentHint: "<provider/model>",
+                argumentOptions: this.#contexts.modelOptions(),
+                source: "builtin",
+            },
+            {
+                name: "login",
+                description: "Configure provider authentication",
+                argumentHint: "<provider>",
+                argumentOptions: this.#contexts.loginOptions().map(option => ({ ...option, id: option.id.split(":").at(-1) ?? option.id })),
+                source: "builtin",
+            },
+        ];
+        const usedNames = new Set(PINNED_PI_WORKFLOW_COMMAND_NAMES);
+        const loader = this.#ports.runtime()?.services.resourceLoader;
+        if (!loader)
+            return commands;
+        const prompts = collectionResult(loader.getPrompts(), "prompts");
+        for (const prompt of prompts.values) {
+            const name = stringProperty(prompt, "name");
+            if (!name || usedNames.has(name))
+                continue;
+            const argumentHint = stringProperty(prompt, "argumentHint");
+            commands.push({
+                name,
+                description: stringProperty(prompt, "description") ?? "Prompt template",
+                ...(argumentHint === undefined ? {} : { argumentHint }),
+                source: "prompt",
+            });
+            usedNames.add(name);
+        }
+        const settings = this.#ports.runtime()?.services.settingsManager;
+        const skillsEnabled = settings?.getEnableSkillCommands?.() !== false;
+        if (skillsEnabled) {
+            const skills = collectionResult(loader.getSkills(), "skills");
+            for (const skill of skills.values) {
+                const resourceName = stringProperty(skill, "name");
+                const name = resourceName ? `skill:${resourceName}` : undefined;
+                if (!name || usedNames.has(name))
+                    continue;
+                commands.push({ name, description: stringProperty(skill, "description") ?? "Skill", source: "skill" });
+                usedNames.add(name);
+            }
+        }
+        const extensionCommands = this.#ports.session()?.extensionRunner?.getRegisteredCommands?.();
+        if (Array.isArray(extensionCommands)) {
+            const registered = extensionCommands.filter(isRecord);
+            for (const command of registered) {
+                const name = stringProperty(command, "invocationName") ?? stringProperty(command, "name");
+                if (!name || usedNames.has(name) || isPiPrefixedCompatibilityAlias(command, registered))
+                    continue;
+                commands.push({ name, description: stringProperty(command, "description") ?? "Extension command", source: "extension" });
+                usedNames.add(name);
+            }
+        }
+        return commands;
+    }
+}
+function extensionResourceDiagnostic(index, sourcePath, diagnostic) {
+    return {
+        kind: "extension",
+        id: `extension-diagnostic-${index}`,
+        sourcePath,
+        resolvedPath: null,
+        sourceInfo: null,
+        loaded: false,
+        hidden: false,
+        diagnostic,
+    };
+}
+function extensionSourceSummary(value) {
+    if (!isRecord(value))
+        return null;
+    const source = stringProperty(value, "source");
+    const scope = value.scope;
+    const origin = value.origin;
+    const baseDir = value.baseDir;
+    if (!source
+        || (scope !== "user" && scope !== "project" && scope !== "temporary")
+        || (origin !== "package" && origin !== "top-level")
+        || (baseDir !== undefined && typeof baseDir !== "string"))
+        return null;
+    return { source, scope, origin, baseDir: baseDir ?? null };
+}
+export function collectionResult(value, key) {
+    if (!isRecord(value))
+        return { values: [], diagnostics: [] };
+    const diagnostics = unknownArray(value.diagnostics).map(diagnostic => {
+        if (typeof diagnostic === "string")
+            return diagnostic;
+        if (isRecord(diagnostic)) {
+            const message = stringProperty(diagnostic, "message") ?? String(diagnostic);
+            const path = stringProperty(diagnostic, "path");
+            return path ? `${path}: ${message}` : message;
+        }
+        return String(diagnostic);
+    });
+    return { values: unknownArray(value[key]), diagnostics };
+}
+function unknownArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * Some ecosystem extensions retain a `pi-<name>` slash-command alias beside
+ * their unprefixed command. A1 presents the product-neutral command once while
+ * leaving Pi's runner free to accept the compatibility alias when typed.
+ */
+function isPiPrefixedCompatibilityAlias(command, commands) {
+    const name = stringProperty(command, "name");
+    if (!name?.startsWith("pi-") || name.length === 3)
+        return false;
+    const canonicalName = name.slice(3);
+    const description = stringProperty(command, "description");
+    const sourcePath = extensionCommandSourcePath(command);
+    return commands.some(candidate => candidate !== command
+        && stringProperty(candidate, "name") === canonicalName
+        && stringProperty(candidate, "description") === description
+        && extensionCommandSourcePath(candidate) === sourcePath);
+}
+function extensionCommandSourcePath(command) {
+    return isRecord(command) ? stringProperty(command.sourceInfo, "path") : undefined;
+}
+function compactResourceLabel(path) {
+    const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
+    return segments.at(-1) ?? path;
+}