@asterxsk/kiln 0.1.0 → 0.2.0

package/agent/extensions/taste/index.ts

@@ -1,443 +0,0 @@
-/**
- * pi-taste — local "taste" learning, no npx / no network.
- *
- * Mirrors Command Code's Taste but entirely on-disk:
- *  - Learns preferences from each completed request via the active local model.
- *  - Stores them as markdown at two scopes:
- *      Global : ~/.pi/agent/extensions/taste/taste.md   (applies to ALL projects)
- *      Project: <cwd>/.pi/taste/taste.md                (this codebase only)
- *  - Feeds high-confidence learnings back into the system prompt each turn.
- *
- * Confidence system: new learning = newConfidence (0.40); a repeat (same
- * category + normalized text) raises confidence by repeatIncrement (0.10),
- * capped at 0.95. Only learnings >= applyThreshold (0.60) are injected.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
-import { uuidv7 } from "@earendil-works/pi-ai";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-// ---- Paths -------------------------------------------------------------
-// Global taste lives INSIDE this extension's folder (per user request).
-const EXT_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "taste");
-const GLOBAL_TASTE = path.join(EXT_DIR, "taste.md");
-const GLOBAL_SETTINGS = path.join(EXT_DIR, "settings.json");
-
-const projectTasteFile = (cwd: string) =>
-  path.join(cwd, CONFIG_DIR_NAME, "taste", "taste.md");
-const projectSettingsFile = (cwd: string) =>
-  path.join(cwd, CONFIG_DIR_NAME, "taste", "settings.json");
-
-// ---- Settings ----------------------------------------------------------
-interface Settings {
-  learning: boolean;
-  applyThreshold: number;
-  newConfidence: number;
-  repeatIncrement: number;
-  minPromptLength: number;
-  minIntervalMs: number;
-}
-
-const DEFAULTS: Settings = {
-  learning: true,
-  applyThreshold: 0.6,
-  newConfidence: 0.4,
-  repeatIncrement: 0.1,
-  minPromptLength: 20,
-  minIntervalMs: 15000,
-};
-
-function loadSettings(file: string): Settings {
-  try {
-    if (fs.existsSync(file)) {
-      return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(file, "utf8")) };
-    }
-  } catch {
-    /* corrupt settings -> defaults */
-  }
-  return { ...DEFAULTS };
-}
-
-// ---- Taste data model --------------------------------------------------
-interface Item {
-  text: string;
-  confidence: number;
-}
-type Taste = Map<string, Item[]>;
-
-const normalize = (s: string) =>
-  s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-
-function parseTaste(text: string): Taste {
-  const taste: Taste = new Map();
-  let category = "Other";
-  for (const line of text.split(/\r?\n/)) {
-    const h = line.match(/^#\s+(.+?)\s*$/);
-    if (h) {
-      category = h[1].trim() || "Other";
-      if (!taste.has(category)) taste.set(category, []);
-      continue;
-    }
-    const b = line.match(
-      /^-\s+(.*?)\s*\.\s*Confidence:\s*([0-9]+(?:\.[0-9]+)?)\s*$/i,
-    );
-    if (b) {
-      const items = taste.get(category) ?? [];
-      items.push({ text: b[1].trim(), confidence: parseFloat(b[2]) });
-      taste.set(category, items);
-    }
-  }
-  return taste;
-}
-
-function serializeTaste(taste: Taste): string {
-  const lines: string[] = [];
-  for (const [category, items] of taste) {
-    if (items.length === 0) continue;
-    lines.push(`# ${category}`);
-    for (const it of [...items].sort((a, b) => b.confidence - a.confidence)) {
-      lines.push(`- ${it.text}. Confidence: ${it.confidence.toFixed(2)}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n").trimEnd() + "\n";
-}
-
-/** Merge one learning; returns true if the file should be rewritten. */
-function mergeLearning(
-  taste: Taste,
-  category: string,
-  preference: string,
-  s: Settings,
-): boolean {
-  const cat = category.trim() || "Other";
-  const norm = normalize(preference);
-  if (!norm) return false;
-
-  const items = taste.get(cat) ?? [];
-  const existing = items.find((i) => normalize(i.text) === norm);
-  if (existing) {
-    const before = existing.confidence;
-    existing.confidence = Math.min(
-      0.95,
-      +(existing.confidence + s.repeatIncrement).toFixed(2),
-    );
-    return existing.confidence !== before;
-  }
-  items.push({ text: preference.trim(), confidence: s.newConfidence });
-  taste.set(cat, items);
-  return true;
-}
-
-function readTaste(file: string): Taste {
-  try {
-    if (fs.existsSync(file)) return parseTaste(fs.readFileSync(file, "utf8"));
-  } catch {
-    /* unreadable -> empty */
-  }
-  return new Map();
-}
-
-function writeTaste(file: string, taste: Taste): void {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, serializeTaste(taste), "utf8");
-}
-
-function safeDelete(file: string): void {
-  try {
-    if (fs.existsSync(file)) fs.unlinkSync(file);
-  } catch {
-    /* ignore */
-  }
-}
-
-// ---- Apply: build the system-prompt section ----------------------------
-function tasteToLines(taste: Taste, threshold: number): string[] {
-  const out: string[] = [];
-  for (const [cat, items] of taste) {
-    const applied = items.filter((i) => i.confidence >= threshold);
-    if (applied.length === 0) continue;
-    out.push(`**${cat}**`);
-    for (const it of [...applied].sort((a, b) => b.confidence - a.confidence)) {
-      out.push(`- ${it.text}. (conf ${it.confidence.toFixed(2)})`);
-    }
-  }
-  return out;
-}
-
-function buildTasteSection(
-  gTaste: Taste,
-  pTaste: Taste,
-  gThresh: number,
-  pThresh: number,
-): string {
-  const gLines = tasteToLines(gTaste, gThresh);
-  const pLines = tasteToLines(pTaste, pThresh);
-  if (gLines.length === 0 && pLines.length === 0) return "";
-
-  const parts = [
-    "## Your learned taste (pi-taste)",
-    "",
-    "Preferences learned from your past requests. Follow them unless the current request clearly overrides.",
-    "",
-  ];
-  if (gLines.length) {
-    parts.push("### Global preferences (all projects)");
-    parts.push(...gLines, "");
-  }
-  if (pLines.length) {
-    parts.push("### This project");
-    parts.push(...pLines, "");
-  }
-  return parts.join("\n").trimEnd();
-}
-
-// ---- Learn: extract preferences via the active local model ------------
-interface RawLearning {
-  category?: string;
-  preference?: string;
-  scope?: "global" | "project";
-}
-
-const EXTRACT_PROMPT = `You are a coding-preference extractor. Given a user's coding request and the assistant's outcome, extract DURABLE preferences about how this user likes to work.
-
-Rules:
-- Extract only preferences clearly evidenced by the request or the resulting choices: tooling, libraries, language style, architecture, testing, git/commit style, documentation, or communication/format.
-- Do NOT extract task-specific facts (file names, bug locations, one-off decisions).
-- For each, set scope:
-    - "global"  if it applies to ANY software project regardless of language/stack (e.g. "prefer pnpm", "write concise commit messages").
-    - "project" if it is specific to THIS codebase (its languages, frameworks, conventions, file layout).
-- Choose a short category from: CLI, TypeScript, JavaScript, Python, Rust, Go, Architecture, Testing, Git, Documentation, Style, Tooling, Communication, Other.
-
-Return ONLY minified JSON: an array of {"category":string,"preference":string,"scope":"global"|"project"}. No markdown fences, no commentary. If nothing durable, return [].`;
-
-function parseLearnings(text: string): RawLearning[] {
-  let t = text.trim();
-  const fence = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  if (fence) t = fence[1].trim();
-  try {
-    const parsed = JSON.parse(t);
-    if (!Array.isArray(parsed)) return [];
-    return parsed
-      .filter(
-        (x) =>
-          x &&
-          typeof x.preference === "string" &&
-          x.preference.trim().length > 0,
-      )
-      .map((x) => ({
-        category: typeof x.category === "string" ? x.category : "Other",
-        preference: x.preference,
-        scope: x.scope === "global" ? "global" : "project",
-      }));
-  } catch {
-    return [];
-  }
-}
-
-function lastAssistantText(ctx: ExtensionContext): string {
-  const entries = ctx.sessionManager.getEntries();
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const e = entries[i];
-    if (e.type === "message" && e.message?.role === "assistant") {
-      const c = e.message.content;
-      if (typeof c === "string") return c;
-      if (Array.isArray(c)) {
-        return c
-          .filter((p: any) => p?.type === "text")
-          .map((p: any) => p.text)
-          .join("\n");
-      }
-      return "";
-    }
-  }
-  return "";
-}
-
-async function extractLearnings(
-  ctx: ExtensionContext,
-  userPrompt: string,
-  assistantText: string,
-): Promise<RawLearning[]> {
-  if (!ctx.model) return [];
-  if (!ctx.modelRegistry.hasConfiguredAuth(ctx.model)) return [];
-
-  const context = {
-    messages: [
-      {
-        role: "user" as const,
-        content: [
-          {
-            type: "text" as const,
-            text:
-              EXTRACT_PROMPT +
-              `\n\nUSER REQUEST:\n${userPrompt}\n\nASSISTANT OUTCOME:\n${assistantText}`,
-          },
-        ],
-        timestamp: Date.now(),
-      },
-    ],
-  } as any;
-
-  const res = await ctx.modelRegistry.complete(ctx.model, context, {
-    reasoningEffort: "low",
-    cacheRetention: "none",
-    sessionId: uuidv7(),
-  });
-
-  const text = res.content
-    .filter((c: any) => c.type === "text")
-    .map((c: any) => c.text)
-    .join("");
-  return parseLearnings(text);
-}
-
-// ---- Wiring ------------------------------------------------------------
-export default function (pi: ExtensionAPI) {
-  let lastUserPrompt = "";
-  let lastLearnAt = 0;
-  let pendingLearn: Promise<void> | null = null;
-  // True only between a genuine user `input` and that turn's `agent_settled`.
-  // Synthetic re-runs (auto-compaction, retries) emit no `input`, so this
-  // stays false and we never learn preferences from a system-generated prompt.
-  let freshInput = false;
-
-  // A genuine user submission arms learning. Extension-injected messages
-  // (source "extension") are excluded so we don't learn the taste of our own
-  // meta-prompts (e.g. review-subagent instructions).
-  pi.on("input", (event) => {
-    if (event.source !== "extension") freshInput = true;
-  });
-
-  // Apply: inject learned taste before each agent run.
-  pi.on("before_agent_start", (event, ctx) => {
-    if (freshInput) lastUserPrompt = event.prompt ?? "";
-
-
-    const gSettings = loadSettings(GLOBAL_SETTINGS);
-    const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
-    const gTaste = readTaste(GLOBAL_TASTE);
-    const pTaste = readTaste(projectTasteFile(ctx.cwd));
-
-    const section = buildTasteSection(
-      gTaste,
-      pTaste,
-      gSettings.applyThreshold,
-      pSettings.applyThreshold,
-    );
-    if (!section) return;
-    return { systemPrompt: event.systemPrompt + "\n\n" + section };
-  });
-
-  // Learn: after a request fully settles (no retry/compact/follow-up left).
-  pi.on("agent_settled", async (_event, ctx) => {
-    const gSettings = loadSettings(GLOBAL_SETTINGS);
-    const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
-    if (!gSettings.learning && !pSettings.learning) return;
-    if (!freshInput) return; // synthetic re-run (e.g. auto-compaction) — skip
-    freshInput = false; // this genuine turn is now being consumed
-
-    const prompt = lastUserPrompt.trim();
-    if (!prompt || prompt.length < gSettings.minPromptLength) return;
-    if (prompt.startsWith("/taste")) return; // don't learn from our own command
-
-    // Rate-limit window follows whichever scope is actually learning.
-    const interval = gSettings.learning
-      ? gSettings.minIntervalMs
-      : pSettings.minIntervalMs;
-    if (Date.now() - lastLearnAt < interval) return;
-
-    const assistantText = lastAssistantText(ctx);
-    if (!assistantText) return;
-
-    const learnings = await extractLearnings(ctx, prompt, assistantText);
-    if (learnings.length === 0) return;
-
-    // Only consume the cooldown once we actually learned something.
-    lastLearnAt = Date.now();
-
-    const task = (async () => {
-      let wrote = false;
-      for (const l of learnings) {
-        const isGlobal = l.scope === "global";
-        const settings = isGlobal ? gSettings : pSettings;
-        if (!settings.learning) continue;
-        const file = isGlobal ? GLOBAL_TASTE : projectTasteFile(ctx.cwd);
-        const taste = readTaste(file);
-        if (mergeLearning(taste, l.category ?? "Other", l.preference ?? "", settings)) {
-          writeTaste(file, taste);
-          wrote = true;
-        }
-      }
-      if (wrote && ctx.hasUI) {
-        ctx.ui.notify(
-          `TASTE learned ${learnings.length} preference(s)`,
-          "info",
-        );
-      }
-    })();
-    pendingLearn = task;
-    await task;
-  });
-
-  // Flush any in-flight learning so it isn't lost on exit.
-  pi.on("session_shutdown", async () => {
-    if (pendingLearn) {
-      try {
-        await pendingLearn;
-      } catch {
-        /* ignore */
-      }
-    }
-  });
-
-  // /taste — view or reset learnings.
-  pi.registerCommand("taste", {
-    description:
-      "Show or reset learned taste. Usage: /taste [reset [global|project]]",
-    handler: async (args, ctx) => {
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      if (parts[0] === "reset") {
-        const scope = parts[1];
-        if (scope === "global") {
-          safeDelete(GLOBAL_TASTE);
-          ctx.ui.notify("Cleared global taste.", "info");
-        } else if (scope === "project") {
-          safeDelete(projectTasteFile(ctx.cwd));
-          ctx.ui.notify("Cleared project taste.", "info");
-        } else if (!scope) {
-          safeDelete(GLOBAL_TASTE);
-          safeDelete(projectTasteFile(ctx.cwd));
-          ctx.ui.notify("Cleared global + project taste.", "info");
-        } else {
-          ctx.ui.notify(
-            `Unknown scope '${scope}'. Use 'global' or 'project'.`,
-            "warning",
-          );
-        }
-        return;
-      }
-
-      const g = readTaste(GLOBAL_TASTE);
-      const p = readTaste(projectTasteFile(ctx.cwd));
-      const gSettings = loadSettings(GLOBAL_SETTINGS);
-      const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
-      const count = (t: Taste) =>
-        [...t.values()].reduce((n, a) => n + a.length, 0);
-      const applied = (t: Taste, th: number) =>
-        [...t.values()].flat().filter((i) => i.confidence >= th).length;
-
-      ctx.ui.notify(
-        [
-          `TASTE — global : ${count(g)} prefs (${applied(g, gSettings.applyThreshold)} applied) → ${GLOBAL_TASTE}`,
-          `TASTE — project: ${count(p)} prefs (${applied(p, pSettings.applyThreshold)} applied) → ${projectTasteFile(ctx.cwd)}`,
-          `Run '/taste reset [global|project]' to clear.`,
-        ].join("\n"),
-        "info",
-      );
-    },
-  });
-}

package/agent/extensions/taste/install.ps1

@@ -1,23 +0,0 @@
-#!/usr/bin/env pwsh
-# Per-extension installer — Windows / PowerShell
-# Installs npm dependencies for this extension. No-op if no package.json.
-$ErrorActionPreference = "Stop"
-$extDir = $PSScriptRoot
-if (-not $extDir) { $extDir = Split-Path -Parent $MyInvocation.MyCommand.Path }
-if (-not (Test-Path "$extDir/package.json")) {
-  Write-Host "  - no package.json — skipping" -ForegroundColor DarkGray
-  exit 0
-}
-if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
-  Write-Host "  x npm not found — install Node.js 22+" -ForegroundColor Red
-  exit 1
-}
-if (Test-Path "$extDir/package-lock.json") {
-  Write-Host "  - npm ci" -ForegroundColor DarkGray
-  npm --prefix $extDir ci --no-audit --no-fund
-} else {
-  Write-Host "  - npm install" -ForegroundColor DarkGray
-  npm --prefix $extDir install --no-audit --no-fund
-}
-if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-Write-Host "  + done" -ForegroundColor Green

package/agent/extensions/taste/install.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-# Per-extension installer — macOS / Linux
-# Installs npm dependencies for this extension. No-op if no package.json.
-set -eu
-EXT_DIR="$(cd "$(dirname "$0")" && pwd)"
-if [ ! -f "$EXT_DIR/package.json" ]; then
-  echo "  · no package.json — skipping"
-  exit 0
-fi
-if ! command -v npm >/dev/null 2>&1; then
-  echo "  ✖ npm not found — install Node.js 22+" >&2
-  exit 1
-fi
-if [ -f "$EXT_DIR/package-lock.json" ]; then
-  echo "  · npm ci"
-  npm --prefix "$EXT_DIR" ci --no-audit --no-fund
-else
-  echo "  · npm install"
-  npm --prefix "$EXT_DIR" install --no-audit --no-fund
-fi
-echo "  ✓ done"