@dev-sergeev/datalab-kit 0.1.2 → 0.1.3

package/node_modules/pi-toggle-skills/toggle-skills.ts

@@ -0,0 +1,316 @@
+/**
+ * pi-toggle-skills — toggle skill visibility in pi's system prompt.
+ *
+ * Toggles `disable-model-invocation` in SKILL.md frontmatter to control
+ * whether a skill appears in the model's available skills list.
+ *
+ * When a skill has `disable-model-invocation: true`, pi excludes it from
+ * the system prompt entirely. Users can still invoke it explicitly via
+ * /skill:name commands.
+ *
+ * This extension modifies SKILL.md files on disk. Changes require a /reload
+ * to take effect.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  TOGGLE_COMMAND_DESCRIPTION,
+  type ToggleSkill,
+  computeChanges,
+} from "./src/index.js";
+import {
+  discoverSkills,
+  toggleSkillInvocation,
+  applyChanges,
+} from "./src/skill-discovery.js";
+import { ToggleSkillSelectorComponent, type ToggleSkillSelectorResult } from "./src/skill-selector.js";
+
+export default function (pi: ExtensionAPI) {
+  let currentSkills: ToggleSkill[] = [];
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentSkills = discoverSkills(ctx.cwd);
+  });
+
+  pi.registerCommand("toggle-skills", {
+    description: TOGGLE_COMMAND_DESCRIPTION,
+    getArgumentCompletions(prefix: string) {
+      const subcommands = ["status", "enable", "disable", "list", "help"];
+      const matches = subcommands.filter((s) => s.startsWith(prefix));
+      return matches.length > 0 ? matches.map((s) => ({ value: s, label: s })) : null;
+    },
+    handler: async (args, ctx) => {
+      await handleToggleCommand(ctx, args.trim(), currentSkills, (skills) => {
+        currentSkills = skills;
+      });
+    },
+  });
+}
+
+async function handleToggleCommand(
+  ctx: ExtensionCommandContext,
+  args: string,
+  currentSkills: ToggleSkill[],
+  setSkills: (skills: ToggleSkill[]) => void,
+): Promise<void> {
+  const parts = args.split(/\s+/);
+  const subcommand = parts[0]?.toLowerCase() ?? "";
+  const rest = parts.slice(1).join(" ");
+
+  // /toggle-skills — open interactive TUI selector (default)
+  if (!subcommand) {
+    await showToggleSelector(ctx, currentSkills, setSkills);
+    return;
+  }
+
+  // /toggle-skills list — show skills and their status
+  if (subcommand === "list") {
+    showStatus(ctx, currentSkills);
+    return;
+  }
+
+  // /toggle-skills status — same as list
+  if (subcommand === "status") {
+    showStatus(ctx, currentSkills);
+    return;
+  }
+
+  // /toggle-skills disable <name> — hide a skill from the system prompt
+  if (subcommand === "disable") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /toggle-skills disable <skill-name>",
+        "warning",
+      );
+      return;
+    }
+
+    const skill = findSkillByName(currentSkills, rest);
+    if (!skill) {
+      ctx.ui.notify(`Skill not found: "${rest}". Use /toggle-skills list to see available skills.`, "warning");
+      return;
+    }
+
+    if (skill.disabled) {
+      ctx.ui.notify(`Skill "${skill.name}" is already hidden.`, "info");
+      return;
+    }
+
+    if (toggleSkillInvocation(skill.filePath, true)) {
+      skill.disabled = true;
+      ctx.ui.notify(
+        `Disabled: "${skill.name}" — hidden from system prompt. Run /reload to apply.`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`Failed to toggle skill "${skill.name}". Check file permissions.`, "error");
+    }
+    return;
+  }
+
+  // /toggle-skills enable <name> — show a skill in the system prompt
+  if (subcommand === "enable") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /toggle-skills enable <skill-name>",
+        "warning",
+      );
+      return;
+    }
+
+    const skill = findSkillByName(currentSkills, rest);
+    if (!skill) {
+      ctx.ui.notify(`Skill not found: "${rest}". Use /toggle-skills list to see available skills.`, "warning");
+      return;
+    }
+
+    if (!skill.disabled) {
+      ctx.ui.notify(`Skill "${skill.name}" is already visible.`, "info");
+      return;
+    }
+
+    if (toggleSkillInvocation(skill.filePath, false)) {
+      skill.disabled = false;
+      ctx.ui.notify(
+        `Enabled: "${skill.name}" — visible in system prompt. Run /reload to apply.`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`Failed to toggle skill "${skill.name}". Check file permissions.`, "error");
+    }
+    return;
+  }
+
+  // /toggle-skills help
+  if (subcommand === "help") {
+    ctx.ui.notify(
+      [
+        "pi-toggle-skills commands:",
+        "  /toggle-skills               Open interactive TUI to toggle skill visibility",
+        "  /toggle-skills status        Show current skills and their visibility",
+        "  /toggle-skills list          Same as /toggle-skills status",
+        "  /toggle-skills disable <n>   Hide a skill from the system prompt",
+        "  /toggle-skills enable <n>    Show a skill in the system prompt",
+        "  /toggle-skills help          This message",
+        "",
+        "Mechanism: toggles disable-model-invocation in SKILL.md frontmatter.",
+        "  When true, the skill is excluded from the system prompt.",
+        "  Users can still invoke hidden skills via /skill:name commands.",
+        "  Changes require /reload to take effect.",
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    `Unknown subcommand: "${subcommand}". Use /toggle-skills help for usage.`,
+    "warning",
+  );
+}
+
+// Open the interactive TUI selector.
+async function showToggleSelector(
+  ctx: ExtensionCommandContext,
+  currentSkills: ToggleSkill[],
+  setSkills: (skills: ToggleSkill[]) => void,
+): Promise<void> {
+  if (currentSkills.length === 0) {
+    ctx.ui.notify("No skills found. Add skills to ~/.pi/agent/skills/ or .pi/skills/ first.", "warning");
+    return;
+  }
+
+  if (ctx.mode !== "tui") {
+    if (!ctx.hasUI) {
+      ctx.ui.notify("/toggle-skills requires a UI (TUI or GUI).", "error");
+      return;
+    }
+    const items = currentSkills.map((s) => `${s.name}: ${s.disabled ? "disabled" : "enabled"}`);
+    const pick = await ctx.ui.select("Toggle skill \u2014 pick a skill to flip", items);
+    if (pick === undefined) return;
+    const idx = items.indexOf(pick);
+    if (idx < 0) return;
+    const skill = currentSkills[idx];
+    if (!skill) return;
+    const newDisabled = !skill.disabled;
+    const written = applyChanges(currentSkills, [{ filePath: skill.filePath, newDisabled }]);
+    if (written.length === 0) {
+      ctx.ui.notify("No files were written. Check file permissions.", "warning");
+      return;
+    }
+    setSkills(
+      currentSkills.map((s) => (s.filePath === skill.filePath ? { ...s, disabled: newDisabled } : s)),
+    );
+    ctx.ui.notify(
+      `Skill ${skill.name} ${newDisabled ? "disabled" : "enabled"}. /reload to take effect. Run /toggle-skills again for more.`,
+      "info",
+    );
+    return;
+  }
+
+  const result = await ctx.ui.custom<ToggleSkillSelectorResult>(
+    (tui, theme, _kb, done) => {
+      const selector = new ToggleSkillSelectorComponent(
+        theme,
+        currentSkills,
+        (result) => done(result),
+      );
+
+      return {
+        get focused() { return selector.focused; },
+        set focused(value: boolean) { selector.focused = value; },
+        render(width: number) {
+          return selector.render(width);
+        },
+        invalidate() {
+          selector.invalidate();
+        },
+        handleInput(data: string) {
+          selector.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+  );
+
+  if (!result || result.cancelled) {
+    ctx.ui.notify("Toggle selector cancelled.", "info");
+    return;
+  }
+
+  // Compute what changed
+  const changes = computeChanges(currentSkills, result.skills);
+  if (changes.length === 0) {
+    ctx.ui.notify("No changes to apply.", "info");
+    return;
+  }
+
+  // Write changes to disk
+  const written = applyChanges(currentSkills, changes);
+  if (written.length === 0) {
+    ctx.ui.notify("No files were written. Check file permissions.", "warning");
+    return;
+  }
+
+  setSkills(result.skills);
+
+  // Summarize what changed
+  const disabled = changes.filter((c) => c.newDisabled).length;
+  const enabled = changes.length - disabled;
+  const parts: string[] = [];
+  if (enabled > 0) parts.push(`${enabled} enabled`);
+  if (disabled > 0) parts.push(`${disabled} disabled`);
+  const summary = parts.join(", ");
+
+  ctx.ui.notify(
+    `Skills updated: ${summary}. Run /reload to apply.`,
+    "info",
+  );
+}
+
+function findSkillByName(skills: ReadonlyArray<ToggleSkill>, name: string): ToggleSkill | undefined {
+  // Exact match first
+  const exact = skills.find((s) => s.name === name);
+  if (exact) return exact;
+
+  // Prefix match
+  const prefix = skills.find((s) => s.name.startsWith(name));
+  if (prefix) return prefix;
+
+  // Fuzzy: contains
+  const fuzzy = skills.find((s) => s.name.includes(name));
+  return fuzzy;
+}
+
+function showStatus(
+  ctx: ExtensionCommandContext,
+  skills: ReadonlyArray<ToggleSkill>,
+): void {
+  const lines: string[] = [];
+
+  if (skills.length === 0) {
+    lines.push("No skills found. Add skills to ~/.pi/agent/skills/ or .pi/skills/.");
+  } else {
+    const visible = skills.filter((s) => !s.disabled);
+    const hidden = skills.filter((s) => s.disabled);
+
+    if (hidden.length > 0) {
+      lines.push(`Visible skills (${visible.length}):`);
+      for (const skill of visible) {
+        lines.push(`  ✓ ${skill.name}`);
+      }
+      lines.push("");
+      lines.push(`Hidden skills (${hidden.length}):`);
+      for (const skill of hidden) {
+        lines.push(`  ✗ ${skill.name}`);
+      }
+    } else {
+      lines.push(`All skills visible (${skills.length}):`);
+      for (const skill of skills) {
+        lines.push(`  ✓ ${skill.name}`);
+      }
+    }
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}

package/node_modules/pi-toggle-skills/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["__tests__/**/*.test.ts"],
+    exclude: ["node_modules", "dist", ".idea", ".git", ".cache"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts"],
+    },
+  },
+});

package/node_modules/proper-lockfile/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/proper-lockfile/README.md

@@ -0,0 +1,183 @@
+# proper-lockfile
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Coverage Status][codecov-image]][codecov-url] [![Dependency status][david-dm-image]][david-dm-url] [![Dev Dependency status][david-dm-dev-image]][david-dm-dev-url]
+
+[npm-url]:https://npmjs.org/package/proper-lockfile
+[downloads-image]:https://img.shields.io/npm/dm/proper-lockfile.svg
+[npm-image]:https://img.shields.io/npm/v/proper-lockfile.svg
+[travis-url]:https://travis-ci.org/moxystudio/node-proper-lockfile
+[travis-image]:https://img.shields.io/travis/moxystudio/node-proper-lockfile/master.svg
+[codecov-url]:https://codecov.io/gh/moxystudio/node-proper-lockfile
+[codecov-image]:https://img.shields.io/codecov/c/github/moxystudio/node-proper-lockfile/master.svg
+[david-dm-url]:https://david-dm.org/moxystudio/node-proper-lockfile
+[david-dm-image]:https://img.shields.io/david/moxystudio/node-proper-lockfile.svg
+[david-dm-dev-url]:https://david-dm.org/moxystudio/node-proper-lockfile?type=dev
+[david-dm-dev-image]:https://img.shields.io/david/dev/moxystudio/node-proper-lockfile.svg
+
+An inter-process and inter-machine lockfile utility that works on a local or network file system.
+
+
+## Installation
+
+`$ npm install proper-lockfile`
+
+
+## Design
+
+There are various ways to achieve [file locking](http://en.wikipedia.org/wiki/File_locking).
+
+This library utilizes the `mkdir` strategy which works atomically on any kind of file system, even network based ones.
+The lockfile path is based on the file path you are trying to lock by suffixing it with `.lock`.
+
+When a lock is successfully acquired, the lockfile's `mtime` (modified time) is periodically updated to prevent staleness. This allows to effectively check if a lock is stale by checking its `mtime` against a stale threshold. If the update of the mtime fails several times, the lock might be compromised. The `mtime` is [supported](http://en.wikipedia.org/wiki/Comparison_of_file_systems) in almost every `filesystem`.
+
+
+### Comparison
+
+This library is similar to [lockfile](https://github.com/isaacs/lockfile) but the latter has some drawbacks:
+
+- It relies on `open` with `O_EXCL` flag which has problems in network file systems. `proper-lockfile` uses `mkdir` which doesn't have this issue.
+
+> O_EXCL is broken on NFS file systems; programs which rely on it for performing locking tasks will contain a race condition.
+
+- The lockfile staleness check is done via `ctime` (creation time) which is unsuitable for long running processes. `proper-lockfile` constantly updates lockfiles `mtime` to do proper staleness check.
+
+- It does not check if the lockfile was compromised which can lead to undesirable situations. `proper-lockfile` checks the lockfile when updating the `mtime`.
+
+- It has a default value of `0` for the stale option which isn't good because any crash or process kill that the package can't handle gracefully will leave the lock active forever.
+
+
+### Compromised
+
+`proper-lockfile` does not detect cases in which:
+
+- A `lockfile` is manually removed and someone else acquires the lock right after
+- Different `stale`/`update` values are being used for the same file, possibly causing two locks to be acquired on the same file
+
+`proper-lockfile` detects cases in which:
+
+- Updates to the `lockfile` fail
+- Updates take longer than expected, possibly causing the lock to become stale for a certain amount of time
+
+
+As you see, the first two are a consequence of bad usage. Technically, it was possible to detect the first two but it would introduce complexity and eventual race conditions.
+
+
+## Usage
+
+### .lock(file, [options])
+
+Tries to acquire a lock on `file` or rejects the promise on error.
+
+If the lock succeeds, a `release` function is provided that should be called when you want to release the lock. The `release` function also rejects the promise on error (e.g. when the lock was already compromised).
+
+Available options:
+
+- `stale`: Duration in milliseconds in which the lock is considered stale, defaults to `10000` (minimum value is `5000`)
+- `update`: The interval in milliseconds in which the lockfile's `mtime` will be updated, defaults to `stale/2` (minimum value is `1000`, maximum value is `stale/2`)
+- `retries`: The number of retries or a [retry](https://www.npmjs.org/package/retry) options object, defaults to `0`
+- `realpath`: Resolve symlinks using realpath, defaults to `true` (note that if `true`, the `file` must exist previously)
+- `fs`: A custom fs to use, defaults to `graceful-fs`
+- `onCompromised`: Called if the lock gets compromised, defaults to a function that simply throws the error which will probably cause the process to die
+- `lockfilePath`: Custom lockfile path. e.g.: If you want to lock a directory and create the lock file inside it, you can pass `file` as `<dir path>` and `options.lockfilePath` as `<dir path>/dir.lock`
+
+
+```js
+const lockfile = require('proper-lockfile');
+
+lockfile.lock('some/file')
+.then((release) => {
+    // Do something while the file is locked
+
+    // Call the provided release function when you're done,
+    // which will also return a promise
+    return release();
+})
+.catch((e) => {
+    // either lock could not be acquired
+    // or releasing it failed
+    console.error(e)
+});
+
+// Alternatively, you may use lockfile('some/file') directly.
+```
+
+
+### .unlock(file, [options])
+
+Releases a previously acquired lock on `file` or rejects the promise on error.
+
+Whenever possible you should use the `release` function instead (as exemplified above). Still there are cases in which it's hard to keep a reference to it around code. In those cases `unlock()` might be handy.
+
+Available options:
+
+- `realpath`: Resolve symlinks using realpath, defaults to `true` (note that if `true`, the `file` must exist previously)
+- `fs`: A custom fs to use, defaults to `graceful-fs`
+- `lockfilePath`: Custom lockfile path. e.g.: If you want to lock a directory and create the lock file inside it, you can pass `file` as `<dir path>` and `options.lockfilePath` as `<dir path>/dir.lock`
+
+
+```js
+const lockfile = require('proper-lockfile');
+
+lockfile.lock('some/file')
+.then(() => {
+    // Do something while the file is locked
+
+    // Later..
+    return lockfile.unlock('some/file');
+});
+```
+
+### .check(file, [options])
+
+Check if the file is locked and its lockfile is not stale, rejects the promise on error.
+
+Available options:
+
+- `stale`: Duration in milliseconds in which the lock is considered stale, defaults to `10000` (minimum value is `5000`)
+- `realpath`: Resolve symlinks using realpath, defaults to `true` (note that if `true`, the `file` must exist previously)
+- `fs`: A custom fs to use, defaults to `graceful-fs`
+- `lockfilePath`: Custom lockfile path. e.g.: If you want to lock a directory and create the lock file inside it, you can pass `file` as `<dir path>` and `options.lockfilePath` as `<dir path>/dir.lock`
+
+
+```js
+const lockfile = require('proper-lockfile');
+
+lockfile.check('some/file')
+.then((isLocked) => {
+    // isLocked will be true if 'some/file' is locked, false otherwise
+});
+```
+
+### .lockSync(file, [options])
+
+Sync version of `.lock()`.   
+Returns the `release` function or throws on error.
+
+### .unlockSync(file, [options])
+
+Sync version of `.unlock()`.   
+Throws on error.
+
+### .checkSync(file, [options])
+
+Sync version of `.check()`.
+Returns a boolean or throws on error.
+
+
+## Graceful exit
+
+`proper-lockfile` automatically removes locks if the process exits, except if the process is killed with SIGKILL or it crashes due to a VM fatal error (e.g.: out of memory).
+
+
+## Tests
+
+`$ npm test`   
+`$ npm test -- --watch` during development
+
+The test suite is very extensive. There's even a stress test to guarantee exclusiveness of locks.
+
+
+## License
+
+Released under the [MIT License](https://www.opensource.org/licenses/mit-license.php).

package/node_modules/proper-lockfile/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const lockfile = require('./lib/lockfile');
+const { toPromise, toSync, toSyncOptions } = require('./lib/adapter');
+
+async function lock(file, options) {
+    const release = await toPromise(lockfile.lock)(file, options);
+
+    return toPromise(release);
+}
+
+function lockSync(file, options) {
+    const release = toSync(lockfile.lock)(file, toSyncOptions(options));
+
+    return toSync(release);
+}
+
+function unlock(file, options) {
+    return toPromise(lockfile.unlock)(file, options);
+}
+
+function unlockSync(file, options) {
+    return toSync(lockfile.unlock)(file, toSyncOptions(options));
+}
+
+function check(file, options) {
+    return toPromise(lockfile.check)(file, options);
+}
+
+function checkSync(file, options) {
+    return toSync(lockfile.check)(file, toSyncOptions(options));
+}
+
+module.exports = lock;
+module.exports.lock = lock;
+module.exports.unlock = unlock;
+module.exports.lockSync = lockSync;
+module.exports.unlockSync = unlockSync;
+module.exports.check = check;
+module.exports.checkSync = checkSync;

package/node_modules/proper-lockfile/lib/adapter.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const fs = require('graceful-fs');
+
+function createSyncFs(fs) {
+    const methods = ['mkdir', 'realpath', 'stat', 'rmdir', 'utimes'];
+    const newFs = { ...fs };
+
+    methods.forEach((method) => {
+        newFs[method] = (...args) => {
+            const callback = args.pop();
+            let ret;
+
+            try {
+                ret = fs[`${method}Sync`](...args);
+            } catch (err) {
+                return callback(err);
+            }
+
+            callback(null, ret);
+        };
+    });
+
+    return newFs;
+}
+
+// ----------------------------------------------------------
+
+function toPromise(method) {
+    return (...args) => new Promise((resolve, reject) => {
+        args.push((err, result) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(result);
+            }
+        });
+
+        method(...args);
+    });
+}
+
+function toSync(method) {
+    return (...args) => {
+        let err;
+        let result;
+
+        args.push((_err, _result) => {
+            err = _err;
+            result = _result;
+        });
+
+        method(...args);
+
+        if (err) {
+            throw err;
+        }
+
+        return result;
+    };
+}
+
+function toSyncOptions(options) {
+    // Shallow clone options because we are oging to mutate them
+    options = { ...options };
+
+    // Transform fs to use the sync methods instead
+    options.fs = createSyncFs(options.fs || fs);
+
+    // Retries are not allowed because it requires the flow to be sync
+    if (
+        (typeof options.retries === 'number' && options.retries > 0) ||
+        (options.retries && typeof options.retries.retries === 'number' && options.retries.retries > 0)
+    ) {
+        throw Object.assign(new Error('Cannot use retries with the sync api'), { code: 'ESYNC' });
+    }
+
+    return options;
+}
+
+module.exports = {
+    toPromise,
+    toSync,
+    toSyncOptions,
+};