@evandu/super-pi 0.1.110 → 0.1.112

package/dist/server/skills.d.ts

@@ -0,0 +1,23 @@
+import type { SkillSummary } from "./types.js";
+import type { ActiveMemory } from "./active-memory.js";
+/**
+ * Loads and returns all available skills for a given workspace and global environment.
+ * Priority is given to Pi SDK's DefaultResourceLoader which scans project and user skills.
+ * Falls back to direct filesystem scanning if Pi SDK is unavailable.
+ */
+export declare function getAvailableSkills(workspacePath?: string, options?: {
+    memory?: ActiveMemory;
+    workspaceId?: string;
+}): Promise<SkillSummary[]>;
+/**
+ * Reads the markdown content of a specific skill by name or ID.
+ */
+export declare function readSkill(nameOrId: string, workspacePath?: string, options?: {
+    memory?: ActiveMemory;
+    workspaceId?: string;
+}): Promise<{
+    id: string;
+    name: string;
+    description: string;
+    content: string;
+} | null>;

package/dist/server/skills.js

@@ -0,0 +1,171 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Loads and returns all available skills for a given workspace and global environment.
+ * Priority is given to Pi SDK's DefaultResourceLoader which scans project and user skills.
+ * Falls back to direct filesystem scanning if Pi SDK is unavailable.
+ */
+export async function getAvailableSkills(workspacePath, options) {
+    const cwd = workspacePath && existsSync(workspacePath) ? workspacePath : process.cwd();
+    const skillsMap = new Map();
+    // 1. Try loading via Pi SDK DefaultResourceLoader
+    try {
+        const sdk = await import("@earendil-works/pi-coding-agent").catch(() => null);
+        if (sdk?.DefaultResourceLoader) {
+            const agentDir = join(homedir(), ".pi", "agent");
+            const loader = new sdk.DefaultResourceLoader({ cwd, agentDir });
+            await loader.reload();
+            const res = loader.getSkills();
+            if (Array.isArray(res?.skills)) {
+                for (const s of res.skills) {
+                    if (!s.name)
+                        continue;
+                    const scope = s.sourceInfo?.scope === "project" ? "workspace" : "global";
+                    skillsMap.set(s.name, {
+                        id: `skill:${s.name}`,
+                        name: s.name,
+                        description: s.description || "",
+                        scope,
+                        filePath: s.filePath,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore and proceed to filesystem fallback
+    }
+    // 2. Fallback: Direct directory scan if SDK loaded nothing or was unavailable
+    if (skillsMap.size === 0) {
+        const scanDirs = [
+            { dir: join(cwd, ".pi", "skills"), scope: "workspace" },
+            { dir: join(cwd, ".agents", "skills"), scope: "workspace" },
+            { dir: join(homedir(), ".pi", "agent", "skills"), scope: "global" },
+            { dir: join(homedir(), ".agents", "skills"), scope: "global" },
+        ];
+        for (const { dir, scope } of scanDirs) {
+            if (!existsSync(dir))
+                continue;
+            try {
+                const entries = await readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    let skillFile = "";
+                    let skillName = entry.name;
+                    if (entry.isDirectory()) {
+                        const candidate = join(dir, entry.name, "SKILL.md");
+                        if (existsSync(candidate)) {
+                            skillFile = candidate;
+                            skillName = entry.name;
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".md")) {
+                        skillFile = join(dir, entry.name);
+                        skillName = entry.name.replace(/\.md$/, "");
+                    }
+                    if (skillFile) {
+                        try {
+                            const text = await readFile(skillFile, "utf-8");
+                            const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+                            let description = "";
+                            let parsedName = skillName;
+                            if (frontmatterMatch) {
+                                const nameMatch = /^name:\s*(.+)$/m.exec(frontmatterMatch[1]);
+                                if (nameMatch)
+                                    parsedName = nameMatch[1].trim();
+                                const descMatch = /^description:\s*(.+)$/m.exec(frontmatterMatch[1]);
+                                if (descMatch)
+                                    description = descMatch[1].trim();
+                            }
+                            if (!skillsMap.has(parsedName)) {
+                                skillsMap.set(parsedName, {
+                                    id: `skill:${parsedName}`,
+                                    name: parsedName,
+                                    description,
+                                    scope,
+                                    filePath: skillFile,
+                                });
+                            }
+                        }
+                        catch {
+                            // Ignore unreadable file
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore unreadable directory
+            }
+        }
+    }
+    // 3. Optional: merge active memory notes skills if available and not colliding
+    if (options?.memory && options?.workspaceId) {
+        try {
+            const memoryEntries = await options.memory.notes.apply(options.workspaceId, "", { target: "skills", action: "list" });
+            if (Array.isArray(memoryEntries)) {
+                for (const entry of memoryEntries) {
+                    const firstLine = entry.content.split(/\r?\n/, 1)[0].replace(/^#+\s*/, "").trim();
+                    const name = firstLine || "unnamed-skill";
+                    if (!skillsMap.has(name) && !skillsMap.has(entry.id)) {
+                        skillsMap.set(`mem:${entry.id}`, {
+                            id: `skill:${entry.id}`,
+                            name,
+                            description: "Active memory skill",
+                            scope: "memory",
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Memory may not be ready or active
+        }
+    }
+    return Array.from(skillsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Reads the markdown content of a specific skill by name or ID.
+ */
+export async function readSkill(nameOrId, workspacePath, options) {
+    const cleanId = nameOrId.startsWith("skill:") ? nameOrId.slice("skill:".length) : nameOrId;
+    const skills = await getAvailableSkills(workspacePath, options);
+    const found = skills.find((s) => s.name === cleanId || s.name === nameOrId || s.id === nameOrId || s.id === `skill:${cleanId}`);
+    if (!found)
+        return null;
+    // If it's a file on disk
+    if (found.filePath && existsSync(found.filePath)) {
+        try {
+            const content = await readFile(found.filePath, "utf-8");
+            return {
+                id: found.id,
+                name: found.name,
+                description: found.description,
+                content,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    // If it's stored in active memory
+    if (found.scope === "memory" && options?.memory && options?.workspaceId) {
+        try {
+            const entryId = found.id.startsWith("skill:") ? found.id.slice("skill:".length) : found.id;
+            const memoryEntries = await options.memory.notes.apply(options.workspaceId, "", { target: "skills", action: "list" });
+            const entry = memoryEntries.find((e) => e.id === entryId || e.id === found.name);
+            if (entry) {
+                return {
+                    id: found.id,
+                    name: found.name,
+                    description: found.description,
+                    content: entry.content,
+                };
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/server/store.d.ts

@@ -91,6 +91,15 @@ export declare class Store {
      */
     setDefaultModel(model?: ModelSelection): Promise<void>;
     snapshot(): AppState;
+    /**
+     * Whether a conversation already holds a message with this id.
+     *
+     * A LIVE read with no clone, because its one caller is the send path's duplicate check: a resend
+     * that arrives within milliseconds of the original must be answered without paying for a full
+     * copy of every conversation in the app. The answer is a boolean and the message is not handed
+     * out, so nothing can mutate the store through it.
+     */
+    hasMessage(conversationId: string, messageId: string): boolean;
     /**
      * One conversation and its workspace, as DETACHED copies, without cloning the whole state.
      *

package/dist/server/store.js

@@ -684,6 +684,17 @@ export class Store {
         }
     }
     snapshot() { return structuredClone(this.state); }
+    /**
+     * Whether a conversation already holds a message with this id.
+     *
+     * A LIVE read with no clone, because its one caller is the send path's duplicate check: a resend
+     * that arrives within milliseconds of the original must be answered without paying for a full
+     * copy of every conversation in the app. The answer is a boolean and the message is not handed
+     * out, so nothing can mutate the store through it.
+     */
+    hasMessage(conversationId, messageId) {
+        return Boolean(this.state.conversations.find((item) => item.id === conversationId)?.messages.some((message) => message.id === messageId));
+    }
     /**
      * One conversation and its workspace, as DETACHED copies, without cloning the whole state.
      *

package/dist/server/types.d.ts

@@ -164,6 +164,13 @@ export type MessageAttachment = {
     content: string;
 };
 export type MessageAttachments = MessageAttachment[];
+export interface SkillSummary {
+    id: string;
+    name: string;
+    description: string;
+    scope?: "workspace" | "global" | "memory";
+    filePath?: string;
+}
 /**
  * ONE PARAMETER OF A TOOL CALL, as a call block lists it, and the boundary that keeps Pi's arguments out
  * of `state.json`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.110",
+  "version": "0.1.112",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -89,12 +89,14 @@
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
     "scripts/file-index.test.mjs",
+    "scripts/file-name-index.test.mjs",
     "scripts/file-content-search.test.mjs",
     "scripts/file-diff-client.test.mjs",
     "scripts/task-tool.test.mjs",
     "scripts/tool-register-env.test.mjs",
     "scripts/bg-task-zombie.test.mjs",
     "scripts/scoped-sidebar-tabs.test.mjs",
+    "scripts/send-retry.test.mjs",
     "scripts/git-diff-view.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
@@ -115,6 +117,7 @@
     "scripts/static-client-assets.test.mjs",
     "scripts/cli.test.mjs",
     "scripts/check-runner.test.mjs",
+    "scripts/skills-discovery.test.mjs",
     "scripts/shared-chrome.test.mjs"
   ],
   "check:browser": [

package/scripts/patch-brace-expansion.mjs

@@ -220,7 +220,7 @@ function findVulnerableCopies() {
     try { version = JSON.parse(readFileSync(manifest, "utf8")).version ?? ""; } catch { continue; }
     if (!version) continue;
     if (compareVersions(version, VULNERABLE_BELOW) >= 0) continue;
-    found.push({ directory, version, lockKey: lockKeyOf(directory) });
+    found.push({ directory, version });
   }
   return found;
 }