pi-ui-extend 0.1.43 → 0.1.44

package/external/pi-tools-suite/README.md

@@ -18,10 +18,11 @@ This package keeps shared Pi tools as ordinary source folders under `src/` and r
 - `src/web-search` — `web_search` and `web_fetch` tools migrated from `@ollama/pi-web-search`; calls the local Ollama experimental web search/fetch APIs, honors `OLLAMA_HOST`, supports request timeouts via `timeout_ms` / `PI_WEB_SEARCH_TIMEOUT_MS`, and reports targeted `ollama signin`, unsupported-endpoint, invalid-response, timeout, DNS, and Ollama-not-running errors
 - `src/dcp` — headless Dynamic Context Pruning ported from `opencode-dynamic-context-pruning` for the Pi SDK: explicit `compress` tool with range and message modes, `/dcp` commands (context, stats, sweep, manual, decompress, recompress, compress), same-call overlap validation, recoverable compressed-block rollups, grouped message-mode skip diagnostics, stable raw-message anchors when available, protected user/tool preservation, deduplication, error purging, and context nudges; visualization is left to `compress` tool responses and the renderer-owned context-percent click dialog
 - `src/prompt-commands` — user slash-command builder: `/prompt-commands` opens a CRUD menu for saved prompt-backed slash commands, stores them under `promptCommands` in `~/.config/pi/pi-tools-suite.jsonc`, reloads after edits, and runs each saved prompt as a normal user message
+- `src/skill-installer` — `/install-skill [name]` installs a personal skill folder from `~/.agents/local_skills` into the current project's `.pi/skills/` so it activates as a project-local skill, then automatically runs `/reload` so the new skill is picked up without a manual step; `/export-skill [name]` does the reverse, copying a project-local skill back to `~/.agents/local_skills/` for reuse in other projects (no reload, since the library lives outside the project); with no argument either command shows an interactive menu of available skills (folders containing `SKILL.md`), and the `<name>` form installs/exports it directly (headless-safe); existing destinations prompt to overwrite in the UI and are refused in headless mode; `.DS_Store` files are skipped
 
 `index.ts` is intentionally only a thin auto-discovery shim that re-exports `src/index.ts`. There is no `pi.extensions` manifest here, so local Pi auto-discovery loads the suite once via `~/.pi/agent/extensions/pi-tools-suite/index.ts` and does not double-register tools.
 
-Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
+Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, prompt-commands, then skill-installer. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
 
 ## Disabling modules
 

package/external/pi-tools-suite/src/coding-discipline/index.ts

@@ -88,7 +88,8 @@ const QUALITY_DISCIPLINE_LINES = [
 	"- for bugs, prefer a failing repro first, then the minimal fix, then verify;",
 	"- high-risk changes (security, data/schema, public APIs, concurrency, irreversible) need a short spec first;",
 	"- handle edge cases, errors, cancellation, and async behavior; do not block UI/event loops;",
-	"- avoid duplicate state, duplicate prompts, and repeated side effects.",
+	"- avoid duplicate state, duplicate prompts, and repeated side effects;",
+	"- write code, identifiers, comments, and commit messages in English.",
 ];
 
 const LOOKUP_DISCIPLINE_LINES = [

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -57,6 +57,20 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
           "maxContextPercent": "30%"
         }
       },
+      // glm-5.2 reports a ~1M-token window. Even zai/* 16%/30% = 160K/300K is
+      // above the ~15% (~150K) point where long sessions degrade, and an
+      // observed 14h/273K-token session never crossed 16%. Lower ONLY glm-5.2
+      // within the zai family: 8%/15% (~80K/150K) so nudging starts early and
+      // auto-compress fires at the observed degradation point. Other zai/*
+      // models keep 16%/30%.
+      "zai/glm-5.2": {
+        "compress": {
+          "minContextPercent": "8%",
+          "maxContextPercent": "15%",
+          "autoCandidates": { "minContextPercent": 0.08 },
+          "messageMode": { "minContextPercent": 0.08 }
+        }
+      },
       "antigravity/*sonnet*": {
         "compress": {
           "minContextPercent": "22%",

package/external/pi-tools-suite/src/index.ts

@@ -25,6 +25,7 @@ const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "web-search", load: () => import("./web-search/index") },
 	{ name: "dcp", load: () => import("./dcp/index") },
 	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
+	{ name: "skill-installer", load: () => import("./skill-installer/index") },
 	{ name: "telegram-mirror", load: () => import("./telegram-mirror/index") },
 ];
 

package/external/pi-tools-suite/src/skill-installer/index.ts

@@ -0,0 +1,333 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, relative } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { ignoreStaleExtensionContextError } from "../context-usage.js";
+
+const INSTALL_COMMAND = "install-skill";
+const EXPORT_COMMAND = "export-skill";
+const LOCAL_SKILLS_DIR = join(homedir(), ".agents", "local_skills");
+const SKILL_FILE = "SKILL.md";
+const PROJECT_DIR = ".pi";
+const PROJECT_SKILLS_SUBDIR = "skills";
+const SKIP_NAMES = new Set([".DS_Store"]);
+const DESC_MAX = 90;
+
+type SkillEntry = {
+	name: string;
+	path: string;
+	description: string;
+};
+
+/** Direction-aware transfer plan shared by install and export. */
+type Transfer = {
+	srcDir: string;
+	destDir: string;
+	/** Human label for the destination root (with trailing slash); name is appended per skill. */
+	destRootLabel: string;
+	commandName: string;
+	direction: "install" | "export";
+};
+
+function localSkillsLabel(): string {
+	const home = homedir();
+	return LOCAL_SKILLS_DIR === home ? LOCAL_SKILLS_DIR : LOCAL_SKILLS_DIR.replace(home, "~");
+}
+
+function projectSkillsDir(ctx: ExtensionContext): string {
+	return join(ctx.cwd, PROJECT_DIR, PROJECT_SKILLS_SUBDIR);
+}
+
+function projectSkillsLabel(ctx: ExtensionContext): string {
+	return displayPath(ctx, projectSkillsDir(ctx));
+}
+
+function displayPath(ctx: ExtensionContext, absPath: string): string {
+	const rel = relative(ctx.cwd, absPath);
+	return rel && !rel.startsWith("..") ? rel : absPath;
+}
+
+function notify(ctx: ExtensionContext, message: string, type: "info" | "warning" | "error" = "info"): void {
+	if (ctx.hasUI) ctx.ui.notify(message, type);
+	else console.log(message);
+}
+
+function truncate(value: string, maxLength: number): string {
+	const collapsed = value.replace(/\s+/g, " ").trim();
+	return collapsed.length <= maxLength ? collapsed : `${collapsed.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+/** Extract the `description` scalar from SKILL.md YAML frontmatter. Returns "" when absent/unparseable. */
+function parseFrontmatterDescription(content: string): string {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match) return "";
+	const front = match[1] ?? "";
+	const lines = front.split(/\r?\n/);
+	const idx = lines.findIndex((line) => /^\s*description:\s*/.test(line));
+	if (idx === -1) return "";
+	const headerLine = lines[idx];
+	if (!headerLine) return "";
+	const after = headerLine.replace(/^\s*description:\s*/, "");
+
+	// Folded/literal block scalar (>, >-, |, |-)
+	if (/^[>|]/.test(after)) {
+		const block: string[] = [];
+		for (let i = idx + 1; i < lines.length; i += 1) {
+			const line = lines[i] ?? "";
+			if (line === "") {
+				block.push(" ");
+				continue;
+			}
+			if (/^\s+/.test(line)) {
+				block.push(line.replace(/^\s+/, ""));
+				continue;
+			}
+			break;
+		}
+		return block.join(" ").trim();
+	}
+
+	// Plain or quoted scalar
+	let value = after.trim();
+	if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+		value = value.slice(1, -1);
+	}
+	return value;
+}
+
+async function readSkillDescription(skillDir: string): Promise<string> {
+	try {
+		const content = await fs.readFile(join(skillDir, SKILL_FILE), "utf-8");
+		return parseFrontmatterDescription(content);
+	} catch {
+		return "";
+	}
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await fs.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/** Scan a skills directory: every subdirectory that contains SKILL.md. Returns ENOENT as empty. */
+async function scanSkills(dir: string): Promise<SkillEntry[]> {
+	let entries: import("node:fs").Dirent[];
+	try {
+		entries = await fs.readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
+	}
+
+	const skills: SkillEntry[] = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || SKIP_NAMES.has(entry.name)) continue;
+		const skillPath = join(dir, entry.name);
+		if (!(await pathExists(join(skillPath, SKILL_FILE)))) continue;
+		skills.push({ name: entry.name, path: skillPath, description: await readSkillDescription(skillPath) });
+	}
+	return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function listLocalSkills(): Promise<SkillEntry[]> {
+	return scanSkills(LOCAL_SKILLS_DIR);
+}
+
+function listProjectSkills(ctx: ExtensionContext): Promise<SkillEntry[]> {
+	return scanSkills(projectSkillsDir(ctx));
+}
+
+function skillLabel(skill: SkillEntry): string {
+	const description = skill.description.replace(/\s+/g, " ").trim();
+	return description ? `${skill.name} — ${truncate(description, DESC_MAX)}` : skill.name;
+}
+
+async function copySkill(source: string, dest: string): Promise<void> {
+	await fs.mkdir(join(dest, ".."), { recursive: true });
+	await fs.cp(source, dest, {
+		recursive: true,
+		filter: (src) => !SKIP_NAMES.has(basename(src)),
+	});
+}
+
+/** Copy a skill folder from srcDir/name → destDir/name with overwrite-confirm (UI) / refuse (headless). */
+async function transferSkill(ctx: ExtensionCommandContext, name: string, t: Transfer): Promise<void> {
+	const src = join(t.srcDir, name);
+	const dest = join(t.destDir, name);
+
+	if (await pathExists(dest)) {
+		if (!ctx.hasUI) {
+			notify(ctx, `Skill "${name}" already exists at ${t.destRootLabel}${name}. Remove it first or run /${t.commandName} ${name} interactively to overwrite.`, "error");
+			return;
+		}
+		let confirmed = false;
+		try {
+			confirmed = await ctx.ui.confirm("Skill already exists", `"${name}" already exists in ${t.destRootLabel}. Overwrite it?`);
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+			return;
+		}
+		if (!confirmed) {
+			notify(ctx, `Cancelled. "${name}" left unchanged.`);
+			return;
+		}
+		await fs.rm(dest, { recursive: true, force: true });
+	}
+
+	try {
+		await copySkill(src, dest);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		notify(ctx, `Failed to ${t.direction} skill "${name}": ${message}`, "error");
+		return;
+	}
+
+	if (t.direction === "install") {
+		notify(ctx, `Installed skill "${name}" → ${t.destRootLabel}${name}. Reloading to activate…`);
+		try {
+			await ctx.reload();
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
+		return;
+	}
+
+	notify(ctx, `Exported skill "${name}" → ${t.destRootLabel}${name}. Available for /install-skill in other projects.`);
+}
+
+function installTransfer(ctx: ExtensionCommandContext): Transfer {
+	return {
+		srcDir: LOCAL_SKILLS_DIR,
+		destDir: projectSkillsDir(ctx),
+		destRootLabel: `${projectSkillsLabel(ctx)}/`,
+		commandName: INSTALL_COMMAND,
+		direction: "install",
+	};
+}
+
+function exportTransfer(ctx: ExtensionCommandContext): Transfer {
+	return {
+		srcDir: projectSkillsDir(ctx),
+		destDir: LOCAL_SKILLS_DIR,
+		destRootLabel: `${localSkillsLabel()}/`,
+		commandName: EXPORT_COMMAND,
+		direction: "export",
+	};
+}
+
+// --- install ---
+
+async function showInstallMenu(ctx: ExtensionCommandContext): Promise<void> {
+	const skills = await listLocalSkills();
+	if (skills.length === 0) {
+		notify(ctx, `No skills found in ${localSkillsLabel()} (each skill is a folder containing ${SKILL_FILE}).`, "warning");
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		notify(ctx, `Available skills in ${localSkillsLabel()}:\n${skills.map((s) => s.name).join("\n")}\n\nUse /${INSTALL_COMMAND} <name> to install one.`, "warning");
+		return;
+	}
+
+	const t = installTransfer(ctx);
+	const labels = skills.map(skillLabel);
+	const labelToName = new Map(labels.map((label, index) => [label, skills[index]!.name]));
+	let selected: string | undefined;
+	try {
+		selected = await ctx.ui.select(`Install skill into ${projectSkillsLabel(ctx)}/ (${localSkillsLabel()})`, labels);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+		return;
+	}
+	if (!selected) return;
+
+	const name = labelToName.get(selected);
+	if (!name) return;
+	await transferSkill(ctx, name, t);
+}
+
+async function installByName(ctx: ExtensionCommandContext, name: string): Promise<void> {
+	const skills = await listLocalSkills();
+	const match = skills.find((entry) => entry.name === name);
+	if (!match) {
+		const available = skills.length > 0 ? skills.map((s) => s.name).join(", ") : "(none)";
+		notify(ctx, `No skill named "${name}" in ${localSkillsLabel()}. Available: ${available}`, "error");
+		return;
+	}
+	await transferSkill(ctx, match.name, installTransfer(ctx));
+}
+
+// --- export ---
+
+async function showExportMenu(ctx: ExtensionCommandContext): Promise<void> {
+	const skills = await listProjectSkills(ctx);
+	if (skills.length === 0) {
+		notify(ctx, `No skills found in ${projectSkillsLabel(ctx)}/. Install one first with /${INSTALL_COMMAND}.`, "warning");
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		notify(ctx, `Installed skills in ${projectSkillsLabel(ctx)}/:\n${skills.map((s) => s.name).join("\n")}\n\nUse /${EXPORT_COMMAND} <name> to export one to ${localSkillsLabel()}.`, "warning");
+		return;
+	}
+
+	const t = exportTransfer(ctx);
+	const labels = skills.map(skillLabel);
+	const labelToName = new Map(labels.map((label, index) => [label, skills[index]!.name]));
+	let selected: string | undefined;
+	try {
+		selected = await ctx.ui.select(`Export skill from ${projectSkillsLabel(ctx)}/ to ${localSkillsLabel()}`, labels);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+		return;
+	}
+	if (!selected) return;
+
+	const name = labelToName.get(selected);
+	if (!name) return;
+	await transferSkill(ctx, name, t);
+}
+
+async function exportByName(ctx: ExtensionCommandContext, name: string): Promise<void> {
+	const skills = await listProjectSkills(ctx);
+	const match = skills.find((entry) => entry.name === name);
+	if (!match) {
+		const available = skills.length > 0 ? skills.map((s) => s.name).join(", ") : "(none)";
+		notify(ctx, `No skill named "${name}" in ${projectSkillsLabel(ctx)}/. Installed: ${available}`, "error");
+		return;
+	}
+	await transferSkill(ctx, match.name, exportTransfer(ctx));
+}
+
+export default function skillInstaller(pi: ExtensionAPI): void {
+	pi.registerCommand(INSTALL_COMMAND, {
+		description: `Install a skill from ${localSkillsLabel()} into the current project's ${PROJECT_DIR}/${PROJECT_SKILLS_SUBDIR}`,
+		handler: async (args: string, ctx) => {
+			const name = args.trim();
+			try {
+				if (name) await installByName(ctx, name);
+				else await showInstallMenu(ctx);
+			} catch (error) {
+				ignoreStaleExtensionContextError(error);
+			}
+		},
+	});
+
+	pi.registerCommand(EXPORT_COMMAND, {
+		description: `Export a skill from the current project's ${PROJECT_DIR}/${PROJECT_SKILLS_SUBDIR} to ${localSkillsLabel()} for reuse in other projects`,
+		handler: async (args: string, ctx) => {
+			const name = args.trim();
+			try {
+				if (name) await exportByName(ctx, name);
+				else await showExportMenu(ctx);
+			} catch (error) {
+				ignoreStaleExtensionContextError(error);
+			}
+		},
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": false,
   "type": "module",
   "bin": {

package/skills/spec-lite/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: spec-lite
+description: Use this skill for creating, updating, or checking lightweight specs for existing code, risky changes, public behavior, bug fixes, or spec-code drift. Use it before or during non-trivial changes that touch security, data, persistence, public APIs, CLI/UI contracts, integrations, concurrency, architecture, or user-visible behavior with edge cases. Do not use it for trivial local edits.
+argument-hint: "behavior, change, bug, or spec path to document/check"
+---
+
+# Spec Lite
+
+Use the lightest spec process that preserves correctness. The goal is to make behavior and risk explicit without turning every change into a heavyweight design process.
+
+## Core rules
+
+- Do not change production code unless the user explicitly asks for implementation.
+- Specs describe either current behavior or intended behavior; label which one clearly.
+- Do not invent behavior. If evidence is missing or ambiguous, mark uncertainty explicitly.
+- Prefer compact specs over exhaustive documents.
+- Load only relevant files, tests, schemas, docs, migrations, entrypoints, and existing specs.
+- Do not load all specs by default.
+- Keep the spec close to the codebase convention when a specs directory, ADR folder, or feature-doc pattern already exists.
+
+## When to create or update a spec
+
+Create or update a lightweight spec when the work affects any of these areas:
+
+- security, privacy, auth, or permissions;
+- data, schemas, migrations, persistence, or file formats;
+- public APIs, CLI behavior, UI contracts, events, or other external contracts;
+- external integrations;
+- payments, destructive operations, or irreversible workflows;
+- background jobs, concurrency, cancellation, retries, or async behavior;
+- cross-cutting architecture;
+- user-visible behavior with non-trivial edge cases;
+- bug fixes where expected behavior, compatibility, or regression risk is unclear;
+- suspected drift between existing specs/docs/tests and code.
+
+Do not require a spec for trivial local edits, mechanical renames, formatting-only changes, or obvious one-file fixes with no broader behavior impact.
+
+## As-is spec workflow
+
+Use this workflow for existing code or spec-code drift checks:
+
+1. Identify the narrow behavior or contract to document.
+2. Inspect relevant code, tests, docs, schemas, migrations, and entrypoints.
+3. Identify current behavior and known gaps.
+4. Mark claims using evidence labels:
+   - confirmed by code;
+   - confirmed by tests;
+   - confirmed by docs;
+   - inferred;
+   - unknown.
+5. Create or update a compact as-is spec.
+6. If drift is found, report it separately from confirmed behavior.
+
+## Change spec workflow
+
+Use this workflow before risky implementation:
+
+1. Define the goal.
+2. Define scope and non-goals.
+3. State expected behavior.
+4. List affected contracts.
+5. List risks, compatibility concerns, and migration concerns if any.
+6. Define a verification path.
+7. Then implement only the scoped change, if implementation was requested.
+
+## Spec template
+
+Use this template by default. Remove sections that are genuinely irrelevant, but keep `Type`, `Goal`, `Behavior`, `Related files`, `Verification`, and `Evidence` when possible.
+
+```markdown
+# Spec: <name>
+
+## Type
+
+As-is | Change
+
+## Goal
+
+...
+
+## Scope
+
+...
+
+## Non-goals
+
+...
+
+## Behavior
+
+...
+
+## Contracts
+
+Inputs, outputs, APIs, CLI, UI, events, files, schemas.
+
+## Invariants
+
+...
+
+## Edge cases
+
+...
+
+## Side effects
+
+...
+
+## Related files
+
+...
+
+## Verification
+
+...
+
+## Risks / unknowns
+
+...
+
+## Evidence
+
+- Confirmed by code:
+- Confirmed by tests:
+- Confirmed by docs:
+- Inferred:
+- Unknown:
+```
+
+## Output guidance
+
+When the user asks only for a spec, write or update the spec and summarize:
+
+- spec path;
+- whether it is as-is or change-oriented;
+- strongest evidence sources;
+- important unknowns or drift;
+- whether production code was left untouched.
+
+When the user asks for implementation too, keep the spec scoped and practical, then implement only after the expected behavior and verification path are clear.