pi-monofold 0.6.2 → 0.7.0

package/focus-preset.ts

@@ -1,3 +1,4 @@
+import { parseFocusSkills, resetFocusSkillsWarningState } from "./focus-skills.js";
 import { assertKnownKeys, asStringArray, isRecord, uniqueStrings } from "./validation.js";
 
 export type FocusPresetTarget = {
@@ -8,13 +9,14 @@ export type FocusPreset = {
   id: string;
   label: string;
   targets: FocusPresetTarget[];
+  focusSkills?: string[];
 };
 
 export type FocusMatchableWorkspace = {
   tags: string[];
 };
 
-const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets"]);
+const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets", "focusSkills"]);
 const FOCUS_PRESET_TARGET_KEYS = new Set(["targetTags"]);
 
 /** Parses and validates focus preset configuration from YAML/JSON input. */
@@ -49,9 +51,15 @@ export function parseFocusPresets(value: unknown, label = "focusPresets"): Focus
       }
       targets.push({ targetTags });
     }
+    const focusSkills = parseFocusSkills(itemLabel, item.focusSkills);
     if (seenIds.has(item.id)) throw new Error(`${label} has duplicate preset id: ${item.id}`);
     seenIds.add(item.id);
-    presets.push({ id: item.id, label: item.label, targets });
+    presets.push({
+      id: item.id,
+      label: item.label,
+      targets,
+      ...(focusSkills !== undefined ? { focusSkills } : {}),
+    });
   }
   return presets;
 }
@@ -118,6 +126,7 @@ export function setActiveFocusPresetId(id: string, focusPresets: FocusPreset[] |
   }
   activeFocusPresetId = id;
   activeFocusInitialized = true;
+  resetFocusSkillsWarningState();
 }
 
 export type ActiveFocusPresetPosition = {
@@ -177,12 +186,14 @@ export function cycleActiveFocusPresetForward(focusPresets: FocusPreset[] | unde
 export function clearActiveFocusPresetId(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = true;
+  resetFocusSkillsWarningState();
 }
 
 /** Resets in-memory session state (for tests and process restart). */
 export function resetActiveFocusSessionState(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = false;
+  resetFocusSkillsWarningState();
 }
 
 export type TagBasedTargetInput = {

package/focus-skills.ts

@@ -0,0 +1,106 @@
+import { formatSkillsForPrompt, type Skill } from "@earendil-works/pi-coding-agent";
+
+/** Max skills a single focus preset may auto-load (matches focus context file cap). */
+export const FOCUS_SKILLS_MAX_COUNT = 6;
+
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SKILLS_SECTION_PATTERN = /\n\nThe following skills provide[\s\S]*?<\/available_skills>/;
+
+/** Validates a focusSkills entry per Agent Skills name rules. */
+export function assertValidFocusSkillName(label: string, name: string): void {
+  if (name.trim() === "") {
+    throw new Error(`${label} must not contain empty skill names`);
+  }
+  if (name.length > 64) {
+    throw new Error(`${label} skill name exceeds 64 characters: ${name}`);
+  }
+  if (!SKILL_NAME_PATTERN.test(name)) {
+    throw new Error(`${label} skill name must use lowercase letters, digits, and hyphens only: ${name}`);
+  }
+}
+
+/** Parses and validates an optional focusSkills list from preset config. */
+export function parseFocusSkills(itemLabel: string, value: unknown): string[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`${itemLabel}.focusSkills must be an array of strings`);
+  }
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (let index = 0; index < value.length; index += 1) {
+    const raw = value[index]!;
+    const nameLabel = `${itemLabel}.focusSkills[${index}]`;
+    assertValidFocusSkillName(nameLabel, raw);
+    if (seen.has(raw)) {
+      throw new Error(`${itemLabel}.focusSkills has duplicate skill name: ${raw}`);
+    }
+    seen.add(raw);
+    names.push(raw);
+  }
+  if (names.length > FOCUS_SKILLS_MAX_COUNT) {
+    throw new Error(`${itemLabel}.focusSkills must contain at most ${FOCUS_SKILLS_MAX_COUNT} skill names`);
+  }
+  return names;
+}
+
+/** Removes Pi's default available-skills block from a system prompt, if present. */
+export function stripSkillsSectionFromSystemPrompt(systemPrompt: string): string {
+  return systemPrompt.replace(SKILLS_SECTION_PATTERN, "");
+}
+
+/** Resolves declared focus skill names against Pi's discovered skill inventory. */
+export function resolveFocusSkills(allSkills: Skill[] | undefined, focusSkillNames: string[] | undefined): Skill[] {
+  if (!focusSkillNames) return [];
+  const byName = new Map((allSkills ?? []).map((skill) => [skill.name, skill]));
+  return focusSkillNames.flatMap((name) => {
+    const skill = byName.get(name);
+    return skill ? [skill] : [];
+  });
+}
+
+/** Returns focusSkills names that are not present in the discovered inventory. */
+export function findMissingFocusSkills(focusSkillNames: string[] | undefined, allSkills: Skill[] | undefined): string[] {
+  if (!focusSkillNames?.length) return [];
+  const available = new Set((allSkills ?? []).map((skill) => skill.name));
+  return focusSkillNames.filter((name) => !available.has(name));
+}
+
+/** Replaces the default skills section with only focus-declared skills when configured. */
+export function applyFocusSkillsToSystemPrompt(
+  systemPrompt: string,
+  allSkills: Skill[] | undefined,
+  focusSkillNames: string[] | undefined,
+): string {
+  if (focusSkillNames === undefined) return systemPrompt;
+  const stripped = stripSkillsSectionFromSystemPrompt(systemPrompt);
+  const resolved = resolveFocusSkills(allSkills, focusSkillNames);
+  if (resolved.length === 0) return stripped;
+  return stripped + formatSkillsForPrompt(resolved);
+}
+
+let warnedFocusSkillsKey: string | null = null;
+
+/** Clears per-activation focus skill warning deduplication (for tests and focus changes). */
+export function resetFocusSkillsWarningState(): void {
+  warnedFocusSkillsKey = null;
+}
+
+/** Emits one actionable warning per focus activation for missing focusSkills names. */
+export function warnMissingFocusSkills(
+  presetId: string,
+  focusSkillNames: string[] | undefined,
+  allSkills: Skill[] | undefined,
+  warn: (message: string) => void,
+): void {
+  if (!focusSkillNames?.length) return;
+  const missing = findMissingFocusSkills(focusSkillNames, allSkills);
+  if (missing.length === 0) return;
+  const key = `${presetId}:${missing.join(",")}`;
+  if (warnedFocusSkillsKey === key) return;
+  warnedFocusSkillsKey = key;
+  for (const name of missing) {
+    warn(
+      `Focus preset "${presetId}" focusSkills: skill "${name}" was not found in Pi's discovered inventory. Check the skill name or install the package, then reload Pi.`,
+    );
+  }
+}

package/index.ts

@@ -20,6 +20,10 @@ import {
   setActiveFocusPresetId,
   warnZeroTargetMatchesForPreset,
 } from "./focus-preset.js";
+import {
+  applyFocusSkillsToSystemPrompt,
+  warnMissingFocusSkills,
+} from "./focus-skills.js";
 import {
   buildMonofoldTree,
   readMonofoldFile,
@@ -1235,9 +1239,22 @@ export default function piMultiWorkspace(pi: ExtensionAPI) {
           "warning",
         );
       }
+      if (activePreset && ctx.hasUI) {
+        warnMissingFocusSkills(
+          activePreset.id,
+          activePreset.focusSkills,
+          _event.systemPromptOptions?.skills,
+          (message) => ctx.ui.notify(message, "warning"),
+        );
+      }
+      const baseSystemPrompt = applyFocusSkillsToSystemPrompt(
+        _event.systemPrompt,
+        _event.systemPromptOptions?.skills,
+        activePreset?.focusSkills,
+      );
       return {
         systemPrompt:
-          _event.systemPrompt +
+          baseSystemPrompt +
           `
 
 ## Pi Monofold

package/package.json

@@ -11,7 +11,7 @@
   },
   "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
   "type": "module",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "pi": {
     "extensions": [
       "./index.ts"
@@ -25,6 +25,7 @@
     "unknown-path-allows.ts",
     "file-read-preview.ts",
     "focus-preset.ts",
+    "focus-skills.ts",
     "monofold-read-ops.ts",
     "read-caps.ts",
     "validation.ts"