gentle-pi 0.2.4 → 0.2.5

package/extensions/skill-registry.ts

@@ -1,5 +1,14 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, watch, writeFileSync } from "node:fs";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	renameSync,
+	statSync,
+	watch,
+	writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, relative } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -11,7 +20,10 @@ const EXCLUDE_NAMES = new Set(["_shared", "skill-registry"]);
 const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
-const REGISTRY_SCHEMA_VERSION = 2;
+const REGISTRY_SCHEMA_VERSION = 3;
+const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
+const LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH =
+	".pi/extensions/skill-registry.ts.disabled";
 
 interface SkillEntry {
 	name: string;
@@ -188,7 +200,7 @@ function renderRegistry(cwd: string, sources: string[], entries: SkillEntry[]):
 	const lines: string[] = [];
 	lines.push(`# Skill Registry — ${projectName}`);
 	lines.push("");
-	lines.push("<!-- Auto-generated by .pi/extensions/skill-registry.ts. Run /skill-registry:refresh to regenerate. -->");
+	lines.push("<!-- Auto-generated by gentle-pi extensions/skill-registry.ts. Run /skill-registry:refresh to regenerate. -->");
 	lines.push("");
 	lines.push(`Last updated: ${today}`);
 	lines.push("");
@@ -243,6 +255,47 @@ function ensureAtlIgnored(cwd: string): void {
 	writeFileSync(gitignorePath, `${existing}${prefix}${header}${ATL_IGNORE_ENTRY}\n`);
 }
 
+function isGeneratedLegacyProjectRegistry(source: string): boolean {
+	return (
+		source.includes("Auto-generated by .pi/extensions/skill-registry.ts") &&
+		source.includes("const REGISTRY_REL_PATH = \".atl/skill-registry.md\"") &&
+		source.includes("function projectSkillDirs(cwd: string): string[]") &&
+		source.includes("function regenerateRegistry(cwd: string, force: boolean)") &&
+		(!source.includes('join(cwd, "skills")') ||
+			source.includes("const dirs = [...userSkillDirs(), ...projectSkillDirs(cwd)]") ||
+			source.includes("if (rules.length === 0) return undefined"))
+	);
+}
+
+function nextLegacyDisabledPath(cwd: string): string {
+	const base = join(cwd, LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH);
+	if (!existsSync(base)) return base;
+	for (let i = 1; i < 100; i++) {
+		const candidate = `${base}.${i}`;
+		if (!existsSync(candidate)) return candidate;
+	}
+	return `${base}.${Date.now()}`;
+}
+
+function quarantineLegacyProjectRegistry(cwd: string): boolean {
+	const legacyPath = join(cwd, LEGACY_PROJECT_REGISTRY_REL_PATH);
+	if (!existsSync(legacyPath)) return false;
+	let source = "";
+	try {
+		source = readFileSync(legacyPath, "utf8");
+	} catch {
+		return false;
+	}
+	if (!isGeneratedLegacyProjectRegistry(source)) return false;
+	const disabledPath = nextLegacyDisabledPath(cwd);
+	try {
+		renameSync(legacyPath, disabledPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 function regenerateRegistry(cwd: string, force: boolean): RegenResult {
 	const existingDirs = uniqueExistingDirs([...projectSkillDirs(cwd), ...userSkillDirs()]);
 	const files = existingDirs.flatMap(findSkillFiles).sort();
@@ -308,13 +361,29 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		try {
 			ensureAtlIgnored(ctx.cwd);
-			const result = regenerateRegistry(ctx.cwd, false);
+			const quarantinedLegacy = quarantineLegacyProjectRegistry(ctx.cwd);
+			const result = regenerateRegistry(ctx.cwd, quarantinedLegacy);
 			if (result.regenerated && ctx.hasUI) {
 				ctx.ui.notify(`Skill registry refreshed (${result.skillCount} skills)`, "info");
 			}
+			if (quarantinedLegacy && ctx.hasUI) {
+				ctx.ui.notify(
+					"Disabled stale project-local skill registry extension; using package registry with project skills first.",
+					"warning",
+				);
+			}
 			startSkillRegistryWatcher(ctx.cwd, (message) => {
 				if (ctx.hasUI) ctx.ui.notify(message, "info");
 			});
+			if (quarantinedLegacy) {
+				setTimeout(() => {
+					try {
+						regenerateRegistry(ctx.cwd, true);
+					} catch {
+						// Best-effort same-session self-heal in case the stale extension already ran.
+					}
+				}, WATCH_DEBOUNCE_MS);
+			}
 		} catch (error) {
 			if (ctx.hasUI) {
 				const message = error instanceof Error ? error.message : String(error);

package/extensions/startup-banner.ts

@@ -63,6 +63,9 @@ function padLines(lines: string[]): { lines: string[]; width: number } {
 
 type CellType =
   | "banner"
+  | "logo-tip"
+  | "logo-fresh"
+  | "logo-ink"
   | "rose"
   | "label"
   | "value"
@@ -70,6 +73,280 @@ type CellType =
   | "accent"
   | "none";
 type LayoutCell = { char: string; type: CellType };
+type LogoCellType = Extract<
+  CellType,
+  "banner" | "logo-tip" | "logo-fresh" | "logo-ink"
+>;
+
+const LOGO_CELL_TYPES: ReadonlySet<CellType> = new Set<CellType>([
+  "banner",
+  "logo-tip",
+  "logo-fresh",
+  "logo-ink",
+]);
+
+function isLogoCellType(type: CellType): type is LogoCellType {
+  return LOGO_CELL_TYPES.has(type);
+}
+
+type Span = { start: number; end: number };
+
+function computeLogoBounds(lines: string[]): Span {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const line of lines) {
+    for (let i = 0; i < line.length; i++) {
+      if (line[i] !== " ") {
+        if (i < start) start = i;
+        if (i > end) end = i;
+      }
+    }
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return { start: 0, end: 0 };
+  }
+  return { start, end };
+}
+
+function buildLetterSpans(bounds: Span, weights: number[]): Span[] {
+  const spanWidth = Math.max(1, bounds.end - bounds.start + 1);
+  const total = weights.reduce((a, b) => a + b, 0);
+  let cursor = bounds.start;
+  return weights.map((w, i) => {
+    const remaining = bounds.end - cursor + 1;
+    const raw = Math.max(1, Math.round((w / total) * spanWidth));
+    const width =
+      i === weights.length - 1
+        ? remaining
+        : Math.min(raw, remaining - (weights.length - i - 1));
+    const s = cursor;
+    const e = s + width - 1;
+    cursor = e + 1;
+    return { start: s, end: e };
+  });
+}
+
+const LOGO_BOUNDS = computeLogoBounds(TEXT_LOGO);
+const LETTER_WEIGHTS = [14, 10, 11, 10, 9, 11, 6, 13, 12]; // G E N T L E - P I
+const LETTER_SPANS = buildLetterSpans(LOGO_BOUNDS, LETTER_WEIGHTS);
+
+function letterIndexAtX(x: number): number {
+  for (let i = 0; i < LETTER_SPANS.length; i++) {
+    const s = LETTER_SPANS[i];
+    if (x >= s.start && x <= s.end) return i;
+  }
+  if (x < LETTER_SPANS[0].start) return 0;
+  return LETTER_SPANS.length - 1;
+}
+
+type Point = { x: number; y: number };
+
+function pointKey(x: number, y: number): string {
+  return `${x}:${y}`;
+}
+
+function buildLetterStrokeMap(letterIdx: number): { orderMap: Map<string, number>; maxOrder: number } {
+  const span = LETTER_SPANS[letterIdx];
+  const points: Point[] = [];
+  const pointSet = new Set<string>();
+
+  for (let y = 0; y < TEXT_LOGO.length; y++) {
+    const line = TEXT_LOGO[y] ?? "";
+    for (let x = span.start; x <= Math.min(span.end, line.length - 1); x++) {
+      if (line[x] !== " ") {
+        points.push({ x, y });
+        pointSet.add(pointKey(x, y));
+      }
+    }
+  }
+
+  const neighbors8 = [
+    [-1, -1], [0, -1], [1, -1],
+    [-1, 0],           [1, 0],
+    [-1, 1],  [0, 1],  [1, 1],
+  ] as const;
+
+  const visited = new Set<string>();
+  const components: Point[][] = [];
+
+  for (const p of points) {
+    const k = pointKey(p.x, p.y);
+    if (visited.has(k)) continue;
+
+    const stack = [p];
+    const comp: Point[] = [];
+    visited.add(k);
+
+    while (stack.length > 0) {
+      const cur = stack.pop()!;
+      comp.push(cur);
+      for (const [dx, dy] of neighbors8) {
+        const nk = pointKey(cur.x + dx, cur.y + dy);
+        if (!visited.has(nk) && pointSet.has(nk)) {
+          visited.add(nk);
+          stack.push({ x: cur.x + dx, y: cur.y + dy });
+        }
+      }
+    }
+
+    components.push(comp);
+  }
+
+  components.sort((a, b) => {
+    const ax = Math.min(...a.map((p) => p.x));
+    const bx = Math.min(...b.map((p) => p.x));
+    if (ax !== bx) return ax - bx;
+    const ay = Math.min(...a.map((p) => p.y));
+    const by = Math.min(...b.map((p) => p.y));
+    return ay - by;
+  });
+
+  const orderMap = new Map<string, number>();
+  let order = 0;
+
+  for (const comp of components) {
+    const compSet = new Set(comp.map((p) => pointKey(p.x, p.y)));
+    const compMap = new Map(comp.map((p) => [pointKey(p.x, p.y), p]));
+
+    let current = comp.reduce((best, p) =>
+      p.x < best.x || (p.x === best.x && p.y < best.y) ? p : best,
+    );
+
+    let dirX = 1;
+    let dirY = 0;
+
+    while (compSet.size > 0) {
+      const ck = pointKey(current.x, current.y);
+      if (compSet.has(ck)) {
+        compSet.delete(ck);
+        orderMap.set(ck, order++);
+      }
+      if (compSet.size === 0) break;
+
+      const candidates: Point[] = [];
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          if (dx === 0 && dy === 0) continue;
+          const nk = pointKey(current.x + dx, current.y + dy);
+          if (compSet.has(nk)) {
+            const point = compMap.get(nk);
+            if (point) candidates.push(point);
+          }
+        }
+      }
+
+      let next: Point | null = null;
+      if (candidates.length > 0) {
+        candidates.sort((a, b) => {
+          const adx = a.x - current.x;
+          const ady = a.y - current.y;
+          const bdx = b.x - current.x;
+          const bdy = b.y - current.y;
+
+          const aDist = Math.hypot(adx, ady);
+          const bDist = Math.hypot(bdx, bdy);
+          const aTurn = Math.abs(adx * dirY - ady * dirX);
+          const bTurn = Math.abs(bdx * dirY - bdy * dirX);
+
+          const aScore = aDist * 3.8 + aTurn * 1.3 + Math.abs(ady) * 0.12;
+          const bScore = bDist * 3.8 + bTurn * 1.3 + Math.abs(bdy) * 0.12;
+          return aScore - bScore;
+        });
+        next = candidates[0];
+      } else {
+        let best: Point | null = null;
+        let bestScore = Number.POSITIVE_INFINITY;
+        for (const k of compSet) {
+          const p = compMap.get(k);
+          if (!p) continue;
+          const dx = p.x - current.x;
+          const dy = p.y - current.y;
+          const score = Math.hypot(dx, dy) + Math.abs(dy) * 0.16;
+          if (score < bestScore) {
+            bestScore = score;
+            best = p;
+          }
+        }
+        next = best;
+      }
+
+      if (!next) break;
+      dirX = next.x - current.x;
+      dirY = next.y - current.y;
+      current = next;
+    }
+  }
+
+  return { orderMap, maxOrder: Math.max(1, order - 1) };
+}
+
+const LETTER_STROKES = LETTER_SPANS.map((_, i) => buildLetterStrokeMap(i));
+const WRITING_START_TICK = 6;
+const LETTER_TICKS = LETTER_STROKES.map((s) =>
+  Math.max(5, Math.ceil(((s.maxOrder + 8) / 11) * 0.48)),
+);
+const LETTER_START_TICKS = LETTER_TICKS.map((_, i) =>
+  WRITING_START_TICK + LETTER_TICKS.slice(0, i).reduce((a, b) => a + b, 0),
+);
+const WRITING_END_TICK = WRITING_START_TICK + LETTER_TICKS.reduce((a, b) => a + b, 0);
+
+function buildPenLogoLine(
+  line: string,
+  rowIdx: number,
+  _totalRows: number,
+  tick: number,
+): LayoutCell[] {
+  const out: LayoutCell[] = [];
+
+  for (let x = 0; x < line.length; x++) {
+    const ch = line[x] ?? " ";
+    if (ch === " ") {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const letterIdx = letterIndexAtX(x);
+    const stroke = LETTER_STROKES[letterIdx];
+    const startTick = LETTER_START_TICKS[letterIdx];
+    const duration = LETTER_TICKS[letterIdx];
+    const progress = (tick - startTick) / Math.max(1, duration);
+
+    if (progress < 0) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const head = progress * (stroke.maxOrder + 7);
+    const rawOrder = stroke.orderMap.get(pointKey(x, rowIdx));
+    if (rawOrder === undefined) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    let order = rawOrder;
+    // v1: ajuste SOLO para la primera letra (G), con más curvatura caligráfica.
+    if (letterIdx === 0) {
+      const s = LETTER_SPANS[0];
+      const w = Math.max(1, s.end - s.start + 1);
+      const localX = x - s.start;
+      const curveBias =
+        Math.sin((localX / w) * Math.PI * 1.35 + rowIdx * 0.26) * 2.2 +
+        Math.cos((localX / w) * Math.PI * 0.72 - rowIdx * 0.20) * 1.3;
+      order = rawOrder + curveBias;
+    }
+
+    if (head < order) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const age = head - order;
+    if (age < 1.2) out.push({ char: ch, type: "logo-tip" });
+    else if (age < 4.9) out.push({ char: ch, type: "logo-fresh" });
+    else out.push({ char: ch, type: "logo-ink" });
+  }
+  return out;
+}
 
 class LayoutBuilder {
   lines: LayoutCell[][] = [];
@@ -106,10 +383,6 @@ export default function (pi: ExtensionAPI) {
 
     process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
 
-    const finishIntro = () => {
-      ctx.ui.setHeader(undefined);
-    };
-
     const roseBase = padLines(normalizeAscii(ROSE_LARGE_RAW));
     const logoBase = padLines(TEXT_LOGO);
 
@@ -177,12 +450,11 @@ export default function (pi: ExtensionAPI) {
 
         state.timer = setInterval(() => {
           tick++;
-          if (tick > 90) {
+          if (tick > WRITING_END_TICK + 22) {
             if (state.timer) {
               clearInterval(state.timer);
               state.timer = null;
             }
-            finishIntro();
             return;
           }
           try {
@@ -193,15 +465,15 @@ export default function (pi: ExtensionAPI) {
               state.timer = null;
             }
           }
-        }, 50);
+        }, 25);
 
         return {
           render(width: number): string[] {
-            const flashStartTick = 16;
-            const roseOpacity = Math.min(1, tick / 16);
+            const flashStartTick = 10;
+            const roseOpacity = Math.min(1, tick / 10);
             const flashPhase =
               tick >= flashStartTick
-                ? Math.max(0, 1 - (tick - flashStartTick) / 20)
+                ? Math.max(0, 1 - (tick - flashStartTick) / 12)
                 : 0;
             const frame = Math.floor(tick / 2);
 
@@ -243,16 +515,35 @@ export default function (pi: ExtensionAPI) {
                 b.addRow();
                 b.add("rose", roseLine);
                 b.add("none", "   ");
-                b.add("banner", logoLine);
+                if (logoI >= 0 && logoI < logoBase.lines.length) {
+                  b.lines[b.lines.length - 1].push(
+                    ...buildPenLogoLine(
+                      logoLine,
+                      logoI,
+                      logoBase.lines.length,
+                      tick,
+                    ),
+                  );
+                } else {
+                  b.add("none", " ".repeat(logoBase.width));
+                }
                 b.center(width);
               }
             } else {
               const showBanner = width >= logoBase.width + 2;
               const showRose = width >= roseBase.width + 2;
               if (showBanner) {
-                for (const logoLine of logoBase.lines) {
+                for (let logoI = 0; logoI < logoBase.lines.length; logoI++) {
+                  const logoLine = logoBase.lines[logoI];
                   b.addRow();
-                  b.add("banner", logoLine);
+                  b.lines[b.lines.length - 1].push(
+                    ...buildPenLogoLine(
+                      logoLine,
+                      logoI,
+                      logoBase.lines.length,
+                      tick,
+                    ),
+                  );
                   b.center(width);
                 }
                 if (showRose) {
@@ -357,9 +648,46 @@ export default function (pi: ExtensionAPI) {
             const out: string[] = [];
             const layout = b.lines;
 
+            const logoRows = layout
+              .map((row, idx) => ({
+                idx,
+                hasLogo: (row || []).some((c) => isLogoCellType(c.type)),
+              }))
+              .filter((r) => r.hasLogo)
+              .map((r) => r.idx);
+            const sparkleY =
+              logoRows.length > 0
+                ? logoRows[Math.floor(logoRows.length / 2)]
+                : -1;
+            const logoLastX = Math.max(
+              -1,
+              ...layout.map((row) => {
+                let last = -1;
+                for (let i = 0; i < (row || []).length; i++) {
+                  const cell = row?.[i];
+                  if (cell && isLogoCellType(cell.type) && cell.char !== " ") {
+                    last = i;
+                  }
+                }
+                return last;
+              }),
+            );
+
+            const glintStartTick = WRITING_END_TICK + 3;
+            const glintEndTick = WRITING_END_TICK + 12;
+            const glintActive = tick >= glintStartTick && tick <= glintEndTick;
+            const glintHead =
+              ((tick - glintStartTick) /
+                Math.max(1, glintEndTick - glintStartTick)) *
+              (LOGO_BOUNDS.end - LOGO_BOUNDS.start + 1);
+            const sparkleActive =
+              tick >= WRITING_END_TICK + 13 && tick <= WRITING_END_TICK + 20;
+
             for (let y = 0; y < layout.length; y++) {
               const row = layout[y] || [];
-              const firstBannerX = row.findIndex((c) => c.type === "banner");
+              const firstLogoX = row.findIndex(
+                (c) => isLogoCellType(c.type) && c.char !== " ",
+              );
               let line = "";
 
               for (let x = 0; x < row.length; x++) {
@@ -389,20 +717,37 @@ export default function (pi: ExtensionAPI) {
                   continue;
                 }
 
-                if (cell.type === "banner") {
-                  if (cell.char === "▒") {
-                    line += rgb(95, 30, 60, cell.char);
+                if (isLogoCellType(cell.type)) {
+                  const localLogoX = firstLogoX >= 0 ? x - firstLogoX : x;
+                  const glintOnCell =
+                    glintActive &&
+                    localLogoX >= glintHead - 2 &&
+                    localLogoX <= glintHead + 1;
+                  const sparkleOnCell =
+                    sparkleActive &&
+                    y === sparkleY &&
+                    (x === logoLastX || x === logoLastX - 1);
+
+                  if (sparkleOnCell) {
+                    line += `\x1b[1m` + rgb(255, 255, 255, "✦") + `\x1b[22m`;
                     continue;
                   }
-                  const localX = firstBannerX >= 0 ? x - firstBannerX : x;
-                  const sweep = Math.floor((tick - 16) * 2.2);
-                  const isFlashing =
-                    tick >= 16 && localX >= sweep - 4 && localX <= sweep + 2;
 
-                  if (isFlashing) {
-                    line += `\x1b[1m\x1b[38;2;255;255;255m${cell.char}\x1b[0m`;
+                  if (glintOnCell) {
+                    line += `\x1b[1m` + rgb(255, 245, 252, cell.char) + `\x1b[22m`;
+                    continue;
+                  }
+
+                  if (cell.type === "logo-tip") {
+                    line += `\x1b[1m` + rgb(255, 205, 238, cell.char) + `\x1b[22m`;
+                  } else if (cell.type === "logo-fresh") {
+                    line += cell.char === "▒"
+                      ? rgb(110, 36, 70, cell.char)
+                      : rgb(255, 138, 206, cell.char);
                   } else {
-                    line += rgb(255, 120, 198, cell.char);
+                    line += cell.char === "▒"
+                      ? rgb(95, 30, 60, cell.char)
+                      : rgb(255, 120, 198, cell.char);
                   }
                   continue;
                 }
@@ -435,7 +780,6 @@ export default function (pi: ExtensionAPI) {
               clearInterval(state.timer);
               state.timer = null;
             }
-            finishIntro();
           },
         };
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",