pi-code 1.0.18 → 1.0.19

package/README.md

@@ -44,7 +44,7 @@ One `pi install` and everything below loads on the next start. `pi list` shows w
 | Global + project rules | `~/.claude/rules`, `.claude/rules` (nearest at or above cwd); unscoped rules inlined in full, `paths:`-scoped rules surfaced as pointers and auto-attached (the rule body is appended to a read/edit/write result when a matching file is touched, once per rule per session) | `claude-rules.ts` |
 | Custom slash commands | `.claude/commands/**/*.md` (namespaced `/dir:name`); `$ARGUMENTS` (with the `ARGUMENTS:` append when unused), 0-based `$ARGUMENTS[N]`/`$N`, named `arguments:` frontmatter, `${CLAUDE_SESSION_ID}`/`${CLAUDE_EFFORT}`/`${CLAUDE_SKILL_DIR}`/`${CLAUDE_PROJECT_DIR}` (in bodies and `allowed-tools` rules); `` !`cmd` `` and multi-line ```` ```! ```` bash (whitespace-bounded, merged stderr, 2-minute budget, a failure aborts the invocation with the documented exit-1 carveout), `@file` inlining; `allowed-tools` with `Bash(...)` and `Read`/`Edit`/`Write` path scopes enforced at call time (gitignore anchors, Edit governs writes), `disallowed-tools`, `argument-hint`, `model` (switches the session model for the command's turn, restored after), `effort` (raises reasoning for the turn, restored after), `shell: powershell` (injected spans run through PowerShell when a `pwsh` binary is present, else `/bin/sh`); the model can also run a command itself through the `SlashCommand` tool (Claude's `SlashCommand` in `allowed-tools`), steered by `when_to_use` and opted out per file with `disable-model-invocation` (`user-invocable: false` hides a command from the menu while still exposing it to the model); `disableSkillShellExecution` (managed and user always, project when trusted) replaces every `!` span with a policy-disabled placeholder; project commands gated on approval | `commands.ts` |
 | `/init` | generates a project context file: detects an existing `AGENTS.md`/`CLAUDE.md` (proposes improvements) or none (creates `AGENTS.md`, pi's preferred name), ingesting `.cursor/rules`, `.cursorrules`, and `.github/copilot-instructions.md` when present; drives the main agent with full tools via a prompt (not a tool-less completion) so it analyzes the codebase and writes the file itself | `init.ts` |
-| Skills | `.claude/skills` → pi skill discovery, project skills gated on approval (pi reads `name`, `description`, `disable-model-invocation`; `allowed-tools` is inert in pi's loader) | `skills.ts` |
+| Skills | `.claude/skills` → pi skill discovery, project skills gated on approval (pi reads `name`, `description`, `disable-model-invocation`; `allowed-tools` is inert in pi's loader); invoking `/skill:name` expands the body through the command pipeline, as Claude documents commands and skills "work the same way": `` !`cmd` `` spans, `@file` references, `$ARGUMENTS`/positional substitution and `${CLAUDE_*}` variables, with a malformed-frontmatter skill degrading to pi's plain expansion | `skills.ts` |
 | Hooks | `.claude/settings.json` hooks: PreToolUse (blocks, rewrites input via `updatedInput`), PostToolUse (feedback and `additionalContext` land next to the tool result), PostToolUseFailure, SessionStart (context injection), UserPromptSubmit (blocks and injects context), Stop (a block continues the conversation), SubagentStart/SubagentStop, PreCompact, PostCompact, SessionEnd, Notification (idle_prompt, the type pi can source), InstructionsLoaded (observational: fires per loaded context file at session start, plus `path_glob_match` on a scoped-rule attach and `include` per resolved `@import`; deduped per session; `nested_traversal`/`compact` reasons never fire since pi does not lazily load nested CLAUDE.md or reload after compaction); `type: http` entries POST the payload (a 2xx JSON body renders the decision, everything else is non-blocking per Claude's contract), `type: prompt` evaluates in-process against the session model, `type: mcp_tool` calls a connected server's tool, and `type: agent` (experimental) spawns a read-only Read/Grep/Glob subagent that returns the JSON decision (a missing model/server/runner is non-blocking, only a PreToolUse timeout fails closed); Claude matcher semantics incl. `mcp__server__tool` names; payloads carry session_id, transcript_path, cwd, permission_mode, effort; `permissionDecision: "ask"` prompts via a confirm dialog (blocks when headless), SubagentStop/PostToolUseFailure are notify-only, and a timed-out PreToolUse/UserPromptSubmit hook fails closed at a 60s default (Claude: 600s for PreToolUse, 30s for UserPromptSubmit, both non-blocking) since pi has no permission backstop; `async`/`asyncRewake` command hooks run in the background on every event (never blocking, no decision, no timeout enforced on `async` while asyncRewake keeps its own; an asyncRewake exit 2 wakes the model with the hook's stderr as a new turn, other completions deliver `systemMessage`/`additionalContext` to the model on the next turn, and hooks still running at session end are killed); payloads use Claude's vocabulary for pi's built-ins (Bash/Edit/Write/Read/Grep/Glob names, documented input and Bash/Write response shapes, absolute `file_path`, `updatedInput` translated back); PreToolUse `additionalContext` lands beside the tool result, `updatedToolOutput`/`updatedMCPToolOutput` replace what the model sees, `permissionDecision: "defer"` blocks (pi cannot resume a deferred call), the `if` permission-rule filter runs on tool events only (a hook carrying it never runs elsewhere), Stop/UserPromptSubmit ignore stray matchers, and a Stop hook's `additionalContext` continues the conversation under the block cap; a `command` hook may use exec form (`command` as an argv array, run with no shell) and executes with `CLAUDECODE=1` and `CLAUDE_PROJECT_DIR` set; a user-typed `!`/`!!` bash line runs PreToolUse (there is no PostToolUse for it); `type: http` targets are gated by `allowedHttpHookUrls` (union of managed and settings scopes; unset allows all, `[]` blocks every http hook); a Stop hook may block at most 8 times before the turn ends (`CLAUDE_CODE_STOP_HOOK_BLOCK_CAP`); `disableAllHooks` in any scope turns the system off; `/hooks` prints the resolved configuration | `hooks.ts` |
 | Output styles | `.claude/output-styles` + active `outputStyle`; plus styles shipped by enabled plugins (manifest `outputStyles`, default `output-styles/`, ranked below the user's and project's own); Claude replace semantics with `keep-coding-instructions`; bundled Explanatory/Learning/Proactive; `/output-style [name]` | `output-styles.ts` |
 | CLAUDE.md `@imports` and rewriting | resolves `@path` imports pi's native loader skips (4-hop depth, budget-capped); loads the user `~/.claude/CLAUDE.md` and the project `.claude/CLAUDE.md` (approval-gated, deduped against the repo-root `CLAUDE.md`/`AGENTS.md` pi loads natively) that pi's own loader does not; loads every `CLAUDE.local.md` from the repo root down to cwd (approval-gated, root first); injects the managed `CLAUDE.md` (a per-OS file beside `managed-settings.json`) and the `claudeMd` string from `managed-settings.json` at the top of context (managed content is never excludable); honors `claudeMdExcludes` (glob/absolute-path skip list from user, approved-project, and managed settings, merged; managed content never excluded); strips block-level HTML comments from CLAUDE.md, rule, and imported bodies (fenced-code comments preserved), so a commented-out `@import` does not expand; with `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` set, loads `CLAUDE.md`/`.claude/CLAUDE.md`/`.claude/rules/*.md`/`CLAUDE.local.md` from each `--add-dir` directory (comma-separated for several, since pi's flag is single-value) | `context-imports.ts` |

package/extensions/skills.ts

@@ -7,14 +7,25 @@
  * pi implements the Agent Skills standard, so `SKILL.md` directories work
  * unchanged and register as `/skill:name`.
  *
+ * Claude documents that a command file and a skill "work the same way", so a
+ * SKILL.md body carries the dynamic features command bodies do: `` !`cmd` ``
+ * spans, `@file` references, `$ARGUMENTS`/positional substitution and
+ * `${CLAUDE_*}` variables. pi's loader delivers the raw text, so this extension
+ * intercepts `/skill:name` input for the skills it contributed, expands the body
+ * through the shared command pipeline, and hands pi the already-expanded content
+ * in pi's own skill-block format (pi emits the input event before its own
+ * expansion, and skips text that no longer starts with `/`).
+ *
  * Docs: https://code.claude.com/docs/en/skills.md, https://agentskills.io
  */
 
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { type ExtensionAPI, type ExtensionContext, parseFrontmatter } from '@earendil-works/pi-coding-agent'
 
+import { expandCommand, shellExecutionDisabled } from './commands.js'
+import { parseCommandFile } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
@@ -28,7 +39,6 @@ function isDirectory(target: string): boolean {
   }
 }
 
-/** Existing `.claude/skills` directories, user first then project. */
 /** Existing `.claude/skills` directories, user first then project. The project
  * directory is included only for approved projects: pi's loader surfaces every skill's
  * name and description to the model, so an untrusted repository would otherwise get
@@ -51,6 +61,50 @@ export function skillDirs(cwd: string, home: string, trusted: boolean): string[]
   return dirs
 }
 
+interface FoundSkill {
+  filePath: string
+  baseDir: string
+}
+
+/** The skill a directory entry holds, named as pi's loader names it (frontmatter
+ * `name`, else the directory name); undefined without a readable SKILL.md. */
+function skillAt(root: string, dirName: string): { name: string; filePath: string } | undefined {
+  const filePath = path.join(root, dirName, 'SKILL.md')
+  let content: string
+  try {
+    content = fs.readFileSync(filePath, 'utf-8')
+  } catch {
+    return undefined
+  }
+  let name = dirName
+  try {
+    const declared = parseFrontmatter<Record<string, unknown>>(content).frontmatter.name
+    if (typeof declared === 'string' && declared.trim()) name = declared.trim()
+  } catch {
+    // Malformed frontmatter: pi's loader falls back to the directory name too.
+  }
+  return { name, filePath }
+}
+
+/** A Claude-contributed skill by the name pi's loader gives it. One directory
+ * level, the standard layout. */
+export function findClaudeSkill(name: string, roots: string[]): FoundSkill | undefined {
+  for (const root of roots) {
+    let entries: fs.Dirent[]
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const skill = skillAt(root, entry.name)
+      if (skill?.name === name) return { filePath: skill.filePath, baseDir: path.dirname(skill.filePath) }
+    }
+  }
+  return undefined
+}
+
 export default function skillsExtension(pi: ExtensionAPI) {
   pi.on('resources_discover', async (_event, ctx) => {
     // resources_discover fires after session_start, so the approval is already
@@ -58,4 +112,38 @@ export default function skillsExtension(pi: ExtensionAPI) {
     const skillPaths = skillDirs(ctx.cwd, os.homedir(), isProjectApprovedSilently(ctx))
     return skillPaths.length > 0 ? { skillPaths } : undefined
   })
+
+  // The dynamic-content shim: only for skills this extension contributed; pi's own
+  // `.pi/skills` (or an unknown name) pass through to pi's plain expansion.
+  pi.on('input', async (event, ctx) => {
+    if (event.source === 'extension') return
+    return expandSkillInvocation(pi, event.text, ctx)
+  })
+}
+
+/** A `/skill:name args` invocation into its expanded skill block, or undefined to
+ * pass the input through to pi untouched. The expanded body is wrapped in pi's
+ * skill-block format so downstream behavior (the baseDir note for relative
+ * references) matches an untouched invocation. */
+async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: ExtensionContext): Promise<{ action: 'transform'; text: string } | undefined> {
+  const text = rawText.trimStart()
+  if (!text.startsWith('/skill:')) return
+  const space = text.indexOf(' ')
+  const name = (space === -1 ? text.slice(7) : text.slice(7, space)).trim()
+  const args = space === -1 ? '' : text.slice(space + 1).trim()
+  if (!name) return
+  const trusted = isProjectApprovedSilently(ctx)
+  const found = findClaudeSkill(name, skillDirs(ctx.cwd, os.homedir(), trusted))
+  if (!found) return
+  let parsed: ReturnType<typeof parseCommandFile>
+  try {
+    parsed = parseCommandFile(fs.readFileSync(found.filePath, 'utf-8'))
+  } catch {
+    // Unreadable, or malformed frontmatter: pass through to pi's plain expansion
+    // (the loader registered the skill and delivers the raw body), rather than
+    // failing the invocation over the dynamic features it cannot have.
+    return
+  }
+  const expanded = await expandCommand(pi, parsed, args, { cwd: ctx.cwd }, found.filePath, undefined, { allowShell: !shellExecutionDisabled(ctx.cwd, os.homedir(), trusted) })
+  return { action: 'transform', text: `<skill name="${name}" location="${found.filePath}">\nReferences are relative to ${found.baseDir}.\n\n${expanded}\n</skill>` }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",