@groeponline/pi-wishcraft 1.4.11 → 1.4.13

package/src/studio/list.ts

@@ -13,6 +13,11 @@ export interface ListRow {
   category: SkillCategory;
   filePath: string;
   warning?: string;
+  routingCategory?: string;
+  routingFamily?: string;
+  role?: string | null;
+  routerParent?: string | null;
+  registryDrift?: boolean;
 }
 
 export function badgeForCategory(category: SkillCategory): string {
@@ -36,6 +41,11 @@ export function buildListRows(entries: readonly SkillEntry[]): ListRow[] {
     category: entry.category,
     filePath: entry.filePath,
     warning: entry.warning,
+    routingCategory: entry.routingCategory,
+    routingFamily: entry.routingFamily,
+    role: entry.role,
+    routerParent: entry.routerParent,
+    registryDrift: entry.registryDrift,
   }));
 }
 
@@ -43,6 +53,6 @@ export function filterListRows(rows: readonly ListRow[], query: string): ListRow
   const q = query.trim().toLowerCase();
   if (q.length === 0) return [...rows];
   return rows.filter(
-    (row) => row.name.toLowerCase().includes(q) || row.description.toLowerCase().includes(q),
+    (row) => row.name.toLowerCase().includes(q) || row.description.toLowerCase().includes(q) || row.routingCategory?.toLowerCase().includes(q) || row.routingFamily?.toLowerCase().includes(q),
   );
 }

package/src/studio/open.ts

@@ -4,19 +4,179 @@
  * context arrives via parameters only.
  */
 
+import { readFileSync, writeFileSync } from "node:fs";
+import { getAgentPath } from "../paths/agent-dirs.ts";
 import type { RuntimeState } from "../extension/core/types.ts";
+import {
+  getSkillUsage,
+  invalidateSkillCache,
+  loadSkillStudioCatalog,
+  readSkillBody,
+  type SkillEntry,
+} from "../extension/skills/skill-registry.ts";
+import { runStudioAction } from "./actions.ts";
+import { createAdvicePane, advicePaneInsert } from "./advice-pane.ts";
 import { createStudioComponent } from "./component.ts";
+import { extractRepos, type RepoRef } from "./deepwiki/extract.ts";
+import { callTool } from "./deepwiki/client.ts";
+import { withCache } from "./deepwiki/cache.ts";
+import type { AdviseStreamProvider } from "./advise/engine.ts";
 
-/**
- * Keep the operator command fail-closed until list/detail/actions/advice are
- * actually wired into the fullscreen component. The scaffold stays available
- * to tests and follow-up implementation without exposing a misleading command.
- */
-export const SKILL_STUDIO_PANES_READY = false;
+/** The fullscreen component is now connected to discovery, actions, and advice. */
+export const SKILL_STUDIO_PANES_READY = true;
+
+const DEEPWIKI_TTL_MS = 24 * 60 * 60 * 1000;
+const DEEPWIKI_MAX_ENTRIES = 64;
+const DEEPWIKI_ENDPOINT = "https://mcp.deepwiki.com/mcp";
+
+type StudioContext = {
+  hasUI: boolean;
+  mode: string;
+  cwd?: string;
+  ui: {
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+    custom<T>(factory: (...args: any[]) => any, options?: { overlay?: boolean }): Promise<T>;
+    input?(title: string, placeholder?: string): Promise<string | undefined>;
+    select?(title: string, options: string[]): Promise<string | undefined>;
+    confirm?(title: string, message: string): Promise<boolean>;
+    editor?(title: string, prefill?: string): Promise<string | undefined>;
+    getEditorText?(): string;
+    setEditorText?(text: string): void;
+  };
+  model?: {
+    id: string;
+    contextWindow: number;
+    maxTokens: number;
+    provider: string;
+    baseUrl?: string;
+  };
+  modelRegistry?: {
+    getProvider(provider: string): {
+      stream(model: unknown, context: unknown, options: Record<string, unknown>): AsyncIterable<unknown>;
+    } | undefined;
+    getApiKeyAndHeaders(model: unknown): Promise<{
+      ok: boolean;
+      apiKey?: string;
+      headers?: Record<string, string | null>;
+      env?: Record<string, string>;
+      baseUrl?: string;
+    }>;
+  };
+};
+
+interface WikiPayload {
+  content: string;
+}
+
+function referencesFor(entry: SkillEntry): { name: string; content: string }[] {
+  const body = readSkillBody(entry.filePath);
+  const refs = body.matchAll(/\[[^\]]+\]\((references|scripts)\/[^)\s]+\)/g);
+  const sections: { name: string; content: string }[] = [];
+  for (const match of refs) {
+    const hrefMatch = /\(([^)\s]+)\)/.exec(match[0] ?? "");
+    const href = hrefMatch?.[1];
+    if (!href) continue;
+    try {
+      sections.push({ name: href, content: readFileSync(`${entry.baseDir}/${href}`, "utf8") });
+    } catch {
+      sections.push({ name: href, content: "(missing local reference)" });
+    }
+  }
+  return sections;
+}
+
+async function fetchWiki(repo: RepoRef): Promise<WikiPayload> {
+  const structure = await callTool<{ content?: { type: string; text?: string }[] }>(
+    "read_wiki_structure",
+    { repo: `${repo.owner}/${repo.repo}` },
+    DEEPWIKI_ENDPOINT,
+  );
+  const structureText = structure.content?.map((part) => part.text ?? "").join("\n") ?? "";
+  const contents = await callTool<{ content?: { type: string; text?: string }[] }>(
+    "read_wiki_contents",
+    { repo: `${repo.owner}/${repo.repo}` },
+    DEEPWIKI_ENDPOINT,
+  );
+  const contentText = contents.content?.map((part) => part.text ?? "").join("\n") ?? "";
+  return { content: `${structureText}\n\n${contentText}`.trim() };
+}
+
+async function localWikiContext(entry: SkillEntry, notify: (message: string, type?: "info" | "warning" | "error") => void) {
+  const sections: { name: string; content: string }[] = [];
+  for (const repo of extractRepos(readSkillBody(entry.filePath))) {
+    const cached = await withCache(
+      getAgentPath("wishcraft-cache", "deepwiki"),
+      repo,
+      { ttlMs: DEEPWIKI_TTL_MS, maxEntries: DEEPWIKI_MAX_ENTRIES },
+      () => fetchWiki(repo),
+    );
+    if (cached.entry?.data.content) {
+      sections.push({ name: `${repo.owner}/${repo.repo}`, content: cached.entry.data.content });
+    }
+    if (cached.stale || !cached.entry) {
+      notify(`DeepWiki unavailable for ${repo.owner}/${repo}; using local skill context`, "warning");
+    }
+  }
+  return sections;
+}
+
+async function runAdviceFor(
+  ctx: StudioContext,
+  entry: SkillEntry,
+  mode: "explain" | "integrate" | "examples" | "improve",
+  pane: ReturnType<typeof createAdvicePane>,
+): Promise<void> {
+  const model = ctx.model;
+  const registry = ctx.modelRegistry;
+  const provider = model && registry ? registry.getProvider(model.provider) : undefined;
+  if (!model || !registry || !provider) {
+    await pane.run({ mode, skillName: entry.name, body: readSkillBody(entry.filePath), references: referencesFor(entry), wiki: [], provider: null, signal: new AbortController().signal });
+    return;
+  }
+  const auth = await registry.getApiKeyAndHeaders(model);
+  if (!auth.ok) {
+    await pane.run({ mode, skillName: entry.name, body: readSkillBody(entry.filePath), references: referencesFor(entry), wiki: [], provider: null, signal: new AbortController().signal });
+    return;
+  }
+  const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+  const streamProvider: AdviseStreamProvider = {
+    stream: (_advisorModel, context, options) => provider.stream(requestModel, {
+      systemPrompt: context.prompt?.system,
+      messages: [{ role: "user", content: [{ type: "text", text: context.prompt?.user ?? "" }], timestamp: Date.now() }],
+    }, {
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+      env: auth.env,
+      signal: options.signal,
+      maxTokens: options.maxTokens,
+    }),
+  };
+  const references = referencesFor(entry);
+  const wiki = await localWikiContext(entry, (message, type) => ctx.ui.notify(message, type));
+  await pane.run({
+    mode,
+    skillName: entry.name,
+    body: readSkillBody(entry.filePath),
+    references,
+    wiki,
+    provider: streamProvider,
+    model: { id: model.id, contextWindow: model.contextWindow, maxTokens: model.maxTokens },
+    signal: new AbortController().signal,
+  });
+}
+
+async function editSkill(ctx: StudioContext, entry: SkillEntry): Promise<void> {
+  if (!ctx.ui.editor) return;
+  const next = await ctx.ui.editor(`Edit skill: ${entry.name}`, readFileSync(entry.filePath, "utf8"));
+  if (next === undefined) return;
+  writeFileSync(entry.filePath, next, "utf8");
+  invalidateSkillCache();
+  ctx.ui.notify(`Updated ${entry.name}`, "info");
+}
 
 export async function openSkillStudio(
   rt: RuntimeState,
-  ctx: any,
+  ctx: StudioContext,
 ): Promise<void> {
   if (!rt.enabled) {
     if (ctx.hasUI) ctx.ui.notify("Skill Studio requires the Signal UI to be enabled", "info");
@@ -30,15 +190,47 @@ export async function openSkillStudio(
     ctx.ui.notify("Skill Studio is not available in RPC mode", "warning");
     return;
   }
-  if (!SKILL_STUDIO_PANES_READY) {
-    ctx.ui.notify("Skill Studio is not available until its panes are connected", "warning");
-    return;
-  }
-
   rt.currentCtx = ctx;
-
+  invalidateSkillCache();
+  const cwd = ctx.cwd ?? process.cwd();
+  const pane = createAdvicePane();
+  let entries = loadSkillStudioCatalog(cwd);
   await ctx.ui.custom(
-    (_tui: any, theme: any, _keybindings: any, done: (value: string | null) => void) =>
-      createStudioComponent(theme, done),
+    (_tui: unknown, theme: any, _keybindings: unknown, done: (value: string | null) => void) =>
+      createStudioComponent(theme, done, undefined, {
+        entries,
+        usage: getSkillUsage(),
+        advicePane: pane,
+        onRefresh: () => {
+          entries = loadSkillStudioCatalog(cwd);
+          return entries;
+        },
+        onCreate: async () => {
+          const name = await ctx.ui.input?.("New skill", "skill-name");
+          if (!name) return;
+          const template = await ctx.ui.select?.("Template", ["standard", "browser-workflow", "cli-workflow", "review-checklist"]);
+          const result = await runStudioAction({ type: "create", name, template: (template ?? "standard") as "standard" | "browser-workflow" | "cli-workflow" | "review-checklist", skillsRoot: getAgentPath("skills") }, {
+            confirm: (message) => ctx.ui.confirm?.("Confirm", message) ?? Promise.resolve(false),
+          });
+          ctx.ui.notify(result.message, result.kind === "error" ? "error" : "info");
+        },
+        onEdit: (entry) => editSkill(ctx, entry),
+        onDoctor: async () => {
+          const result = await runStudioAction({ type: "doctor", cwd }, { confirm: async () => false });
+          ctx.ui.notify(result.message, result.kind === "error" ? "error" : "info");
+        },
+        onAdvice: (entry, mode, targetPane) => runAdviceFor(ctx, entry, mode, targetPane),
+        onInsert: (targetPane) => {
+          if (!ctx.ui.getEditorText || !ctx.ui.setEditorText) return;
+          advicePaneInsert(targetPane, {
+            appendUserMessage(text) {
+              const current = ctx.ui.getEditorText!();
+              ctx.ui.setEditorText!(`${current}${current ? "\n\n" : ""}${text}\n`);
+            },
+          });
+          ctx.ui.notify("Advice inserted into the editor", "info");
+        },
+        onError: (error) => ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"),
+      }),
   );
 }

package/src/theme/colors.ts

@@ -15,13 +15,9 @@ export const ansi: AnsiColors = {
 // ponytail: NO_COLOR (de-facto standard — present and non-empty) disables all
 // wishcraft color so the status bar stays plain text in no-color terminals
 // and color-blind pipelines. Computed lazily so test env changes take effect.
-let _colorEnabled: boolean | undefined;
 export function colorEnabled(): boolean {
-  if (_colorEnabled === undefined) {
-    const v = process.env.NO_COLOR;
-    _colorEnabled = !(v != null && v !== "");
-  }
-  return _colorEnabled;
+  const v = process.env.NO_COLOR;
+  return !(v != null && v !== "");
 }
 
 function hexToRgb(hex: string): [number, number, number] {

package/src/tools/patch.ts

@@ -1,179 +0,0 @@
-import { readFileSync, writeFileSync, copyFileSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentPath } from "../paths/agent-dirs.ts";
-
-export interface PatchHunk {
-  oldStart: number;
-  oldLines: number;
-  newStart: number;
-  newLines: number;
-  lines: string[];
-}
-
-export interface FilePatch {
-  targetFile: string;
-  hunks: PatchHunk[];
-}
-
-export interface PatchResult {
-  success: boolean;
-  targetFile: string;
-  appliedHunks: number;
-  totalHunks: number;
-  backupPath?: string;
-  error?: string;
-}
-
-const undoStack: { targetFile: string; backupPath: string; timestamp: number }[] = [];
-const MAX_UNDO_STACK = 10;
-
-/**
- * Parse a unified diff string into structured FilePatch objects.
- */
-export function parseUnifiedDiff(diffText: string): FilePatch[] {
-  const patches: FilePatch[] = [];
-  const lines = diffText.split(/\r?\n/);
-  let currentPatch: FilePatch | null = null;
-  let currentHunk: PatchHunk | null = null;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    if (line.startsWith("--- ")) {
-      continue;
-    }
-
-    if (line.startsWith("+++ ")) {
-      const rawPath = line.slice(4).trim();
-      const targetFile = rawPath.replace(/^[ab]\//, "");
-      currentPatch = { targetFile, hunks: [] };
-      patches.push(currentPatch);
-      continue;
-    }
-
-    const hunkHeaderMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    if (hunkHeaderMatch && currentPatch) {
-      currentHunk = {
-        oldStart: parseInt(hunkHeaderMatch[1], 10),
-        oldLines: parseInt(hunkHeaderMatch[2] ?? "1", 10),
-        newStart: parseInt(hunkHeaderMatch[3], 10),
-        newLines: parseInt(hunkHeaderMatch[4] ?? "1", 10),
-        lines: [],
-      };
-      currentPatch.hunks.push(currentHunk);
-      continue;
-    }
-
-    if (currentHunk && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ") || line === "")) {
-      currentHunk.lines.push(line);
-    }
-  }
-
-  return patches;
-}
-
-/**
- * Apply a FilePatch to a file safely with an atomic backup.
- */
-export function applyFilePatch(patch: FilePatch, baseDir: string = process.cwd()): PatchResult {
-  const fullPath = join(baseDir, patch.targetFile);
-  
-  if (!existsSync(fullPath)) {
-    return {
-      success: false,
-      targetFile: patch.targetFile,
-      appliedHunks: 0,
-      totalHunks: patch.hunks.length,
-      error: `Target file not found: ${fullPath}`,
-    };
-  }
-
-  // 1. Create backup
-  const backupDir = getAgentPath("patch-backups");
-  if (!existsSync(backupDir)) {
-    mkdirSync(backupDir, { recursive: true });
-  }
-  const backupPath = join(backupDir, `${Date.now()}-${patch.targetFile.replace(/\//g, "_")}.bak`);
-  copyFileSync(fullPath, backupPath);
-
-  try {
-    const originalContent = readFileSync(fullPath, "utf-8");
-    let fileLines = originalContent.split(/\r?\n/);
-    let appliedHunks = 0;
-
-    for (const hunk of patch.hunks) {
-      const targetLineIdx = hunk.oldStart - 1;
-      const expectedOldLines = hunk.lines.filter((l) => !l.startsWith("+"));
-      
-      // Match context check
-      let matches = true;
-      for (let j = 0; j < expectedOldLines.length; j++) {
-        const expected = expectedOldLines[j].slice(1);
-        const actual = fileLines[targetLineIdx + j];
-        if (actual !== undefined && actual !== expected) {
-          matches = false;
-          break;
-        }
-      }
-
-      if (matches) {
-        const newHunkLines: string[] = [];
-        for (const line of hunk.lines) {
-          if (!line.startsWith("-")) {
-            newHunkLines.push(line.startsWith("+") ? line.slice(1) : line.slice(1));
-          }
-        }
-        
-        fileLines.splice(targetLineIdx, hunk.oldLines, ...newHunkLines);
-        appliedHunks++;
-      }
-    }
-
-    writeFileSync(fullPath, fileLines.join("\n"), "utf-8");
-
-    // Track undo stack
-    undoStack.push({ targetFile: fullPath, backupPath, timestamp: Date.now() });
-    if (undoStack.length > MAX_UNDO_STACK) {
-      const oldest = undoStack.shift();
-      if (oldest && existsSync(oldest.backupPath)) {
-        try { unlinkSync(oldest.backupPath); } catch {}
-      }
-    }
-
-    return {
-      success: appliedHunks > 0,
-      targetFile: patch.targetFile,
-      appliedHunks,
-      totalHunks: patch.hunks.length,
-      backupPath,
-    };
-  } catch (err) {
-    // Revert from backup
-    copyFileSync(backupPath, fullPath);
-    return {
-      success: false,
-      targetFile: patch.targetFile,
-      appliedHunks: 0,
-      totalHunks: patch.hunks.length,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-/**
- * Revert the last applied patch.
- */
-export function undoLastPatch(): { success: boolean; targetFile?: string; error?: string } {
-  const last = undoStack.pop();
-  if (!last || !existsSync(last.backupPath)) {
-    return { success: false, error: "No undo backup available" };
-  }
-
-  try {
-    copyFileSync(last.backupPath, last.targetFile);
-    unlinkSync(last.backupPath);
-    return { success: true, targetFile: last.targetFile };
-  } catch (err) {
-    return { success: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}

package/src/tools/ripgrep.ts

@@ -1,104 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-export interface RipgrepMatch {
-  file: string;
-  lineNumber: number;
-  content: string;
-}
-
-export interface RipgrepOptions {
-  cwd?: string;
-  typeFilter?: string;
-  maxResults?: number;
-}
-
-export interface RipgrepResult {
-  matches: RipgrepMatch[];
-  totalCount: number;
-  engine: "ripgrep" | "grep-fallback";
-  error?: string;
-}
-
-/**
- * Execute a ripgrep (or fallback grep) search programmatically for subagent use.
- */
-export function searchRipgrep(pattern: string, options: RipgrepOptions = {}): RipgrepResult {
-  const cwd = options.cwd ?? process.cwd();
-  const maxResults = options.maxResults ?? 50;
-
-  // Try rg first
-  try {
-    const rgArgs = ["--json", "-m", String(maxResults), "-i"];
-    if (options.typeFilter) {
-      rgArgs.push("-t", options.typeFilter);
-    }
-    rgArgs.push(pattern, ".");
-
-    const proc = spawnSync("rg", rgArgs, { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 });
-
-    if (proc.status === 0 || proc.status === 1) {
-      const matches: RipgrepMatch[] = [];
-      const lines = (proc.stdout ?? "").split("\n");
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed.type === "match") {
-            const data = parsed.data;
-            matches.push({
-              file: data.path.text,
-              lineNumber: data.line_number,
-              content: data.lines.text.trimEnd(),
-            });
-          }
-        } catch {
-          // ignore non-json lines
-        }
-      }
-
-      return {
-        matches: matches.slice(0, maxResults),
-        totalCount: matches.length,
-        engine: "ripgrep",
-      };
-    }
-  } catch {
-    // Fallback to standard grep
-  }
-
-  // Fallback: standard grep
-  try {
-    const grepArgs = ["-rn", "-m", String(maxResults), "--exclude-dir=node_modules", "--exclude-dir=.git", pattern, "."];
-    const proc = spawnSync("grep", grepArgs, { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 });
-
-    const matches: RipgrepMatch[] = [];
-    const lines = (proc.stdout ?? "").split("\n");
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      const parts = line.split(":");
-      if (parts.length >= 3) {
-        const file = parts[0];
-        const lineNumber = parseInt(parts[1], 10);
-        const content = parts.slice(2).join(":").trimEnd();
-        if (!isNaN(lineNumber)) {
-          matches.push({ file, lineNumber, content });
-        }
-      }
-    }
-
-    return {
-      matches: matches.slice(0, maxResults),
-      totalCount: matches.length,
-      engine: "grep-fallback",
-    };
-  } catch (err) {
-    return {
-      matches: [],
-      totalCount: 0,
-      engine: "grep-fallback",
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}