@dev-sergeev/datalab-kit 0.1.6 → 0.1.7

package/node_modules/node-addon-api/napi-inl.deprecated 2.h

@@ -0,0 +1,186 @@
+#ifndef SRC_NAPI_INL_DEPRECATED_H_
+#define SRC_NAPI_INL_DEPRECATED_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyDescriptor class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::CallbackData<Getter, Napi::Value>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* data) {
+  return Accessor(utf8name.c_str(), getter, attributes, data);
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::CallbackData<Getter, Napi::Value>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name, Getter getter, napi_property_attributes attributes, void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(nameValue, getter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
+  return Accessor(utf8name.c_str(), getter, setter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(
+      nameValue, getter, setter, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const char* utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const std::string& utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* data) {
+  return Function(utf8name.c_str(), cb, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    napi_value name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    Name name, Callable cb, napi_property_attributes attributes, void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Function(nameValue, cb, attributes, data);
+}
+
+#endif  // !SRC_NAPI_INL_DEPRECATED_H_

package/node_modules/node-addon-api/node_addon_api 2.gyp

@@ -0,0 +1,42 @@
+{
+  'targets': [
+    {
+      'target_name': 'node_addon_api',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_except',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_except_all',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+        'defines': [ 'NODE_ADDON_API_CPP_EXCEPTIONS_ALL' ]
+      }
+    },
+    {
+      'target_name': 'node_addon_api_maybe',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+        'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
+      }
+    },
+  ]
+}

package/node_modules/node-addon-api/node_api 2.gyp

@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'nothing',
+      'type': 'static_library',
+      'sources': [ 'nothing.c' ]
+    }
+  ]
+}

package/node_modules/node-addon-api/noexcept 2.gypi

@@ -0,0 +1,26 @@
+{
+  'defines': [ 'NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS' ],
+  'cflags': [ '-fno-exceptions' ],
+  'cflags_cc': [ '-fno-exceptions' ],
+  'conditions': [
+    ["OS=='win'", {
+      # _HAS_EXCEPTIONS is already defined and set to 0 in common.gypi
+      #"defines": [
+      #  "_HAS_EXCEPTIONS=0"
+      #],
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          'ExceptionHandling': 0,
+          'EnablePREfast': 'true',
+        },
+      },
+    }],
+    ["OS=='mac'", {
+      'xcode_settings': {
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',
+      },
+    }],
+  ],
+}

package/node_modules/pi-toggle-skills/toggle-skills 2.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 2.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/sprintf-js/.npmignore 2

@@ -0,0 +1 @@
+/node_modules/

package/node_modules/sprintf-js/LICENSE 2

@@ -0,0 +1,24 @@
+Copyright (c) 2007-2014, Alexandru Marasteanu <hello [at) alexei (dot] ro>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this software nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.