@asterxsk/kiln 0.2.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/skillsconf/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "skillsconf",
+  "private": true,
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Per-skill visibility manager with packages (groups) for mass enable/disable",
+  "scripts": {
+    "check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "typescript": "^5.6.0"
+  },
+  "allowScripts": {},
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "^0.84.4"
+  }
+}

package/agent.bak.20260905-190020/extensions/skillsconf/src/delete-skill.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { deleteSkillFiles, resolveSkillDeleteTarget } from "./delete-skill.js";
+
+// resolve: SKILL.md -> parent dir
+assert.equal(
+  resolveSkillDeleteTarget(path.join("C:", "s", "foo", "SKILL.md")),
+  path.join("C:", "s", "foo"),
+);
+// resolve: lone file -> itself
+assert.equal(
+  resolveSkillDeleteTarget(path.join("C:", "s", "solo.md")),
+  path.join("C:", "s", "solo.md"),
+);
+// resolve: empty / relative -> null
+assert.equal(resolveSkillDeleteTarget(""), null);
+assert.equal(resolveSkillDeleteTarget("relative/SKILL.md"), null);
+
+// delete: skill dir with SKILL.md (+ extra files) goes away entirely
+{
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skillsconf-del-"));
+  const skillDir = path.join(dir, "my-skill");
+  fs.mkdirSync(path.join(skillDir, "scripts"), { recursive: true });
+  fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# test");
+  fs.writeFileSync(path.join(skillDir, "scripts", "x.py"), "x");
+  const removed = await deleteSkillFiles(path.join(skillDir, "SKILL.md"));
+  assert.equal(removed, skillDir);
+  assert.equal(fs.existsSync(skillDir), false);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// delete: lone .md file
+{
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skillsconf-del-"));
+  const file = path.join(dir, "solo.md");
+  fs.writeFileSync(file, "# test");
+  assert.equal(await deleteSkillFiles(file), file);
+  assert.equal(fs.existsSync(file), false);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// delete: missing path throws, touches nothing
+{
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skillsconf-del-"));
+  await assert.rejects(deleteSkillFiles(path.join(dir, "nope", "SKILL.md")), /not found/);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// delete: relative path refused
+await assert.rejects(deleteSkillFiles("some/SKILL.md"), /non-absolute/);
+
+// delete: type mismatch refused (non-SKILL.md path pointing at a directory)
+{
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skillsconf-del-"));
+  const sub = path.join(dir, "notmd");
+  fs.mkdirSync(sub);
+  await assert.rejects(deleteSkillFiles(sub), /expected a file/);
+  assert.equal(fs.existsSync(sub), true, "refused delete leaves dir alone");
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+console.log("delete-skill.test.ts: all assertions passed");

package/agent.bak.20260905-190020/extensions/skillsconf/src/delete-skill.ts

@@ -0,0 +1,45 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Resolve what `d` on a skill should remove from disk:
+ * - a `SKILL.md` file means the skill owns its parent directory -> remove the dir
+ * - a lone `.md` file (root-level skill) -> remove just the file
+ * Returns null when the location is missing or not absolute (never delete
+ * relative to an assumed cwd).
+ */
+export function resolveSkillDeleteTarget(filePath: string): string | null {
+  if (!filePath || !path.isAbsolute(filePath)) return null;
+  const normalized = path.normalize(filePath);
+  if (path.basename(normalized) === "SKILL.md") return path.dirname(normalized);
+  return normalized;
+}
+
+/**
+ * Delete a skill from disk. Throws on anything unexpected; callers surface
+ * the message. Refuses filesystem root, home, and items directly in home.
+ * Returns the removed path.
+ */
+export async function deleteSkillFiles(filePath: string): Promise<string> {
+  const target = resolveSkillDeleteTarget(filePath);
+  if (!target) throw new Error("unknown or non-absolute skill location");
+  const root = path.parse(target).root;
+  if (target === root) throw new Error(`refusing to delete filesystem root (${target})`);
+  const home = path.normalize(os.homedir());
+  if (target === home) throw new Error("refusing to delete home directory");
+  if (path.dirname(target) === home) {
+    throw new Error("refusing to delete items directly in home directory");
+  }
+  let st: Awaited<ReturnType<typeof fs.stat>>;
+  try {
+    st = await fs.stat(target);
+  } catch {
+    throw new Error(`not found: ${target}`);
+  }
+  const wantsDir = path.basename(path.normalize(filePath)) === "SKILL.md";
+  if (wantsDir && !st.isDirectory()) throw new Error(`expected a directory: ${target}`);
+  if (!wantsDir && !st.isFile()) throw new Error(`expected a file: ${target}`);
+  await fs.rm(target, { recursive: true });
+  return target;
+}

package/agent.bak.20260905-190020/extensions/skillsconf/src/filter.test.ts

@@ -0,0 +1,80 @@
+import assert from "node:assert";
+import { filterSkillsPrompt } from "./filter.js";
+
+function samplePrompt(): string {
+  return [
+    "You are a coding agent.",
+    "",
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>",
+    "  <skill>",
+    "    <name>alpha</name>",
+    "    <description>First skill</description>",
+    "    <location>/skills/alpha/SKILL.md</location>",
+    "  </skill>",
+    "  <skill>",
+    "    <name>beta</name>",
+    "    <description>Second skill</description>",
+    "    <location>/skills/beta/SKILL.md</location>",
+    "  </skill>",
+    "  <skill>",
+    "    <name>gamma</name>",
+    "    <description>Third skill</description>",
+    "    <location>/skills/gamma/SKILL.md</location>",
+    "  </skill>",
+    "</available_skills>",
+    "",
+    "Trailing instructions.",
+  ].join("\n");
+}
+
+const base = samplePrompt();
+
+// no disabled -> identical
+assert.equal(filterSkillsPrompt(base, []), base);
+assert.equal(filterSkillsPrompt(base, undefined), base);
+
+// unknown name -> identical
+assert.equal(filterSkillsPrompt(base, ["nope"]), base);
+
+// disable one -> only its block removed, rest verbatim
+const one = filterSkillsPrompt(base, ["beta"]);
+assert.ok(!one.includes("<name>beta</name>"), "beta block removed");
+assert.ok(one.includes("<name>alpha</name>"), "alpha kept");
+assert.ok(one.includes("<name>gamma</name>"), "gamma kept");
+assert.ok(one.includes("<available_skills>"), "wrapper kept");
+assert.ok(one.includes("Trailing instructions."), "tail kept");
+assert.ok(one.includes("You are a coding agent."), "head kept");
+
+// disable two
+const two = filterSkillsPrompt(base, ["alpha", "gamma"]);
+assert.ok(!two.includes("<name>alpha</name>"));
+assert.ok(!two.includes("<name>gamma</name>"));
+assert.ok(two.includes("<name>beta</name>"));
+assert.ok(two.includes("<available_skills>"));
+
+// disable all -> whole section gone, no stray blank lines
+const all = filterSkillsPrompt(base, ["alpha", "beta", "gamma"]);
+assert.ok(!all.includes("<available_skills>"), "wrapper removed");
+assert.ok(!all.includes("provide specialized instructions"), "intro removed");
+assert.ok(!all.includes("<name>alpha</name>"));
+assert.equal(all, "You are a coding agent.\n\nTrailing instructions.");
+
+// prompt without a skills section -> identical
+assert.equal(filterSkillsPrompt("plain prompt", ["alpha"]), "plain prompt");
+
+// XML-escaped names match
+const escaped = base.replace("<name>beta</name>", "<name>a&lt;b&gt;c</name>");
+const escFiltered = filterSkillsPrompt(escaped, ["a<b>c"]);
+assert.ok(!escFiltered.includes("a&lt;b&gt;c"), "escaped block removed");
+assert.ok(escFiltered.includes("<name>alpha</name>"));
+
+// Set input works
+const viaSet = filterSkillsPrompt(base, new Set(["gamma"]));
+assert.ok(!viaSet.includes("<name>gamma</name>"));
+assert.ok(viaSet.includes("<name>alpha</name>"));
+
+console.log("filter.test.ts: all assertions passed");

package/agent.bak.20260905-190020/extensions/skillsconf/src/filter.ts

@@ -0,0 +1,74 @@
+// Removes disabled skills from a built system prompt.
+//
+// pi renders loaded skills as a verbatim XML block:
+//
+//   <available_skills>
+//     <skill>
+//       <name>...</name>
+//       <description>...</description>
+//       <location>...</location>
+//     </skill>
+//     ...
+//   </available_skills>
+//
+// Filtering is done by verbatim block surgery (kept blocks are untouched),
+// so prompt output never depends on re-escaping. When every skill is
+// disabled the whole section (intro + wrapper) is removed.
+
+const SECTION_INTRO = "The following skills provide specialized instructions for specific tasks.";
+const OPEN_TAG = "<available_skills>";
+const CLOSE_TAG = "</available_skills>";
+
+function unescapeXml(s: string): string {
+  return s
+    .replace(/&apos;/g, "'")
+    .replace(/&quot;/g, '"')
+    .replace(/&gt;/g, ">")
+    .replace(/&lt;/g, "<")
+    .replace(/&amp;/g, "&");
+}
+
+export function filterSkillsPrompt(
+  systemPrompt: string,
+  disabled: string[] | Set<string> | undefined,
+): string {
+  const disabledSet = disabled instanceof Set ? disabled : new Set(disabled ?? []);
+  if (disabledSet.size === 0) return systemPrompt;
+
+  // Locate the section. The intro is preceded by two newlines in the template;
+  // include them so full removal leaves no stray blank lines.
+  let start = systemPrompt.indexOf("\n\n" + SECTION_INTRO);
+  let introLen = 2 + SECTION_INTRO.length;
+  if (start === -1) {
+    start = systemPrompt.indexOf(SECTION_INTRO);
+    introLen = SECTION_INTRO.length;
+    if (start === -1) return systemPrompt;
+  }
+  const openIdx = systemPrompt.indexOf(OPEN_TAG, start);
+  if (openIdx === -1) return systemPrompt;
+  const closeIdx = systemPrompt.indexOf(CLOSE_TAG, openIdx);
+  if (closeIdx === -1) return systemPrompt;
+
+  const bodyStart = openIdx + OPEN_TAG.length;
+  const closeEnd = closeIdx + CLOSE_TAG.length;
+  const body = systemPrompt.slice(bodyStart, closeIdx);
+
+  const blockRe = /  <skill>\n[\s\S]*?\n  <\/skill>/g;
+  const blocks = body.match(blockRe);
+  if (!blocks) return systemPrompt;
+
+  const kept: string[] = [];
+  let removed = 0;
+  for (const b of blocks) {
+    const m = b.match(/<name>([\s\S]*?)<\/name>/);
+    const name = m ? unescapeXml(m[1]) : "";
+    if (name && disabledSet.has(name)) removed++;
+    else kept.push(b);
+  }
+  if (removed === 0) return systemPrompt;
+  if (kept.length === 0) {
+    // Drop the entire section including its leading blank lines.
+    return systemPrompt.slice(0, start) + systemPrompt.slice(closeEnd);
+  }
+  return systemPrompt.slice(0, bodyStart) + "\n" + kept.join("\n") + "\n" + systemPrompt.slice(closeIdx);
+}

package/agent.bak.20260905-190020/extensions/skillsconf/src/fuzzy.ts

@@ -0,0 +1,26 @@
+export function fuzzyScore(query: string, target: string): number | null {
+  if (!query) return 0;
+  const q = query.toLowerCase();
+  const t = target.toLowerCase();
+  let qi = 0, ti = 0, score = 0, last = -2;
+  for (; qi < q.length && ti < t.length; ti++) {
+    if (q[qi] === t[ti]) {
+      // bonus for contiguous + start-of-word
+      score += (ti === last + 1 ? 2 : 1);
+      if (ti === 0 || t[ti-1] === "/" || t[ti-1] === "-" || t[ti-1] === "_") score += 2;
+      last = ti; qi++;
+    }
+  }
+  if (qi !== q.length) return null;
+  // penalize longer targets slightly
+  score -= Math.floor(t.length / 20);
+  return score;
+}
+
+export function fuzzyFilter<T>(query: string, items: T[], key: (t:T)=>string): T[] {
+  if (!query.trim()) return items;
+  const scored = items.map(i => ({ i, s: fuzzyScore(query, key(i)) }))
+    .filter(x => x.s !== null) as Array<{i:T; s:number}>;
+  scored.sort((a,b)=> b.s - a.s);
+  return scored.map(x=>x.i);
+}

package/agent.bak.20260905-190020/extensions/skillsconf/src/persistence.test.ts

@@ -0,0 +1,72 @@
+import assert from "node:assert";
+import {
+  cloneState,
+  isDisabled,
+  normalizeMembers,
+  statesEqual,
+  toggleMembership,
+  togglePackage,
+  toggleSkill,
+} from "./persistence.js";
+import type { SkillState } from "./persistence.js";
+
+// isDisabled
+assert.equal(isDisabled("a", undefined), false);
+assert.equal(isDisabled("a", []), false);
+assert.equal(isDisabled("a", ["a"]), true);
+assert.equal(isDisabled("b", ["a"]), false);
+
+// toggleSkill
+assert.deepEqual(toggleSkill("a", undefined), ["a"]);
+assert.deepEqual(toggleSkill("a", ["a"]), undefined);
+assert.deepEqual(toggleSkill("b", ["a"]), ["a", "b"]);
+assert.deepEqual(toggleSkill("a", ["a", "b"]), ["b"]);
+
+// togglePackage: partial -> disable all; full -> enable all
+assert.deepEqual(togglePackage(["a", "b"], undefined), ["a", "b"]);
+assert.deepEqual(togglePackage(["a", "b"], ["a"]), ["a", "b"]);
+assert.deepEqual(togglePackage(["a", "b"], ["a", "b"]), undefined);
+// preserves unrelated disabled entries
+assert.deepEqual(togglePackage(["a"], ["a", "z"]), ["z"]);
+// empty package -> no change
+assert.deepEqual(togglePackage([], ["a"]), ["a"]);
+assert.equal(togglePackage([], undefined), undefined);
+
+// toggleMembership
+assert.deepEqual(toggleMembership(["a"], "b"), ["a", "b"]);
+assert.deepEqual(toggleMembership(["a", "b"], "a"), ["b"]);
+assert.deepEqual(toggleMembership([], "a"), ["a"]);
+
+// normalizeMembers dedupes + sorts
+assert.deepEqual(normalizeMembers(["b", "a", "b"]), ["a", "b"]);
+
+// statesEqual
+const s = (disabled: string[] | undefined, packages: SkillState["packages"]): SkillState => ({
+  disabled,
+  packages,
+});
+assert.equal(statesEqual(s(undefined, {}), s(undefined, {})), true);
+assert.equal(statesEqual(s(["a"], {}), s(undefined, {})), false);
+assert.equal(statesEqual(s(["b", "a"], {}), s(["a", "b"], {})), true);
+assert.equal(
+  statesEqual(s(undefined, { p: ["a"] }), s(undefined, { p: ["a", "a"] })),
+  true,
+);
+assert.equal(
+  statesEqual(s(undefined, { p: ["a"] }), s(undefined, { p: ["b"] })),
+  false,
+);
+assert.equal(
+  statesEqual(s(undefined, { p: ["a"] }), s(undefined, { q: ["a"] })),
+  false,
+);
+
+// cloneState is a deep copy
+const orig = s(["a"], { p: ["x"] });
+const copy = cloneState(orig);
+assert.equal(statesEqual(orig, copy), true);
+copy.packages["p"].push("y");
+(copy.disabled as string[]).push("z");
+assert.equal(statesEqual(orig, copy), false);
+
+console.log("persistence.test.ts: all assertions passed");

package/agent.bak.20260905-190020/extensions/skillsconf/src/persistence.ts

@@ -0,0 +1,169 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type SkillPackages = Record<string, string[]>;
+
+export interface SkillState {
+  /** Names of disabled skills. undefined/empty = all enabled. */
+  disabled: string[] | undefined;
+  /** Package name -> member skill names. Never undefined (may be empty). */
+  packages: SkillPackages;
+}
+
+function settingsPath(): string {
+  return path.join(os.homedir(), ".pi", "agent", "settings.json");
+}
+
+function parseState(json: unknown): SkillState {
+  const j = (json ?? {}) as Record<string, unknown>;
+  const rawDisabled = Array.isArray(j.disabledSkills)
+    ? (j.disabledSkills as unknown[]).filter((x): x is string => typeof x === "string")
+    : undefined;
+  const rawPkgs = (j.skillPackages ?? {}) as Record<string, unknown>;
+  const packages: SkillPackages = {};
+  if (rawPkgs && typeof rawPkgs === "object") {
+    for (const [k, v] of Object.entries(rawPkgs)) {
+      if (typeof k !== "string" || !Array.isArray(v)) continue;
+      packages[k] = normalizeMembers(v.filter((x): x is string => typeof x === "string"));
+    }
+  }
+  return {
+    disabled: rawDisabled && rawDisabled.length > 0 ? [...new Set(rawDisabled)].sort() : undefined,
+    packages,
+  };
+}
+
+export async function loadSkillState(): Promise<SkillState> {
+  try {
+    const raw = await fs.readFile(settingsPath(), "utf8");
+    return parseState(JSON.parse(raw));
+  } catch {
+    return { disabled: undefined, packages: {} };
+  }
+}
+
+export function loadSkillStateSync(): SkillState {
+  try {
+    const raw = fsSync.readFileSync(settingsPath(), "utf8");
+    return parseState(JSON.parse(raw));
+  } catch {
+    return { disabled: undefined, packages: {} };
+  }
+}
+
+/**
+ * Persist state. `knownSkills` (when provided) is used to drop stale names
+ * from the disabled list and from package memberships. Packages are kept
+ * even when empty so freshly created groups survive until filled.
+ */
+export async function saveSkillState(
+  disabled: string[] | undefined,
+  packages: SkillPackages,
+  knownSkills?: string[],
+): Promise<void> {
+  const p = settingsPath();
+  let j: Record<string, unknown> = {};
+  try {
+    const raw = await fs.readFile(p, "utf8");
+    j = JSON.parse(raw) as Record<string, unknown>;
+  } catch (e: unknown) {
+    if ((e as { code?: string })?.code !== "ENOENT") {
+      try {
+        const raw = await fs.readFile(p, "utf8");
+        JSON.parse(raw);
+      } catch {}
+    }
+    j = {};
+  }
+  const known = knownSkills ? new Set(knownSkills) : null;
+  const cleanDisabled = (disabled ?? []).filter((n) => (known ? known.has(n) : true));
+  if (cleanDisabled.length === 0) delete j.disabledSkills;
+  else j.disabledSkills = [...new Set(cleanDisabled)].sort();
+
+  const cleanPkgs: SkillPackages = {};
+  for (const name of Object.keys(packages).sort()) {
+    const members = normalizeMembers(packages[name] ?? []).filter((n) =>
+      known ? known.has(n) : true,
+    );
+    cleanPkgs[name] = members;
+  }
+  if (Object.keys(cleanPkgs).length === 0) delete j.skillPackages;
+  else j.skillPackages = cleanPkgs;
+
+  await fs.writeFile(p, JSON.stringify(j, null, 2) + "\n", "utf8");
+}
+
+// ---------- pure helpers (unit-tested) ----------
+
+export function normalizeMembers(members: string[]): string[] {
+  return [...new Set(members)].sort();
+}
+
+export function isDisabled(name: string, disabled: string[] | undefined): boolean {
+  if (!disabled || disabled.length === 0) return false;
+  return disabled.includes(name);
+}
+
+/** Toggle one skill. Returns undefined when nothing ends up disabled. */
+export function toggleSkill(name: string, disabled: string[] | undefined): string[] | undefined {
+  const set = new Set(disabled ?? []);
+  if (set.has(name)) set.delete(name);
+  else set.add(name);
+  if (set.size === 0) return undefined;
+  return [...set].sort();
+}
+
+/**
+ * Toggle a whole package: if every (known) member is disabled, enable them
+ * all; otherwise disable all of them. Members unknown to the caller are
+ * passed through untouched. Returns undefined when nothing ends up disabled.
+ */
+export function togglePackage(
+  members: string[],
+  disabled: string[] | undefined,
+): string[] | undefined {
+  if (members.length === 0) return disabled && disabled.length > 0 ? [...disabled] : undefined;
+  const set = new Set(disabled ?? []);
+  const allDisabled = members.every((m) => set.has(m));
+  if (allDisabled) {
+    for (const m of members) set.delete(m);
+  } else {
+    for (const m of members) set.add(m);
+  }
+  if (set.size === 0) return undefined;
+  return [...set].sort();
+}
+
+export function toggleMembership(members: string[], name: string): string[] {
+  const set = new Set(members);
+  if (set.has(name)) set.delete(name);
+  else set.add(name);
+  return [...set].sort();
+}
+
+/** Normalized deep-equal for dirty checking. */
+export function statesEqual(a: SkillState, b: SkillState): boolean {
+  const da = a.disabled ?? [];
+  const db = b.disabled ?? [];
+  if (da.length !== db.length) return false;
+  const sa = [...da].sort();
+  const sb = [...db].sort();
+  if (JSON.stringify(sa) !== JSON.stringify(sb)) return false;
+  const ka = Object.keys(a.packages).sort();
+  const kb = Object.keys(b.packages).sort();
+  if (JSON.stringify(ka) !== JSON.stringify(kb)) return false;
+  for (const k of ka) {
+    const ma = normalizeMembers(a.packages[k] ?? []);
+    const mb = normalizeMembers(b.packages[k] ?? []);
+    if (JSON.stringify(ma) !== JSON.stringify(mb)) return false;
+  }
+  return true;
+}
+
+export function cloneState(s: SkillState): SkillState {
+  const packages: SkillPackages = {};
+  for (const [k, v] of Object.entries(s.packages)) packages[k] = [...v];
+  return { disabled: s.disabled === undefined ? undefined : [...s.disabled], packages };
+}