@dev-sergeev/datalab-kit 0.1.1 → 0.1.3

package/node_modules/@zigai/pi-mention-anything/src/source-runtime.ts

@@ -0,0 +1,99 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ChainCompletionSource } from "./chain-autocomplete.ts";
+import {
+    createLazySelectionHistory,
+    rankWithSelectionHistory,
+    type SelectionHistory,
+} from "./initial-suggestions.ts";
+import type { ExpansionSource } from "./mention-resolution.ts";
+import { createSourceController } from "./source-controller.ts";
+import type { Candidate } from "./source-contract.ts";
+import type { MentionConfiguration, MentionRegistration } from "./register-mention.ts";
+
+export type SourceRuntime = {
+    readonly id: string;
+    readonly controller: ReturnType<typeof createSourceController>;
+    readonly source: ChainCompletionSource & ExpansionSource;
+    readonly history: SelectionHistory;
+};
+
+/** Compose one provider's discovery, ranking, persistence and expansion behavior. */
+export function createSourceRuntime(
+    ctx: ExtensionContext,
+    registration: MentionRegistration,
+    configuration: MentionConfiguration,
+): SourceRuntime {
+    const provider = registration.provider(ctx);
+    const controller = createSourceController(provider, {
+        ...configuration,
+        sourceId: registration.id,
+        cwd: ctx.cwd,
+        trusted: ctx.isProjectTrusted(),
+        onError: () =>
+            ctx.ui.notify(
+                `Mention source ${registration.id} could not refresh its candidates.`,
+                "warning",
+            ),
+    });
+    const history = createLazySelectionHistory({
+        stateFileName: `pi-mention-anything-${registration.id}-selections.json`,
+        errorMessage: `Mention source ${registration.id} could not use its selection history.`,
+        onError: (message) => ctx.ui.notify(message, "warning"),
+    });
+    let replacement: ExpansionSource["replacement"];
+    const registrationReplacement = registration.replacement;
+    if (registrationReplacement !== undefined) {
+        replacement = (
+            path,
+            options,
+        ): ReturnType<NonNullable<MentionRegistration["replacement"]>> =>
+            registrationReplacement(path, ctx, options);
+    }
+
+    const source: ChainCompletionSource & ExpansionSource = {
+        id: registration.id,
+        trigger: configuration.trigger,
+        separator: configuration.separator,
+        completionSuffix: configuration.completionSuffix ?? " ",
+        filtering: provider.filtering,
+        expansionPolicy: configuration.expansionPolicy,
+        replacementTemplate: configuration.replacementTemplate,
+        async discover(request) {
+            const response = await controller.discover(request);
+            if (provider.filtering !== "local" || request.query !== "") return response;
+
+            const initial = configuration.initialSuggestions ?? {
+                strategy: "frecency",
+                pinned: [],
+            };
+            const identityOf = (candidate: Candidate): string =>
+                JSON.stringify([...request.path.map((parent) => parent.id), candidate.id]);
+
+            const pinned = initial.pinned.flatMap((name) =>
+                response.items
+                    .filter((candidate) => candidate.id === name || candidate.segment === name)
+                    .map(identityOf),
+            );
+            let ordered = response.items;
+            let strategy = initial.strategy;
+            if (initial.strategy === "alphabetical") {
+                ordered = [...response.items].sort((left, right) =>
+                    left.label.localeCompare(right.label),
+                );
+                strategy = "sourceOrder";
+            }
+
+            const items = await rankWithSelectionHistory(
+                ordered,
+                identityOf,
+                { strategy, pinned },
+                history,
+            );
+            return { ...response, items };
+        },
+        resolve: async (segments, signal) => controller.resolve(segments, signal),
+        replacement,
+    };
+
+    return { id: registration.id, controller, source, history };
+}

package/node_modules/@zigai/pi-mention-skill/README.md

@@ -0,0 +1,60 @@
+# Pi Mention Skill
+
+<a href="https://www.npmjs.com/package/@zigai/pi-mention-skill"><img alt="npm version" src="https://img.shields.io/npm/v/@zigai/pi-mention-skill.svg?color=blue" style="display:inline-block;border:0" /></a> <a href="https://www.npmjs.com/package/@zigai/pi-mention-skill"><img alt="npm downloads" src="https://img.shields.io/npm/dm/@zigai/pi-mention-skill.svg" style="display:inline-block;border:0" /></a> <a href="https://github.com/zigai/pi-tweaks/blob/master/LICENSE"><img alt="license" src="https://img.shields.io/npm/l/@zigai/pi-mention-skill.svg" style="display:inline-block;border:0" /></a>
+
+Move Pi skill selection from slash autocomplete to `$` mentions.
+
+## Install
+
+```sh
+pi install npm:@zigai/pi-mention-skill
+```
+
+## Features
+
+- Adds fuzzy skill autocomplete with `$` mentions.
+- Ranks initial suggestions by frecency, recency, frequency, name, or command order.
+- Supports custom triggers, pinned skills, and optional project-local priority.
+- Expands mentions such as `$skill-name` before the model sees the prompt.
+- Keeps `/skill:*` entries out of slash autocomplete by default.
+
+## Usage
+
+Type `$` in the prompt editor to open skill suggestions, then select a skill.
+
+The selected mention loads the same skill content that `/skill:name` would have loaded, while keeping skills out of the normal slash command picker.
+
+History-based ordering records autocomplete selections in `~/.pi/agent/state/pi-mention-skill-selections.json`. Frecency combines selection count with recency; manually typed mentions do not update this history.
+
+<!-- pi-extension-settings:start -->
+## Configuration
+
+Global settings are stored in `~/.pi/agent/extension-settings/pi-mention-skill.json`.
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `trigger` | string | `"$"` | One or more non-whitespace, non-slash characters that start a skill mention. |
+| `hideSlashSkills` | boolean | `true` | Hide skill commands from slash-command completion. |
+| `completionSuffix` | string | `" "` | Text inserted after a completed skill mention. |
+| `initialSuggestions.strategy` | `frecency` \| `recent` \| `frequent` \| `alphabetical` \| `sourceOrder` | `"frecency"` | Ordering used before any skill query text is entered. |
+| `initialSuggestions.pinned` | string[] | `[]` | Skill names placed first, in this order, before the configured strategy. |
+| `initialSuggestions.projectSkillsFirst` | boolean | `false` | Place project-local skills before user and temporary skills in initial suggestions. |
+
+```json
+{
+  "$schema": "./schemas/pi-mention-skill.schema.json",
+  "trigger": "$",
+  "hideSlashSkills": true,
+  "completionSuffix": " ",
+  "initialSuggestions": {
+    "strategy": "frecency",
+    "pinned": [],
+    "projectSkillsFirst": false
+  }
+}
+```
+<!-- pi-extension-settings:end -->
+
+## License
+
+MIT

package/node_modules/@zigai/pi-mention-skill/config.schema.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/zigai/pi-tweaks/master/packages/pi-mention-skill/config.schema.json",
+  "title": "Pi Mention Skill settings",
+  "description": "Settings for skill mentions and slash-skill visibility.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "default": "./schemas/pi-mention-skill.schema.json",
+      "description": "JSON Schema used by editors for this settings file."
+    },
+    "trigger": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[^/\\s]+$",
+      "default": "$",
+      "description": "One or more non-whitespace, non-slash characters that start a skill mention."
+    },
+    "hideSlashSkills": {
+      "type": "boolean",
+      "default": true,
+      "description": "Hide skill commands from slash-command completion."
+    },
+    "completionSuffix": {
+      "type": "string",
+      "default": " ",
+      "description": "Text inserted after a completed skill mention."
+    },
+    "initialSuggestions": {
+      "type": "object",
+      "properties": {
+        "strategy": {
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "frecency"
+            },
+            {
+              "type": "string",
+              "const": "recent"
+            },
+            {
+              "type": "string",
+              "const": "frequent"
+            },
+            {
+              "type": "string",
+              "const": "alphabetical"
+            },
+            {
+              "type": "string",
+              "const": "sourceOrder"
+            }
+          ],
+          "default": "frecency",
+          "description": "Ordering used before any skill query text is entered."
+        },
+        "pinned": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "default": [],
+          "uniqueItems": true,
+          "description": "Skill names placed first, in this order, before the configured strategy."
+        },
+        "projectSkillsFirst": {
+          "type": "boolean",
+          "default": false,
+          "description": "Place project-local skills before user and temporary skills in initial suggestions."
+        }
+      },
+      "default": {},
+      "additionalProperties": false,
+      "description": "Controls the entries shown immediately after the trigger."
+    }
+  }
+}

package/node_modules/@zigai/pi-mention-skill/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@zigai/pi-mention-skill",
+  "version": "0.10.4",
+  "description": "Pi package that moves skill discovery from slash commands to $ mentions.",
+  "keywords": [
+    "mention",
+    "pi",
+    "pi-coding-agent",
+    "pi-extension",
+    "pi-package",
+    "pi-tweaks",
+    "skill"
+  ],
+  "homepage": "https://github.com/zigai/pi-tweaks/tree/main/packages/pi-mention-skill#readme",
+  "bugs": {
+    "url": "https://github.com/zigai/pi-tweaks/issues"
+  },
+  "license": "MIT",
+  "author": "zigai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zigai/pi-tweaks.git",
+    "directory": "packages/pi-mention-skill"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "*.json"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zigai/pi-extension-settings": "0.5.3",
+    "@zigai/pi-mention-anything": "0.1.4"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "piExtensionSettings": {
+    "definition": "./src/settings-input.ts",
+    "schema": "./config.schema.json",
+    "readme": "./README.md",
+    "prevalidation": "./src/settings.prevalidated.ts"
+  }
+}

package/node_modules/@zigai/pi-mention-skill/src/index.ts

@@ -0,0 +1,60 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerMention, type MentionExtensionApi } from "@zigai/pi-mention-anything/api";
+import { createCachedSkillExpansionLoader } from "./skill-content.ts";
+import { loadMentionSkillSettingsResult } from "./settings.ts";
+import { createSkillProvider, resolveSkillCandidate } from "./skill-provider.ts";
+import { getSkillCommands } from "./skill-commands.ts";
+import { createSlashSkillFilter } from "./slash-skill-filter.ts";
+
+export type MentionSkillExtensionApi = Pick<ExtensionAPI, "getCommands"> & MentionExtensionApi;
+
+export default function (pi: MentionSkillExtensionApi): void {
+    const loadSkillExpansion = createCachedSkillExpansionLoader();
+    const settingsByContext = new WeakMap<
+        object,
+        ReturnType<typeof loadMentionSkillSettingsResult>
+    >();
+    const settingsFor = (ctx: Parameters<typeof loadMentionSkillSettingsResult>[0]) => {
+        const cached = settingsByContext.get(ctx);
+        if (cached !== undefined) return cached;
+
+        const loaded = loadMentionSkillSettingsResult(ctx);
+        settingsByContext.set(ctx, loaded);
+        return loaded;
+    };
+
+    pi.on("session_start", (_event, ctx) => {
+        const loaded = settingsFor(ctx);
+        if (ctx.hasUI) {
+            for (const diagnostic of loaded.diagnostics) {
+                ctx.ui.notify(diagnostic.message, diagnostic.severity);
+            }
+        }
+        if (ctx.hasUI && loaded.settings.hideSlashSkills) {
+            ctx.ui.addAutocompleteProvider(createSlashSkillFilter);
+        }
+    });
+
+    registerMention(pi, {
+        id: "skill",
+        configuration(ctx) {
+            const { settings } = settingsFor(ctx);
+            return {
+                trigger: settings.trigger,
+                completionSuffix: settings.completionSuffix,
+                initialSuggestions: settings.initialSuggestions,
+                expansionPolicy: "selected-or-resolved",
+            };
+        },
+        provider(ctx) {
+            const { settings } = settingsFor(ctx);
+
+            return createSkillProvider(() => getSkillCommands(pi), loadSkillExpansion, {
+                projectSkillsFirst: settings.initialSuggestions.projectSkillsFirst,
+            });
+        },
+        async replacement(candidatePath, _ctx, options) {
+            return resolveSkillCandidate(candidatePath, loadSkillExpansion, options.signal);
+        },
+    });
+}

package/node_modules/@zigai/pi-mention-skill/src/settings-input.ts

@@ -0,0 +1,74 @@
+import { Type, type StaticDecode } from "typebox";
+
+export const DEFAULT_MENTION_TRIGGER = "$";
+export const DEFAULT_COMPLETION_SUFFIX = " ";
+
+export const initialSuggestionStrategySchema = Type.Union(
+    [
+        Type.Literal("frecency"),
+        Type.Literal("recent"),
+        Type.Literal("frequent"),
+        Type.Literal("alphabetical"),
+        Type.Literal("sourceOrder"),
+    ],
+    {
+        default: "frecency",
+        description: "Ordering used before any skill query text is entered.",
+    },
+);
+
+export const mentionSkillSettingsSchema = Type.Object(
+    {
+        trigger: Type.String({
+            minLength: 1,
+            pattern: "^[^/\\s]+$",
+            default: DEFAULT_MENTION_TRIGGER,
+            description:
+                "One or more non-whitespace, non-slash characters that start a skill mention.",
+        }),
+        hideSlashSkills: Type.Boolean({
+            default: true,
+            description: "Hide skill commands from slash-command completion.",
+        }),
+        completionSuffix: Type.String({
+            default: DEFAULT_COMPLETION_SUFFIX,
+            description: "Text inserted after a completed skill mention.",
+        }),
+        initialSuggestions: Type.Object(
+            {
+                strategy: initialSuggestionStrategySchema,
+                pinned: Type.Array(Type.String({ minLength: 1 }), {
+                    default: [],
+                    uniqueItems: true,
+                    description:
+                        "Skill names placed first, in this order, before the configured strategy.",
+                }),
+                projectSkillsFirst: Type.Boolean({
+                    default: false,
+                    description:
+                        "Place project-local skills before user and temporary skills in initial suggestions.",
+                }),
+            },
+            {
+                default: {},
+                additionalProperties: false,
+                description: "Controls the entries shown immediately after the trigger.",
+            },
+        ),
+    },
+    { additionalProperties: false },
+);
+
+export type MentionSkillSettings = StaticDecode<typeof mentionSkillSettingsSchema>;
+export type InitialSuggestionsSettings = MentionSkillSettings["initialSuggestions"];
+
+export const extensionSettingsInput = {
+    id: "pi-mention-skill",
+    title: "Pi Mention Skill",
+    description: "Settings for skill mentions and slash-skill visibility.",
+    schemaId:
+        "https://raw.githubusercontent.com/zigai/pi-tweaks/master/packages/pi-mention-skill/config.schema.json",
+    schema: mentionSkillSettingsSchema,
+};
+
+export default extensionSettingsInput;

package/node_modules/@zigai/pi-mention-skill/src/settings.prevalidated.ts

@@ -0,0 +1,18 @@
+// Generated by pi-extension-settings. Do not edit.
+const artifact = {
+    "formatVersion": 1,
+    "fingerprint": "json-sha256-v1:6068fb01eaa1b4e2e46d7bea643342bd95af1b52617b924f5b45e5bc0266821b",
+    "semanticFingerprint": "typebox-value-hash-v1:3ad1f77c03289771",
+    "defaultSettings": {
+        "trigger": "$",
+        "hideSlashSkills": true,
+        "completionSuffix": " ",
+        "initialSuggestions": {
+            "strategy": "frecency",
+            "pinned": [],
+            "projectSkillsFirst": false
+        }
+    }
+} as const;
+
+export default artifact;

package/node_modules/@zigai/pi-mention-skill/src/settings.ts

@@ -0,0 +1,54 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { loadPiExtensionSettings } from "@zigai/pi-extension-settings/pi";
+
+import { definePrevalidatedExtensionSettings } from "@zigai/pi-extension-settings/runtime";
+import { MentionSkillSettings, extensionSettingsInput } from "./settings-input.ts";
+import prevalidatedSettings from "./settings.prevalidated.ts";
+
+export * from "./settings-input.ts";
+
+export const mentionSkillSettingsDefinition = definePrevalidatedExtensionSettings(
+    extensionSettingsInput,
+    prevalidatedSettings,
+);
+
+export default mentionSkillSettingsDefinition;
+
+export type MentionSkillSettingsContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted">;
+
+/** Load validated global and trusted-project mention settings with safe diagnostics. */
+export function loadMentionSkillSettingsResult(ctx: MentionSkillSettingsContext) {
+    const loaded = loadPiExtensionSettings(
+        mentionSkillSettingsDefinition,
+        {
+            cwd: ctx.cwd,
+            isProjectTrusted: () => ctx.isProjectTrusted(),
+        },
+        {
+            bundledSchema: {
+                kind: "url",
+                url: new URL("../config.schema.json", import.meta.url),
+            },
+        },
+    );
+
+    return {
+        settings: {
+            trigger: loaded.settings.trigger,
+            hideSlashSkills: loaded.settings.hideSlashSkills,
+            completionSuffix: loaded.settings.completionSuffix,
+            initialSuggestions: {
+                strategy: loaded.settings.initialSuggestions.strategy,
+                pinned: [...loaded.settings.initialSuggestions.pinned],
+                projectSkillsFirst: loaded.settings.initialSuggestions.projectSkillsFirst,
+            },
+        },
+        diagnostics: loaded.diagnostics,
+    };
+}
+
+/** Load validated global and trusted-project mention settings. */
+export function loadMentionSkillSettings(ctx: MentionSkillSettingsContext): MentionSkillSettings {
+    return loadMentionSkillSettingsResult(ctx).settings;
+}

package/node_modules/@zigai/pi-mention-skill/src/skill-commands.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI, SlashCommandInfo } from "@earendil-works/pi-coding-agent";
+
+export type SkillCommand = SlashCommandInfo & {
+    name: `skill:${string}`;
+    description: string;
+};
+
+const SKILL_COMMAND_PREFIX = "skill:";
+
+export function getSkillCommands(pi: Pick<ExtensionAPI, "getCommands">): SkillCommand[] {
+    return pi.getCommands().filter((command): command is SkillCommand => {
+        return command.source === "skill" && command.name.startsWith(SKILL_COMMAND_PREFIX);
+    });
+}
+
+export function skillName(command: SkillCommand): string {
+    return command.name.slice(SKILL_COMMAND_PREFIX.length);
+}

package/node_modules/@zigai/pi-mention-skill/src/skill-content.ts

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises";
+
+export type SkillExpansion = {
+    name: string;
+    location: string;
+    body: string;
+    baseDir: string;
+};
+
+export type SkillExpansionTarget = Omit<SkillExpansion, "body">;
+export type SkillExpansionLoader = (target: SkillExpansionTarget) => Promise<SkillExpansion>;
+
+type CachedSkillExpansion = {
+    mtimeMs: number;
+    expansion: SkillExpansion;
+};
+
+export function stripFrontmatter(content: string): string {
+    if (!content.startsWith("---")) return content;
+
+    const end = content.indexOf("\n---", 3);
+    if (end === -1) return content;
+
+    const afterMarker = end + "\n---".length;
+    if (content[afterMarker] === "\r" && content[afterMarker + 1] === "\n") {
+        return content.slice(afterMarker + 2);
+    }
+
+    if (content[afterMarker] === "\n") {
+        return content.slice(afterMarker + 1);
+    }
+
+    return content.slice(afterMarker);
+}
+
+async function loadSkillExpansion(target: SkillExpansionTarget): Promise<SkillExpansion> {
+    const content = await fs.readFile(target.location, "utf8");
+    const body = stripFrontmatter(content).trim();
+    return { ...target, body };
+}
+
+export function createCachedSkillExpansionLoader(): SkillExpansionLoader {
+    const cache = new Map<string, CachedSkillExpansion>();
+    return async (target) => {
+        const stats = await fs.stat(target.location);
+        const cached = cache.get(target.location);
+        if (cached?.mtimeMs === stats.mtimeMs) {
+            return cached.expansion;
+        }
+
+        const expansion = await loadSkillExpansion(target);
+        cache.set(target.location, { mtimeMs: stats.mtimeMs, expansion });
+
+        return expansion;
+    };
+}
+
+export function formatSkillBlock(expansion: SkillExpansion): string {
+    return `<skill name="${expansion.name}" location="${expansion.location}">\nReferences are relative to ${expansion.baseDir}.\n\n${expansion.body}\n</skill>`;
+}