@docyrus/docyrus 0.0.63 → 0.0.65

package/resources/pi-agent/extensions/pi-mcp-adapter/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, ToolInfo } from "@mariozechner/pi-coding-agent";
 import type { McpExtensionState } from "./state.js";
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
 import { showStatus, showTools, reconnectServers, authenticateServer, openMcpPanel } from "./commands.js";
 import { loadMcpConfig } from "./config.js";
 import { buildProxyDescription, createDirectToolExecutor, resolveDirectTools } from "./direct-tools.js";

package/resources/pi-agent/extensions/pi-mcp-adapter/package.json

@@ -65,7 +65,7 @@
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@sinclair/typebox": "^0.32.0",
+    "typebox": "^1.1.24",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "devDependencies": {

package/resources/pi-agent/extensions/prompt-editor.ts

@@ -1,5 +1,9 @@
-import type { ExtensionAPI, ExtensionContext, ModelSelectEvent, ThinkingLevel } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { CustomEditor, ModelSelectorComponent, SettingsManager } from "@mariozechner/pi-coding-agent";
+
+// Mirrors @mariozechner/pi-agent-core's ThinkingLevel (including "off"), defined locally so this
+// extension can be loaded by pi without pulling an additional direct dep. Keep in sync with pi-agent-core.
+type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 import path from "node:path";
 import os from "node:os";
 import fs from "node:fs/promises";
@@ -1148,13 +1152,28 @@ function setEditor(pi: ExtensionAPI, ctx: ExtensionContext, history: PromptEntry
     requestEditorRender = () => editor.requestRenderNow();
     editor.modeLabelProvider = () => runtime.currentMode;
 		// Keep the mode label color stable (match footer/status bar).
-    editor.modeLabelColor = (text: string) => ctx.ui.theme.fg("dim", text);
+		// ctx can go stale after session replacement or reload; swallow the stale
+		// assertion in the render-path callbacks so the last TUI frame doesn't crash.
+    editor.modeLabelColor = (text: string) => {
+      try {
+        return ctx.ui.theme.fg("dim", text);
+      } catch {
+        return text;
+      }
+    };
     const borderColor = (text: string) => {
-      const isBashMode = editor.getText().trimStart().startsWith("!");
-      if (isBashMode) {
-        return ctx.ui.theme.getBashModeBorderColor()(text);
+      // ctx can go stale after session replacement or reload; a final TUI render
+      // can still fire from timers and calls into ctx.ui.* throw. Fall back to
+      // the raw text instead of crashing the editor on the way out.
+      try {
+        const isBashMode = editor.getText().trimStart().startsWith("!");
+        if (isBashMode) {
+          return ctx.ui.theme.getBashModeBorderColor()(text);
+        }
+        return getModeBorderColor(ctx, pi, runtime.currentMode)(text);
+      } catch {
+        return text;
       }
-      return getModeBorderColor(ctx, pi, runtime.currentMode)(text);
     };
 
     editor.borderColor = borderColor;
@@ -1267,7 +1286,7 @@ export default function(pi: ExtensionAPI) {
     applyEditor(pi, ctx);
   });
 
-  pi.on("model_select", async(event: ModelSelectEvent, ctx) => {
+  pi.on("model_select", async(event, ctx) => {
 		// Always track the last observed model for overlay/store correctness.
     lastObservedModel = { provider: event.model.provider, modelId: event.model.id };
 

package/resources/pi-agent/extensions/soul.ts

@@ -0,0 +1,183 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+import { DEFAULT_SOUL_ID, SOULS, findSoul } from "../souls/catalog";
+
+type Scope = "local" | "global";
+
+interface IStoredConfig {
+  version?: number;
+  activeEnvironmentId?: string;
+  environments?: unknown;
+  defaultClientId?: string;
+  activeSoulId?: string;
+  [extraKey: string]: unknown;
+}
+
+function resolveScope(): Scope {
+  const raw = process.env.DOCYRUS_CLI_SCOPE?.trim();
+  if (raw === "global") {
+    return "global";
+  }
+
+  return "local";
+}
+
+function resolveConfigFilePath(cwd: string): string {
+  const scope = resolveScope();
+  const root = scope === "global" ? join(homedir(), ".docyrus") : join(cwd, ".docyrus");
+  return join(root, "config.json");
+}
+
+async function readStoredConfig(cwd: string): Promise<IStoredConfig> {
+  const configPath = resolveConfigFilePath(cwd);
+  try {
+    const raw = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw) as IStoredConfig;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  }
+  catch (error) {
+    const code = (error as NodeJS.ErrnoException | null)?.code;
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+
+  return {};
+}
+
+async function writeStoredConfig(cwd: string, config: IStoredConfig): Promise<void> {
+  const configPath = resolveConfigFilePath(cwd);
+  await mkdir(dirname(configPath), {
+    recursive: true,
+    mode: 0o700,
+  });
+
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+
+  await chmod(configPath, 0o600);
+}
+
+async function getPersistedSoulId(cwd: string): Promise<string> {
+  const config = await readStoredConfig(cwd);
+  const stored = typeof config.activeSoulId === "string" ? config.activeSoulId.trim() : "";
+  if (stored && findSoul(stored)) {
+    return stored;
+  }
+
+  return DEFAULT_SOUL_ID;
+}
+
+async function persistSoulId(cwd: string, soulId: string): Promise<void> {
+  const config = await readStoredConfig(cwd);
+  await writeStoredConfig(cwd, {
+    ...config,
+    activeSoulId: soulId,
+  });
+}
+
+function parseSoulArg(rawArgs: string): string | null {
+  const trimmed = rawArgs.trim();
+  return trimmed.length > 0 ? trimmed.split(/\s+/u)[0] || null : null;
+}
+
+function renderSoulList(activeSoulId: string, runtimeSoulId: string): string {
+  const lines: string[] = [
+    "# Available Souls",
+    "",
+    "Use `/soul <id>` to pick one. Changes take effect on the **next** agent session (restart the agent).",
+    "",
+  ];
+
+  for (const soul of SOULS) {
+    const markers: string[] = [];
+    if (soul.id === runtimeSoulId) {
+      markers.push("running");
+    }
+    if (soul.id === activeSoulId && soul.id !== runtimeSoulId) {
+      markers.push("pending");
+    }
+    if (soul.id === activeSoulId && soul.id === runtimeSoulId) {
+      markers.length = 0;
+      markers.push("active");
+    }
+
+    const suffix = markers.length > 0 ? `  _(${markers.join(", ")})_` : "";
+    lines.push(`- \`${soul.id}\` — **${soul.name}**: ${soul.description}${suffix}`);
+  }
+
+  lines.push("");
+  lines.push(`Current: \`${runtimeSoulId}\` (running) · \`${activeSoulId}\` (persisted for next session)`);
+  return lines.join("\n");
+}
+
+function renderUsage(activeSoulId: string, runtimeSoulId: string): string {
+  return [
+    "# /soul",
+    "",
+    "Switch the agent's communication style (SOUL).",
+    "",
+    "- `/soul` — show this help and current selection.",
+    "- `/soul <id>` — persist a new soul; takes effect on the next session.",
+    "- `/souls` — list every available soul with descriptions.",
+    "",
+    `Currently running: \`${runtimeSoulId}\``,
+    `Persisted for next session: \`${activeSoulId}\``,
+  ].join("\n");
+}
+
+export default function(pi: ExtensionAPI) {
+  pi.registerCommand("souls", {
+    description: "List available agent souls (communication styles)",
+    handler: async(_rawArgs: string, ctx: ExtensionCommandContext) => {
+      const activeSoulId = await getPersistedSoulId(ctx.cwd);
+      const runtimeSoulId = process.env.DOCYRUS_PI_SOUL_ID?.trim() || DEFAULT_SOUL_ID;
+      if (ctx.hasUI) {
+        ctx.ui.notify(renderSoulList(activeSoulId, runtimeSoulId), "info");
+      }
+    },
+  });
+
+  pi.registerCommand("soul", {
+    description: "Show or change the agent's soul (communication style)",
+    handler: async(rawArgs: string, ctx: ExtensionCommandContext) => {
+      const requested = parseSoulArg(rawArgs);
+      const activeSoulId = await getPersistedSoulId(ctx.cwd);
+      const runtimeSoulId = process.env.DOCYRUS_PI_SOUL_ID?.trim() || DEFAULT_SOUL_ID;
+
+      if (!requested) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(renderUsage(activeSoulId, runtimeSoulId), "info");
+        }
+        return;
+      }
+
+      const candidate = findSoul(requested);
+      if (!candidate) {
+        const known = SOULS.map((soul) => soul.id).join(", ");
+        if (ctx.hasUI) {
+          ctx.ui.notify(`Unknown soul '${requested}'. Known souls: ${known}.`, "warning");
+        }
+        return;
+      }
+
+      await persistSoulId(ctx.cwd, candidate.id);
+
+      if (ctx.hasUI) {
+        const suffix = candidate.id === runtimeSoulId
+          ? " Already running — no restart needed."
+          : " Takes effect on the next agent session — restart with `/exit` and relaunch.";
+        ctx.ui.notify(`Soul set to \`${candidate.id}\` — ${candidate.name}.${suffix}`, "info");
+      }
+    },
+  });
+}

package/resources/pi-agent/extensions/todos.ts

@@ -31,7 +31,7 @@
  */
 import { DynamicBorder, copyToClipboard, getMarkdownTheme, keyHint, type ExtensionAPI, type ExtensionContext, type Theme } from "@mariozechner/pi-coding-agent";
 import { StringEnum } from "@mariozechner/pi-ai";
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { existsSync, readFileSync, readdirSync } from "node:fs";

package/resources/pi-agent/skills/grill-me/SKILL.md

@@ -1,14 +1,17 @@
 ---
 name: grill-me
 description: >
-  Interview the user relentlessly about a plan, architecture, or data model design until reaching shared understanding, resolving each branch of the decision tree. Use when the user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
-
-**Triggers — use this skill when:**
-- User says "grill me", "stress test this", "challenge my design"
-- User asks to "poke holes", "find gaps", "review my thinking"
-- User wants to validate a plan before implementing
-- User says "interview me about this", "question my decisions"
-- Used after `/architect` or `/plan` when the user wants to pressure-test the output
+  Stress-test a plan, architecture, or data model design by interviewing the user one question at a time, walking each branch of the decision tree until every critical choice is resolved. Tailored to Docyrus projects — probes data source design, field types, enum choices, relations and dependencies, access control, edge cases, and implementation feasibility against the current platform. Tracks resolved decisions, surfaces open questions, and offers to update `PLAN.md` / `data-sources.plan.json` with the agreed changes when the interview finishes.
+
+  **Triggers — use this skill when:**
+  - User says "grill me", "stress test this", "challenge my design", "pressure-test this"
+  - User asks to "poke holes", "find gaps", "review my thinking"
+  - User wants to validate a plan before implementing
+  - User says "interview me about this", "question my decisions", "ask me hard questions"
+  - Used after `/architect` or `/plan` when the user wants to pressure-test the output
+  - User is about to commit to a schema, data model, or architectural decision and wants a second pass
+
+  **Covers:** Plans and architectures for Docyrus-backed apps — data sources, fields, enums, relations, apps, queries, and the surrounding access-control and implementation-feasibility questions. Works best when there is a plan artifact on disk (PLAN.md, data-sources.plan.json, discovery snapshot) to anchor the conversation.
 ---
 
 # Grill Me