@docyrus/docyrus 0.0.62 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docyrus/docyrus",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "private": false,
   "description": "Docyrus API CLI",
   "main": "./main.js",

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/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