poe-code 3.0.222 → 3.0.224

package/packages/agent-skill-config/dist/git-exclude.js

@@ -0,0 +1,93 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+const markerPrefix = "# poe-code-spawn-skills:";
+function defaultGitDirRunner(cwd) {
+    try {
+        return execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+let gitDirRunner = defaultGitDirRunner;
+export function setGitDirRunnerForTest(runner) {
+    const previous = gitDirRunner;
+    gitDirRunner = runner;
+    return () => {
+        gitDirRunner = previous;
+    };
+}
+function resolveExcludePath(cwd) {
+    const gitDir = gitDirRunner(cwd);
+    if (gitDir === undefined || gitDir.length === 0) {
+        return undefined;
+    }
+    return path.join(path.isAbsolute(gitDir) ? gitDir : path.resolve(cwd, gitDir), "info/exclude");
+}
+function markers(runId) {
+    return {
+        begin: `${markerPrefix}${runId} begin`,
+        end: `${markerPrefix}${runId} end`
+    };
+}
+function readExcludeFile(excludePath) {
+    try {
+        return fs.readFileSync(excludePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function removeBlock(content, runId) {
+    const { begin, end } = markers(runId);
+    const lines = content.split("\n");
+    const result = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index] === begin) {
+            const endIndex = lines.indexOf(end, index + 1);
+            if (endIndex !== -1) {
+                index = endIndex;
+                continue;
+            }
+        }
+        result.push(lines[index]);
+    }
+    return result.join("\n");
+}
+function appendBlock(content, runId, entries) {
+    const { begin, end } = markers(runId);
+    const existing = content ?? "";
+    const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}\n`;
+    return `${prefix}${[begin, ...entries, end, ""].join("\n")}`;
+}
+export function appendExcludeBlock(cwd, runId, entries) {
+    const excludePath = resolveExcludePath(cwd);
+    if (excludePath === undefined) {
+        return;
+    }
+    fs.mkdirSync(path.dirname(excludePath), { recursive: true });
+    const content = readExcludeFile(excludePath);
+    fs.writeFileSync(excludePath, appendBlock(content, runId, entries), "utf8");
+}
+export function removeExcludeBlock(cwd, runId) {
+    const excludePath = resolveExcludePath(cwd);
+    if (excludePath === undefined) {
+        return;
+    }
+    const content = readExcludeFile(excludePath);
+    if (content === undefined) {
+        return;
+    }
+    fs.writeFileSync(excludePath, removeBlock(content, runId), "utf8");
+}

package/packages/agent-skill-config/dist/index.d.ts

@@ -1,5 +1,10 @@
 export type { AgentSkillConfig, AgentSupportResult, AgentSupportStatus, SkillScope } from "./configs.js";
 export type { ApplyOptions, SkillFile } from "./types.js";
+export type { SkillResolution, SkillResolutionFailure, SkillSource } from "./resolve-skill-reference.js";
+export type { BridgeEntry, BridgeManifest, BridgeWarning, BridgeWarningKind } from "./bridge-active-skills.js";
 export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
 export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";
 export type { InstallSkillOptions, InstallSkillResult } from "./apply.js";
+export { resolveSkillReference } from "./resolve-skill-reference.js";
+export { appendExcludeBlock, removeExcludeBlock } from "./git-exclude.js";
+export { bridgeActiveSkills, cleanupBridgedSkills } from "./bridge-active-skills.js";

package/packages/agent-skill-config/dist/index.js

@@ -1,2 +1,5 @@
 export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
 export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";
+export { resolveSkillReference } from "./resolve-skill-reference.js";
+export { appendExcludeBlock, removeExcludeBlock } from "./git-exclude.js";
+export { bridgeActiveSkills, cleanupBridgedSkills } from "./bridge-active-skills.js";

package/packages/agent-skill-config/dist/resolve-skill-reference.d.ts

@@ -0,0 +1,22 @@
+export interface SkillSource {
+    kind: "resolved";
+    ref: string;
+    name: string;
+    sourceAgentId?: string;
+    sourcePath: string;
+    scope: "project" | "user";
+}
+export type SkillResolutionFailure = {
+    kind: "malformed";
+    ref: string;
+} | {
+    kind: "unknown-agent";
+    ref: string;
+    agentInput: string;
+} | {
+    kind: "not-found";
+    ref: string;
+    searchedPaths: string[];
+};
+export type SkillResolution = SkillSource | SkillResolutionFailure;
+export declare function resolveSkillReference(ref: string, cwd: string, homeDir: string): SkillResolution;

package/packages/agent-skill-config/dist/resolve-skill-reference.js

@@ -0,0 +1,82 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import { getAgentConfig, resolveAgentSupport, resolveSkillDir } from "./configs.js";
+function isMalformedSegment(segment) {
+    return segment.length === 0 || segment !== segment.trim();
+}
+function isDirectory(targetPath) {
+    try {
+        return statSync(targetPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function findSkill(ref, name, tiers, sourceAgentId) {
+    for (const tier of tiers) {
+        if (isDirectory(tier.sourcePath)) {
+            return {
+                kind: "resolved",
+                ref,
+                name,
+                ...(sourceAgentId ? { sourceAgentId } : {}),
+                sourcePath: tier.sourcePath,
+                scope: tier.scope
+            };
+        }
+    }
+    return {
+        kind: "not-found",
+        ref,
+        searchedPaths: tiers.map((tier) => tier.sourcePath)
+    };
+}
+export function resolveSkillReference(ref, cwd, homeDir) {
+    const slashIndex = ref.indexOf("/");
+    const hasPrefix = slashIndex !== -1;
+    if (ref.length === 0 ||
+        ref !== ref.trim() ||
+        (hasPrefix && ref.indexOf("/", slashIndex + 1) !== -1)) {
+        return { kind: "malformed", ref };
+    }
+    if (!hasPrefix) {
+        if (isMalformedSegment(ref)) {
+            return { kind: "malformed", ref };
+        }
+        const tiers = [
+            {
+                scope: "project",
+                sourcePath: path.resolve(cwd, ".poe-code/skills", ref)
+            },
+            {
+                scope: "user",
+                sourcePath: path.resolve(homeDir, ".poe-code/skills", ref)
+            }
+        ];
+        return findSkill(ref, ref, tiers);
+    }
+    const agentInput = ref.slice(0, slashIndex);
+    const name = ref.slice(slashIndex + 1);
+    if (isMalformedSegment(agentInput) || isMalformedSegment(name)) {
+        return { kind: "malformed", ref };
+    }
+    const support = resolveAgentSupport(agentInput);
+    if (support.status !== "supported" || !support.id) {
+        return { kind: "unknown-agent", ref, agentInput };
+    }
+    const config = getAgentConfig(support.id);
+    if (!config) {
+        return { kind: "unknown-agent", ref, agentInput };
+    }
+    const tiers = [
+        {
+            scope: "project",
+            sourcePath: path.resolve(resolveSkillDir(config, "local", cwd), name)
+        },
+        {
+            scope: "user",
+            sourcePath: path.resolve(resolveSkillDir(config, "global", cwd, homeDir), name)
+        }
+    ];
+    return findSkill(ref, name, tiers, support.id);
+}

package/packages/design-system/dist/components/browser.d.ts

@@ -0,0 +1,15 @@
+interface BrowserProcess {
+    once(event: "error", listener: (error: Error) => void): this;
+    once(event: "spawn", listener: () => void): this;
+    unref(): void;
+}
+type SpawnBrowserProcess = (command: string, args: string[], options: {
+    detached: true;
+    stdio: "ignore";
+}) => BrowserProcess;
+export interface OpenExternalOptions {
+    platform?: NodeJS.Platform;
+    spawnProcess?: SpawnBrowserProcess;
+}
+export declare function openExternal(url: string, options?: OpenExternalOptions): Promise<void>;
+export {};

package/packages/design-system/dist/components/browser.js

@@ -0,0 +1,26 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+export async function openExternal(url, options = {}) {
+    const parsed = new URL(url);
+    const { command, args } = browserCommand(parsed.href, options.platform ?? process.platform);
+    await launchBrowser(command, args, options.spawnProcess ?? spawn);
+}
+function browserCommand(url, platform) {
+    if (platform === "darwin") {
+        return { command: "open", args: [url] };
+    }
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    }
+    return { command: "xdg-open", args: [url] };
+}
+function launchBrowser(command, args, spawnProcess) {
+    return new Promise((resolve, reject) => {
+        const child = spawnProcess(command, args, { detached: true, stdio: "ignore" });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}

package/packages/design-system/dist/explorer/index.d.ts

@@ -4,5 +4,5 @@ export { createInitialState } from "./state.js";
 export { resolveBindings } from "./keymap.js";
 export type { Effect, ExplorerEvent } from "./events.js";
 export type { BindingTarget, ExplorerBindingDefaults, ExplorerBuiltinCommand, ResolvedBindings } from "./keymap.js";
-export type { Action, ActionContext, Detail, DetailCtx, DetailItem, Dirty, ExplorerConfig, ExplorerLayoutMode, ExplorerSize, ExplorerState, Row, Tone } from "./state.js";
+export type { Action, ActionContext, Detail, DetailCtx, DetailItem, Dirty, ExplorerConfig, ExplorerLayoutMode, ExplorerSize, ExplorerState, ReorderContext, Row, Tone } from "./state.js";
 export declare function singleDetail<R>(fn: (row: Row, ctx: DetailCtx) => string | Promise<string>): Detail<R>;

package/packages/design-system/dist/explorer/keymap.js

@@ -19,8 +19,8 @@ const builtinBindings = {
     detailScrollUp: ["Ctrl+b"],
     extendSelectionUp: ["Shift+up"],
     extendSelectionDown: ["Shift+down"],
-    reorderUp: ["Ctrl+up", "K"],
-    reorderDown: ["Ctrl+down", "J"]
+    reorderUp: ["Shift+up", "K"],
+    reorderDown: ["Shift+down", "J"]
 };
 const baseBuiltinCommands = [
     "quit",
@@ -49,7 +49,10 @@ const reservedActionIds = new Set(["quit"]);
 export function resolveBindings(config, defaults = {}) {
     const commands = config.reorder === undefined
         ? baseBuiltinCommands
-        : [...baseBuiltinCommands, ...reorderCommands];
+        : [
+            ...baseBuiltinCommands.filter((command) => command !== "extendSelectionUp" && command !== "extendSelectionDown"),
+            ...reorderCommands
+        ];
     const commandBindings = new Map();
     const flatBindings = new Map();
     const targetKeys = new Map();

package/packages/design-system/dist/explorer/render/footer.js

@@ -13,6 +13,12 @@ export function renderFooter(state, screen, layout) {
         if (x >= rect.x + rect.width) {
             break;
         }
+        if (hint.bracketed === false) {
+            const text = `${hint.key} ${hint.label}`;
+            screen.put(x, y, text, hint.running ? styles.muted : {});
+            x += text.length + 2;
+            continue;
+        }
         screen.put(x, y, `[${hint.key}]`, hint.running ? styles.muted : styles.accent);
         x += hint.key.length + 2;
         screen.put(x, y, ` ${hint.label}`, hint.running ? styles.muted : {});
@@ -37,9 +43,17 @@ function footerHints(state) {
     }
     hints.push({ key: "?", label: "help", running: false });
     hints.push({ key: "Ctrl+P", label: "palette", running: false });
+    if (hasShiftReorderBindings(state)) {
+        hints.push({ key: "⇧↑↓", label: "reorder (within state)", running: false, bracketed: false });
+    }
     hints.push({ key: "q", label: "quit", running: false });
     return hints;
 }
+function hasShiftReorderBindings(state) {
+    const up = state.bindings.keysByTarget.get("builtin:reorderUp") ?? [];
+    const down = state.bindings.keysByTarget.get("builtin:reorderDown") ?? [];
+    return up.includes("Shift+up") && down.includes("Shift+down");
+}
 function actionKey(entry, fallback) {
     const key = entry.action?.key;
     if (Array.isArray(key)) {

package/packages/design-system/dist/explorer/runtime.js

@@ -36,7 +36,7 @@ class ExplorerRuntime {
         });
         this.runtimeHandles = {
             refresh: async () => {
-                await this.refreshRows();
+                await this.refreshRowsFromSource();
             },
             suspendAnd: async (fn) => this.suspendAnd(fn),
             toast: (msg, tone) => {
@@ -54,7 +54,7 @@ class ExplorerRuntime {
             try {
                 this.startTerminal();
                 this.render();
-                this.refreshRows().catch((error) => {
+                this.loadRows().catch((error) => {
                     this.fail(error);
                 });
             }
@@ -76,10 +76,14 @@ class ExplorerRuntime {
             this.dispatch({ type: "resize", cols: size.cols, rows: size.rows });
         });
     }
-    async refreshRows() {
+    async loadRows() {
         const rows = await this.config.rows();
         this.dispatch({ type: "rowsLoaded", rows });
     }
+    async refreshRowsFromSource() {
+        await this.config.refresh?.();
+        await this.loadRows();
+    }
     dispatch(event) {
         if (this.stopped) {
             return;
@@ -128,7 +132,10 @@ class ExplorerRuntime {
     }
     async persistOrder(orderedIds, previousRows) {
         try {
-            await this.config.reorder?.onReorder(orderedIds);
+            await this.config.reorder?.onReorder(orderedIds, {
+                refresh: this.runtimeHandles.refresh,
+                toast: this.runtimeHandles.toast
+            });
         }
         catch (error) {
             this.showToast(error instanceof Error ? error.message : "Could not persist order", "error");

package/packages/design-system/dist/explorer/state.d.ts

@@ -51,13 +51,18 @@ export interface ActionContext<R> {
     confirm: (prompt: string) => Promise<boolean>;
     exit: (after?: () => void | Promise<void>) => void;
 }
+export interface ReorderContext {
+    refresh: () => Promise<void>;
+    toast: (msg: string, tone?: Tone) => void;
+}
 export interface ExplorerConfig<R> {
     title: string;
     rows: () => Promise<Row[]>;
+    refresh?: () => Promise<void>;
     detail: Detail<R>;
     actions: Action<R>[];
     reorder?: {
-        onReorder: (orderedIds: string[]) => void | Promise<void>;
+        onReorder: (orderedIds: string[], ctx?: ReorderContext) => void | Promise<void>;
     };
     multiSelect?: boolean;
     keybindOverrides?: Record<string, string | string[]>;

package/packages/design-system/dist/index.d.ts

@@ -19,13 +19,14 @@ export { renderTable } from "./components/table.js";
 export type { TableColumn, RenderTableOptions } from "./components/table.js";
 export { renderTemplate } from "./components/template.js";
 export type { RenderTemplateOptions, TemplateEscape } from "./components/template.js";
+export { openExternal } from "./components/browser.js";
 export * as acp from "./acp/index.js";
 export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
 export { runExplorer, singleDetail } from "./explorer/index.js";
-export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ExplorerConfig, Tone, } from "./explorer/index.js";
+export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ExplorerConfig, ReorderContext, Tone, } from "./explorer/index.js";
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
 export type { SelectOptions, MultiselectOptions, TextOptions, ConfirmOptions, PasswordOptions, SpinnerOptions, WithSpinnerOptions } from "./prompts/index.js";

package/packages/design-system/dist/index.js

@@ -15,6 +15,7 @@ export { formatCommandNotFound } from "./components/command-errors.js";
 export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
 export { renderTemplate } from "./components/template.js";
+export { openExternal } from "./components/browser.js";
 // ACP rendering
 export * as acp from "./acp/index.js";
 // Dashboard