@johnnywu/pi-subagents 1.0.0

package/extensions/subagent-render.ts

@@ -0,0 +1,270 @@
+import { homedir } from 'node:os';
+import type { AgentProgress } from './subagent-executor.ts';
+
+export interface SubagentCallArgs {
+  agent?: string;
+  task?: string;
+}
+
+export interface RenderTextOptions {
+  expanded: boolean;
+  suppressOutput?: boolean;
+  suppressUsage?: boolean;
+  expandHint?: string;
+}
+
+export type SubagentResultLineKind = 'status' | 'tool' | 'hint' | 'usage' | 'output' | 'blank';
+
+export interface SubagentResultLine {
+  text: string;
+  kind: SubagentResultLineKind;
+  singleLine: boolean;
+  tool?: {
+    name: string;
+    args: Record<string, unknown>;
+    status: 'running' | 'done' | 'error';
+  };
+}
+
+const TOOL_LOG_LIMIT = 20;
+
+export type ContextUsageSeverity = 'dim' | 'warning' | 'error';
+
+export function contextUsageSeverity(usage: {
+  contextTokens?: number;
+  contextWindow?: number;
+}): ContextUsageSeverity {
+  if (!usage.contextWindow || usage.contextWindow <= 0) return 'dim';
+  const percent = (usage.contextTokens ?? 0) / usage.contextWindow;
+  if (percent >= 0.9) return 'error';
+  if (percent >= 0.7) return 'warning';
+  return 'dim';
+}
+
+function preview(text: string, length: number): string {
+  return text.length > length ? `${text.slice(0, length)}...` : text;
+}
+
+function elapsedSeconds(ms: number): number {
+  return Math.round(ms / 1000);
+}
+
+function summaryText(markdown: string): string {
+  return markdown.split('\n').slice(0, 20).join('\n');
+}
+
+function formatTokens(value: number): string {
+  if (Math.abs(value) >= 1_000_000) return `${Number((value / 1_000_000).toFixed(1))}m`;
+  if (Math.abs(value) >= 1_000) return `${Number((value / 1_000).toFixed(1))}k`;
+  return String(value);
+}
+
+export function formatUsage(progress: AgentProgress): string {
+  const usage = progress.usage;
+  const parts: string[] = [];
+
+  if (usage.contextWindow && usage.contextWindow > 0) {
+    const percent = ((usage.contextTokens / usage.contextWindow) * 100).toFixed(1);
+    parts.push(`${percent}%/${formatTokens(usage.contextWindow)}`);
+  }
+
+  parts.push(`↑${formatTokens(usage.input)}`);
+  parts.push(`↓${formatTokens(usage.output)}`);
+  parts.push(`R${formatTokens(usage.cacheRead)}`);
+  if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+  parts.push(`$${usage.cost.toFixed(3)}`);
+
+  return parts.join(' ');
+}
+
+function indent(text: string, spaces: number): string {
+  const prefix = ' '.repeat(spaces);
+  return text
+    .split('\n')
+    .map((line) => `${prefix}${line}`)
+    .join('\n');
+}
+
+function shortenPath(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const home = homedir();
+  return value.startsWith(`${home}/`) ? `~/${value.slice(home.length + 1)}` : value;
+}
+
+function quote(value: string | undefined): string {
+  return value ? JSON.stringify(value) : '';
+}
+
+function stringArg(args: Record<string, unknown>, key: string): string | undefined {
+  const value = args[key];
+  return typeof value === 'string' ? value : undefined;
+}
+
+function numberArg(args: Record<string, unknown>, key: string): number | undefined {
+  const value = args[key];
+  return typeof value === 'number' ? value : undefined;
+}
+
+function pathArg(args: Record<string, unknown>, fallback?: string): string {
+  return shortenPath(args.path ?? args.file_path) ?? fallback ?? '...';
+}
+
+function lineRange(args: Record<string, unknown>): string {
+  if (args.offset === undefined && args.limit === undefined) return '';
+  const startLine = numberArg(args, 'offset') ?? 1;
+  const limit = numberArg(args, 'limit');
+  const endLine = limit !== undefined ? startLine + limit - 1 : undefined;
+  return `:${startLine}${endLine !== undefined ? `-${endLine}` : ''}`;
+}
+
+function limitSuffix(args: Record<string, unknown>): string {
+  const limit = numberArg(args, 'limit');
+  return limit !== undefined ? ` (limit ${limit})` : '';
+}
+
+function formatToolTitle(name: string, args: Record<string, unknown>): string {
+  switch (name) {
+    case 'read':
+      return `read ${pathArg(args)}${lineRange(args)}`;
+    case 'bash': {
+      const command = stringArg(args, 'command') ?? '';
+      const timeout = numberArg(args, 'timeout');
+      return `$ ${command}${timeout !== undefined ? ` (timeout ${timeout}s)` : ''}`;
+    }
+    case 'edit':
+      return `edit ${pathArg(args)}`;
+    case 'write':
+      return `write ${pathArg(args)}`;
+    case 'find': {
+      const pattern = stringArg(args, 'pattern') ?? '';
+      return `find ${pattern} in ${pathArg(args, '.')}${limitSuffix(args)}`;
+    }
+    case 'grep': {
+      const pattern = stringArg(args, 'pattern') ?? '';
+      const glob = stringArg(args, 'glob');
+      const globSuffix = glob ? ` (${glob})` : '';
+      const limit = numberArg(args, 'limit');
+      const limitText = limit !== undefined ? ` limit ${limit}` : '';
+      return `grep /${pattern}/ in ${pathArg(args, '.')}${globSuffix}${limitText}`;
+    }
+    case 'ls':
+      return `ls ${pathArg(args, '.')}${limitSuffix(args)}`;
+    case 'webfetch': {
+      const url = stringArg(args, 'url') ?? '';
+      const mode = stringArg(args, 'mode');
+      return `webfetch ${url}${mode ? ` (${mode})` : ''}`.trimEnd();
+    }
+    case 'subagent': {
+      const agent = stringArg(args, 'agent');
+      const task = stringArg(args, 'task');
+      return `${name} ${agent ?? ''}${task ? ` ${quote(preview(task, 60))}` : ''}`.trimEnd();
+    }
+    default: {
+      const values = Object.values(args).filter((value) => typeof value === 'string') as string[];
+      return `${name}${values.length > 0 ? ` ${quote(preview(values[0], 80))}` : ''}`;
+    }
+  }
+}
+
+function formatToolLineItems(
+  progress: AgentProgress,
+  options: RenderTextOptions,
+): SubagentResultLine[] {
+  const lines: SubagentResultLine[] = [];
+  const hiddenCount = options.expanded ? 0 : Math.max(0, progress.tools.length - TOOL_LOG_LIMIT);
+  const visibleTools = progress.tools.slice(hiddenCount);
+
+  if (hiddenCount > 0) {
+    const expandHint = options.expandHint ?? 'to expand';
+    lines.push({
+      text: `  ... (${hiddenCount} earlier tool calls, ${expandHint})`,
+      kind: 'hint',
+      singleLine: true,
+    });
+  }
+
+  for (const tool of visibleTools) {
+    lines.push({
+      text: `${tool.status === 'running' ? '▸' : ' '} ${formatToolTitle(tool.name, tool.args)}`,
+      kind: 'tool',
+      singleLine: true,
+      tool: { name: tool.name, args: tool.args, status: tool.status },
+    });
+    if ((options.expanded || progress.status === 'running') && tool.nested) {
+      for (const line of formatSubagentResultLines(tool.nested, {
+        expanded: false,
+        suppressOutput: true,
+      })) {
+        lines.push({ ...line, text: indent(line.text, 2) });
+      }
+    }
+  }
+  return lines;
+}
+
+export function formatSubagentCall(
+  args: SubagentCallArgs,
+  options: Partial<RenderTextOptions> = {},
+): string {
+  if (options.expanded) return `subagent ${args.agent ?? '...'}\n${args.task ?? '...'}`;
+  return `subagent ${args.agent ?? '...'} ${preview(args.task ?? '...', 60)}`;
+}
+
+export function formatSubagentResultLines(
+  progress: AgentProgress,
+  options: RenderTextOptions,
+): SubagentResultLine[] {
+  const icon = progress.status === 'error' ? '✗' : progress.status === 'done' ? '✓' : '▸';
+  const statusLine = `${icon} ${progress.agent}${progress.model ? ` (${progress.model})` : ''} — ${
+    progress.tools.length
+  } tools · ${elapsedSeconds(progress.elapsedMs)}s`;
+  const toolLines = formatToolLineItems(progress, options);
+  const usage = formatUsage(progress);
+  const lines: SubagentResultLine[] = [
+    { text: statusLine, kind: 'status', singleLine: false },
+    ...toolLines,
+  ];
+
+  if (progress.status === 'running' || options.suppressOutput) {
+    if (!options.suppressUsage) {
+      lines.push({ text: '', kind: 'blank', singleLine: false });
+      lines.push({ text: usage, kind: 'usage', singleLine: false });
+    }
+    return lines;
+  }
+
+  const output = options.expanded
+    ? progress.output || '(no output)'
+    : summaryText(progress.output) || '(no output)';
+
+  lines.push({ text: '', kind: 'blank', singleLine: false });
+  lines.push({ text: output, kind: 'output', singleLine: false });
+
+  if (!options.expanded) {
+    const totalLines = (progress.output || '').split('\n').length;
+    if (totalLines > 20) {
+      const hidden = totalLines - 20;
+      const expandHint = options.expandHint ?? 'to expand';
+      lines.push({
+        text: `... (${hidden} more lines, ${expandHint})`,
+        kind: 'hint',
+        singleLine: true,
+      });
+    }
+  }
+
+  if (!options.suppressUsage) {
+    lines.push({ text: '', kind: 'blank', singleLine: false });
+    lines.push({ text: usage, kind: 'usage', singleLine: false });
+  }
+  return lines;
+}
+
+export function formatSubagentResultText(
+  progress: AgentProgress,
+  options: RenderTextOptions,
+): string {
+  return formatSubagentResultLines(progress, options)
+    .map((line) => line.text)
+    .join('\n');
+}

package/extensions/subagent-tool.ts

@@ -0,0 +1,329 @@
+import { homedir } from 'node:os';
+import {
+  getMarkdownTheme,
+  keyHint,
+  type AgentToolUpdateCallback,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ThemeColor,
+} from '@earendil-works/pi-coding-agent';
+import { Container, Markdown, Spacer, Text } from '@earendil-works/pi-tui';
+import type { AgentConfig } from './agent-loader.ts';
+import { type AgentProgress, type AgentResult, runSubagent } from './subagent-executor.ts';
+import {
+  contextUsageSeverity,
+  formatSubagentCall,
+  formatSubagentResultLines,
+  formatUsage,
+  type SubagentResultLine,
+} from './subagent-render.ts';
+
+const SubagentParams = {
+  type: 'object',
+  properties: {
+    agent: { type: 'string', description: 'Name of the agent to invoke' },
+    task: { type: 'string', description: 'Task to delegate to the agent' },
+    cwd: { type: 'string', description: 'Working directory for the agent process' },
+  },
+  required: ['agent', 'task'],
+  additionalProperties: false,
+} as any;
+
+type SubagentParamsType = {
+  agent: string;
+  task: string;
+  cwd?: string;
+};
+
+type RegisterablePi = Pick<ExtensionAPI, 'registerTool'>;
+type RecursionEnv = Partial<
+  Record<'PI_SUBAGENT_ALLOWED' | 'PI_SUBAGENT_DEPTH' | 'PI_SUBAGENT_MAX_DEPTH', string>
+>;
+
+export interface RegisterSubagentToolOptions {
+  agents: AgentConfig[];
+  run?: typeof runSubagent;
+  env?: RecursionEnv;
+}
+
+function availableAgentsText(agents: AgentConfig[]): string {
+  return (
+    agents
+      .map((agent) => agent.name)
+      .sort()
+      .join(', ') || 'none'
+  );
+}
+
+function toToolResult(result: AgentResult) {
+  return {
+    content: [{ type: 'text' as const, text: result.output || '(no output)' }],
+    details: result,
+    isError: result.isError,
+  };
+}
+
+function toProgressResult(progress: AgentProgress) {
+  return {
+    content: [{ type: 'text' as const, text: progress.output || '(running...)' }],
+    details: progress,
+  };
+}
+
+function parseEnvNumber(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function allowedAgentNames(env: RecursionEnv): Set<string> | undefined {
+  const raw = env?.PI_SUBAGENT_ALLOWED;
+  if (!raw) return undefined;
+  return new Set(
+    raw
+      .split(',')
+      .map((name) => name.trim())
+      .filter(Boolean),
+  );
+}
+
+function isPastMaxDepth(env: RecursionEnv): boolean {
+  const depth = parseEnvNumber(env?.PI_SUBAGENT_DEPTH);
+  const maxDepth = parseEnvNumber(env?.PI_SUBAGENT_MAX_DEPTH);
+  return depth !== undefined && maxDepth !== undefined && depth > maxDepth;
+}
+
+type CollapsedTheme = {
+  fg: (name: ThemeColor, text: string) => string;
+  bold: (text: string) => string;
+};
+
+function preview(text: string, length: number): string {
+  return text.length > length ? `${text.slice(0, length)}...` : text;
+}
+
+function shortenPath(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const home = homedir();
+  return value.startsWith(`${home}/`) ? `~/${value.slice(home.length + 1)}` : value;
+}
+
+function stringArg(args: Record<string, unknown>, key: string): string | undefined {
+  const value = args[key];
+  return typeof value === 'string' ? value : undefined;
+}
+
+function numberArg(args: Record<string, unknown>, key: string): number | undefined {
+  const value = args[key];
+  return typeof value === 'number' ? value : undefined;
+}
+
+function styledPathArg(
+  args: Record<string, unknown>,
+  theme: CollapsedTheme,
+  fallback?: string,
+): string {
+  const path = shortenPath(args.path ?? args.file_path) ?? fallback;
+  return path ? theme.fg('accent', path) : theme.fg('toolOutput', '...');
+}
+
+function styledLineRange(args: Record<string, unknown>, theme: CollapsedTheme): string {
+  if (args.offset === undefined && args.limit === undefined) return '';
+  const startLine = numberArg(args, 'offset') ?? 1;
+  const limit = numberArg(args, 'limit');
+  const endLine = limit !== undefined ? startLine + limit - 1 : undefined;
+  return theme.fg('warning', `:${startLine}${endLine !== undefined ? `-${endLine}` : ''}`);
+}
+
+function styledLimitSuffix(args: Record<string, unknown>, theme: CollapsedTheme): string {
+  const limit = numberArg(args, 'limit');
+  return limit !== undefined ? theme.fg('toolOutput', ` (limit ${limit})`) : '';
+}
+
+function styledToolTitle(
+  name: string,
+  args: Record<string, unknown>,
+  theme: CollapsedTheme,
+): string {
+  switch (name) {
+    case 'read':
+      return `${theme.fg('toolTitle', theme.bold('read'))} ${styledPathArg(args, theme)}${styledLineRange(args, theme)}`;
+    case 'bash': {
+      const command = stringArg(args, 'command') ?? '';
+      const timeout = numberArg(args, 'timeout');
+      const timeoutSuffix =
+        timeout !== undefined ? theme.fg('muted', ` (timeout ${timeout}s)`) : '';
+      return `${theme.fg('toolTitle', theme.bold(`$ ${command || '...'}`))}${timeoutSuffix}`;
+    }
+    case 'edit':
+      return `${theme.fg('toolTitle', theme.bold('edit'))} ${styledPathArg(args, theme)}`;
+    case 'write':
+      return `${theme.fg('toolTitle', theme.bold('write'))} ${styledPathArg(args, theme)}`;
+    case 'find': {
+      const pattern = stringArg(args, 'pattern') ?? '';
+      return `${theme.fg('toolTitle', theme.bold('find'))} ${theme.fg('accent', pattern)}${theme.fg('toolOutput', ` in ${shortenPath(args.path) ?? '.'}`)}${styledLimitSuffix(args, theme)}`;
+    }
+    case 'grep': {
+      const pattern = stringArg(args, 'pattern') ?? '';
+      const glob = stringArg(args, 'glob');
+      const limit = numberArg(args, 'limit');
+      let text = `${theme.fg('toolTitle', theme.bold('grep'))} ${theme.fg('syntaxKeyword', `/${pattern}/`)}${theme.fg('dim', ' in ')}${theme.fg('accent', shortenPath(args.path) ?? '.')}`;
+      if (glob) text += theme.fg('muted', ` (${glob})`);
+      if (limit !== undefined) text += theme.fg('toolOutput', ` limit ${limit}`);
+      return text;
+    }
+    case 'ls':
+      return `${theme.fg('toolTitle', theme.bold('ls'))} ${styledPathArg(args, theme, '.')}${styledLimitSuffix(args, theme)}`;
+    case 'webfetch': {
+      const url = stringArg(args, 'url') ?? '';
+      const mode = stringArg(args, 'mode');
+      return `${theme.fg('toolTitle', theme.bold('webfetch'))} ${theme.fg('accent', url)}${mode ? theme.fg('toolOutput', ` (${mode})`) : ''}`;
+    }
+    case 'subagent': {
+      const agent = stringArg(args, 'agent') ?? '';
+      const task = stringArg(args, 'task');
+      return `${theme.fg('toolTitle', theme.bold('subagent'))} ${theme.fg('accent', agent)}${task ? ` ${theme.fg('dim', JSON.stringify(preview(task, 60)))}` : ''}`.trimEnd();
+    }
+    default: {
+      const values = Object.values(args).filter((value) => typeof value === 'string') as string[];
+      return `${theme.fg('toolTitle', theme.bold(name))}${values.length > 0 ? ` ${theme.fg('dim', JSON.stringify(preview(values[0], 80)))}` : ''}`;
+    }
+  }
+}
+
+function styledCollapsedLine(
+  line: SubagentResultLine,
+  details: AgentResult | AgentProgress,
+  theme: CollapsedTheme,
+): string {
+  if (line.kind === 'status')
+    return theme.fg(details.status === 'error' ? 'error' : 'success', line.text);
+  if (line.kind === 'hint') return theme.fg('dim', line.text);
+  if (line.kind === 'tool' && line.tool) {
+    const prefix = line.tool.status === 'running' ? theme.fg('warning', '▸') : ' ';
+    return `${prefix} ${styledToolTitle(line.tool.name, line.tool.args, theme)}`;
+  }
+  if (line.kind === 'usage') return theme.fg(contextUsageSeverity(details.usage), line.text);
+  return line.text;
+}
+
+function styledSubagentCall(
+  args: SubagentParamsType,
+  theme: CollapsedTheme,
+  expanded: boolean,
+): string {
+  const title = `${theme.fg('toolTitle', theme.bold('subagent'))} ${theme.fg('accent', args.agent ?? '...')}`;
+  if (expanded) return `${title}\n${theme.fg('dim', args.task ?? '...')}`;
+  return `${title} ${theme.fg('dim', formatSubagentCall(args).replace(/^subagent \S+ /, ''))}`;
+}
+
+function renderResultLines(
+  details: AgentResult | AgentProgress,
+  theme: CollapsedTheme,
+  options: {
+    expanded: boolean;
+    suppressOutput?: boolean;
+    suppressUsage?: boolean;
+    expandHint?: string;
+  },
+): Container {
+  const container = new Container();
+  for (const line of formatSubagentResultLines(details, options)) {
+    if (line.kind === 'blank') {
+      container.addChild(new Spacer(1));
+      continue;
+    }
+
+    const text = styledCollapsedLine(line, details, theme);
+    container.addChild(new Text(text, 0, 0));
+  }
+  return container;
+}
+
+function renderCollapsedResult(
+  details: AgentResult | AgentProgress,
+  theme: CollapsedTheme,
+): Container {
+  return renderResultLines(details, theme, {
+    expanded: false,
+    expandHint: keyHint('app.tools.expand', 'to expand'),
+  });
+}
+
+export function registerSubagentTool(
+  pi: RegisterablePi,
+  options: RegisterSubagentToolOptions,
+): void {
+  const env: RecursionEnv = options.env ?? process.env;
+  if (isPastMaxDepth(env)) return;
+
+  const allowed = allowedAgentNames(env);
+  const agents = allowed
+    ? options.agents.filter((candidate) => allowed.has(candidate.name))
+    : options.agents;
+  const runner = options.run ?? runSubagent;
+
+  pi.registerTool({
+    name: 'subagent',
+    label: 'Subagent',
+    description: 'Delegate a task to a named sub-agent running in an isolated pi process.',
+    promptSnippet: 'Delegate isolated tasks with subagent({ agent, task, cwd? }).',
+    parameters: SubagentParams,
+
+    async execute(
+      _toolCallId: string,
+      params: SubagentParamsType,
+      signal: AbortSignal | undefined,
+      onUpdate: AgentToolUpdateCallback<AgentProgress> | undefined,
+      ctx: ExtensionContext,
+    ) {
+      const agent = agents.find((candidate) => candidate.name === params.agent);
+      if (!agent) {
+        throw new Error(
+          `Unknown agent: ${params.agent}. Available agents: ${availableAgentsText(agents)}.`,
+        );
+      }
+
+      const result = await runner({
+        agent,
+        task: params.task,
+        cwd: params.cwd ?? ctx.cwd,
+        signal,
+        depth: Number(env.PI_SUBAGENT_DEPTH ?? '0') + 1,
+        onProgress: (progress) => onUpdate?.(toProgressResult(progress)),
+      });
+
+      return toToolResult(result);
+    },
+
+    renderCall(args, theme, context) {
+      const typedArgs = args as SubagentParamsType;
+      return new Text(styledSubagentCall(typedArgs, theme, context.expanded), 0, 0);
+    },
+
+    renderResult(result, options, theme) {
+      const details = result.details as AgentResult | AgentProgress | undefined;
+      if (!details) {
+        const first = result.content[0];
+        return new Text(first?.type === 'text' ? first.text : '(no output)', 0, 0);
+      }
+
+      if (options.expanded) {
+        const container = renderResultLines(details, theme, {
+          expanded: true,
+          suppressOutput: true,
+          suppressUsage: true,
+        });
+        container.addChild(new Spacer(1));
+        container.addChild(new Markdown(details.output || '(no output)', 0, 0, getMarkdownTheme()));
+        container.addChild(new Spacer(1));
+        container.addChild(
+          new Text(theme.fg(contextUsageSeverity(details.usage), formatUsage(details)), 0, 0),
+        );
+        return container;
+      }
+
+      return renderCollapsedResult(details, theme);
+    },
+  });
+}

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@johnnywu/pi-subagents",
+  "version": "1.0.0",
+  "description": "Sub-agents extension for pi coding agent.",
+  "homepage": "https://github.com/jwu/pi-subagents#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jwu/pi-subagents.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jwu/pi-subagents/issues"
+  },
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "subagents"
+  ],
+  "author": "jwu",
+  "license": "MIT",
+  "files": [
+    "extensions/",
+    "README.md",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit --ignoreDeprecations 6.0",
+    "lint": "bun run format:check && bun run typecheck",
+    "format": "prettier --write '**/*.ts'",
+    "format:check": "prettier --check '**/*.ts'",
+    "prepare": "[ -d .git ] && simple-git-hooks || true",
+    "release": "GH_TOKEN=$(gh auth token) semantic-release --no-ci",
+    "release:dry": "GH_TOKEN=$(gh auth token) semantic-release --no-ci --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "release": {
+    "repositoryUrl": "https://github.com/jwu/pi-subagents.git",
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/changelog",
+        {
+          "changelogFile": "CHANGELOG.md"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json",
+            "CHANGELOG.md"
+          ],
+          "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
+  },
+  "simple-git-hooks": {
+    "pre-commit": "bun prettier --check '**/*.ts' && bun test",
+    "commit-msg": "bun commitlint --edit \"$1\""
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/node": "^24.3.0",
+    "prettier": "^3.8.3",
+    "semantic-release": "^25.0.3",
+    "simple-git-hooks": "^2.13.1",
+    "typescript": "^6.0.3"
+  }
+}