pi-code 1.0.8 → 1.0.10

package/extensions/claude-rules.ts

@@ -21,8 +21,9 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+import { claudeConfigDir } from './internal/config-dir.js'
 import { publishInstructionLoad } from './internal/instruction-events.js'
-import { globToRegExpSource } from './internal/path-rules.js'
+import { type CompiledGlob, compileGlobs, matchesCompiledGlobs } from './internal/path-rules.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { findNearestDir } from './internal/project-root.js'
 import { stripBlockComments } from './internal/strip-comments.js'
@@ -81,19 +82,7 @@ export function parseFrontmatter(content: string): Frontmatter {
  * the rule set's root.
  */
 export function pathMatchesGlobs(relPath: string, globs: string[]): boolean {
-  const posix = relPath.split(path.sep).join('/')
-  const base = posix.split('/').pop() ?? posix
-  return globs.some((raw) => {
-    let glob = raw.trim()
-    if (!glob) return false
-    if (glob.startsWith('./')) glob = glob.slice(2)
-    else if (glob.startsWith('/')) glob = glob.slice(1)
-    // A trailing slash means the directory's contents, like gitignore; `docs/` alone
-    // would compile to `^docs/$` and match nothing.
-    if (glob.endsWith('/')) glob += '**'
-    const target = glob.includes('/') ? posix : base
-    return new RegExp(`^${globToRegExpSource(glob)}$`).test(target)
-  })
+  return matchesCompiledGlobs(relPath, compileGlobs(globs))
 }
 
 /** A rule pointer line, annotated with its path scope when present. */
@@ -199,8 +188,10 @@ function rulesSection(title: string, rules: RuleSet, base: string): string {
 
 /** A scoped rule resolved to the root its globs match against, ready to attach. */
 interface AttachTarget {
-  key: string
+  /** The rule's `paths:` globs as written, reported on the instruction-events bus. */
   globs: string[]
+  /** The globs precompiled once at session start for the per-tool-result scan. */
+  compiled: CompiledGlob[]
   body: string
   /** The absolute directory `paths:` globs are matched relative to. */
   root: string
@@ -210,18 +201,26 @@ interface AttachTarget {
   memoryType: 'User' | 'Project'
 }
 
+// Module level because the working list lives in each extension instance's closure.
+let pendingScopedRules = 0
+
+/** Test seam: scoped rules still awaiting attachment in the current session, for
+ * asserting that a fully attached rule leaves the per-tool-result working list. */
+export function pendingScopedRuleCount(): number {
+  return pendingScopedRules
+}
+
 export default function claudeRulesExtension(pi: ExtensionAPI) {
-  const globalRulesDir = path.join(os.homedir(), '.claude', 'rules')
+  const globalRulesDir = path.join(claudeConfigDir(os.homedir()), 'rules')
   let globalRules: RuleSet = EMPTY_RULES
   let projectRules: RuleSet = EMPTY_RULES
   // The base a scoped-rule pointer is written against, so the model's read resolves.
   // The project rules dir may sit at an ancestor of cwd, where a cwd-relative
   // '.claude/rules' would point the read at a path that does not exist.
   let projectRulesBase = '.claude/rules'
-  // Scoped rules ready to attach when a matching file is touched, and the set of
-  // rules already attached this session so each attaches at most once.
+  // Scoped rules still awaiting a matching touch. An attached rule leaves the
+  // list, so each attaches at most once and the per-tool-result scan shrinks.
   let attachTargets: AttachTarget[] = []
-  const attached = new Set<string>()
 
   pi.on('session_start', async (_event, ctx) => {
     globalRules = readRules(globalRulesDir)
@@ -236,13 +235,14 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
 
     // Global globs are relative to cwd; project globs to the project root (the dir
     // holding .claude), so `db/**` in a repo rule matches repo-relative paths even
-    // from a subdirectory session. Reset per session so a re-run re-attaches.
-    attached.clear()
+    // from a subdirectory session. Globs compile here, once per session, rather
+    // than on every tool result; rebuilt per session so a re-run re-attaches.
     const projectRoot = projectRulesDir ? path.dirname(path.dirname(projectRulesDir)) : ctx.cwd
     attachTargets = [
-      ...globalRules.scoped.map((rule) => ({ key: `global:${rule.rel}`, globs: rule.paths, body: rule.body, root: ctx.cwd, file: path.join(globalRulesDir, rule.rel), memoryType: 'User' as const })),
-      ...projectRules.scoped.map((rule) => ({ key: `project:${rule.rel}`, globs: rule.paths, body: rule.body, root: projectRoot, file: path.join(projectRulesDir ?? path.join(ctx.cwd, '.claude', 'rules'), rule.rel), memoryType: 'Project' as const })),
+      ...globalRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: ctx.cwd, file: path.join(globalRulesDir, rule.rel), memoryType: 'User' as const })),
+      ...projectRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: projectRoot, file: path.join(projectRulesDir ?? path.join(ctx.cwd, '.claude', 'rules'), rule.rel), memoryType: 'Project' as const })),
     ]
+    pendingScopedRules = attachTargets.length
     // Relative to cwd, which the read tool resolves: an ancestor dir yields a
     // `../…/.claude/rules` the model can follow, where a bare '.claude/rules'
     // would point at a nonexistent path under the subdirectory.
@@ -277,21 +277,25 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
     const abs = path.resolve(ctx.cwd, rel)
 
     const bodies: string[] = []
+    const remaining: AttachTarget[] = []
     for (const target of attachTargets) {
-      if (attached.has(target.key)) continue
       const relativeToRoot = path.relative(target.root, abs)
       // A file outside the rule root cannot match its project-relative globs. Test for
       // a real parent-traversal segment, not a leading '..' (a file named `..config` is
       // inside the root).
-      if (relativeToRoot === '..' || relativeToRoot.startsWith(`..${path.sep}`) || path.isAbsolute(relativeToRoot)) continue
-      if (!pathMatchesGlobs(relativeToRoot, target.globs)) continue
-      attached.add(target.key)
+      const outsideRoot = relativeToRoot === '..' || relativeToRoot.startsWith(`..${path.sep}`) || path.isAbsolute(relativeToRoot)
+      if (outsideRoot || !matchesCompiledGlobs(relativeToRoot, target.compiled)) {
+        remaining.push(target)
+        continue
+      }
       bodies.push(target.body)
       // The lazy attach is Claude's path_glob_match instruction load; the hooks
-      // extension bridges the bus event to the InstructionsLoaded hook. The
-      // once-per-session attach set above also bounds the events to one per rule.
+      // extension bridges the bus event to the InstructionsLoaded hook. Leaving
+      // the working list also bounds the events to one per rule per session.
       publishInstructionLoad(pi.events, { file_path: target.file, memory_type: target.memoryType, load_reason: 'path_glob_match', globs: target.globs, trigger_file_path: abs })
     }
+    attachTargets = remaining
+    pendingScopedRules = attachTargets.length
     if (bodies.length === 0) return
     return { content: [...event.content, ...bodies.map((text) => ({ type: 'text' as const, text }))] }
   })

package/extensions/commands.ts

@@ -45,6 +45,7 @@ import { Type } from 'typebox'
 
 import { matchesBashRules } from './internal/bash-rules.js'
 import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
+import { claudeConfigDir } from './internal/config-dir.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
@@ -115,7 +116,7 @@ function isDirectory(target: string): boolean {
  * directory is the nearest at or above cwd (bounded at the repository root, matching
  * the approval walk) and is included only for approved projects. */
 export function commandDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(home, '.claude', 'commands')]
+  const candidates = [path.join(claudeConfigDir(home), 'commands')]
   if (trusted) candidates.push(findNearestDir(cwd, path.join('.claude', 'commands')) ?? path.join(cwd, '.claude', 'commands'))
   const dirs: string[] = []
   for (const dir of candidates) {
@@ -165,7 +166,7 @@ type CommandPlugin = NonNullable<DiscoveredCommand['plugin']>
  */
 export function shellExecutionDisabled(cwd: string, home: string, trusted: boolean): boolean {
   if (readManagedSettings().disableSkillShellExecution === true) return true
-  const files = [path.join(home, '.claude', 'settings.json')]
+  const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (trusted) {
     for (const name of ['settings.json', 'settings.local.json']) {
       files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))
@@ -244,6 +245,8 @@ export interface SlashCommandEntry {
   name: string
   description: string
   argumentHint?: string
+  /** `when_to_use:` trigger text, appended to this entry's line in the tool listing. */
+  whenToUse?: string
 }
 
 /** One listed command's cap inside the tool description, as Claude cuts an
@@ -271,7 +274,10 @@ export function slashCommandToolDescription(commands: SlashCommandEntry[], budge
   let omitted = 0
   for (const command of commands) {
     const hintSuffix = command.argumentHint ? ` (${command.argumentHint})` : ''
-    const entry = `/${command.name} - ${command.description}${hintSuffix}`.slice(0, ENTRY_CHAR_CAP)
+    // when_to_use is model-facing trigger text, appended after the description and before
+    // the argument hint; it shares the per-entry cap and never reaches the user surface.
+    const whenSuffix = command.whenToUse ? ` ${command.whenToUse}` : ''
+    const entry = `/${command.name} - ${command.description}${whenSuffix}${hintSuffix}`.slice(0, ENTRY_CHAR_CAP)
     if (used + entry.length + 1 > budget) {
       omitted++
       continue // a shorter later entry may still fit the remaining budget
@@ -303,6 +309,8 @@ export default function commandsExtension(pi: ExtensionAPI) {
   let pendingPathRules: Partial<Record<PathRuleTool, string[]>> | undefined
   /** The session model to restore after a command's `model:` override drove its run. */
   let pendingModelRestore: ModelLike | undefined
+  /** The thinking level to restore after a command's `effort:` override drove its run. */
+  let pendingEffortRestore: string | undefined
 
   // Claude's contract is "the grant clears when you send your next message", and
   // pi's turn_end fires after every assistant step: restoring there stripped a
@@ -323,6 +331,11 @@ export default function commandsExtension(pi: ExtensionAPI) {
       // command's override model.
       void pi.setModel(restore).catch(() => {})
     }
+    if (pendingEffortRestore) {
+      const level = pendingEffortRestore as Parameters<typeof pi.setThinkingLevel>[0]
+      pendingEffortRestore = undefined
+      pi.setThinkingLevel(level)
+    }
     if (pendingRestore) {
       pi.setActiveTools(pendingRestore)
       pendingRestore = undefined
@@ -404,6 +417,19 @@ export default function commandsExtension(pi: ExtensionAPI) {
     }
   }
 
+  /** Claude's `effort:` frontmatter overrides the thinking level for this run only, then
+   * the session level resumes; restore happens on agent_settled like the model restore.
+   * Applied before sendUserMessage so the run it drives happens at the new level. Only the
+   * first override in a turn records the restore target, so a second command restores to
+   * the original session level rather than the first command's override (as pendingModelRestore). */
+  function applyEffortOverride(parsed: ParsedCommand, varCtx: VarContext): void {
+    const target = parsed.effort
+    if (target && varCtx.thinkingLevel && target !== varCtx.thinkingLevel) {
+      pendingEffortRestore = pendingEffortRestore ?? varCtx.thinkingLevel
+      pi.setThinkingLevel(target as Parameters<typeof pi.setThinkingLevel>[0])
+    }
+  }
+
   async function runCommand(parsed: ParsedCommand, args: string, ctx: ExtensionCommandContext, filePath: string, plugin?: CommandPlugin): Promise<void> {
     const varCtx = ctx as unknown as VarContext
     const vars = commandVars(ctx, filePath, plugin)
@@ -435,6 +461,7 @@ export default function commandsExtension(pi: ExtensionAPI) {
     applyAllowedTools(parsed, vars)
     applyDisallowedTools(parsed)
     await applyModelOverride(parsed, varCtx)
+    applyEffortOverride(parsed, varCtx)
     pi.sendUserMessage(expanded)
   }
 
@@ -463,7 +490,11 @@ export default function commandsExtension(pi: ExtensionAPI) {
       discovered.set(command.name, command)
       // A user-only command stays off the tool description; it is still in the
       // map so a model attempt gets the explicit refusal, not "unknown command".
-      if (!parsed.disableModelInvocation) invocable.push({ name: command.name, description: parsed.description, argumentHint: parsed.argumentHint })
+      if (!parsed.disableModelInvocation) invocable.push({ name: command.name, description: parsed.description, argumentHint: parsed.argumentHint, whenToUse: parsed.whenToUse })
+      // user-invocable:false is the inverse of disable-model-invocation: the command is
+      // hidden from the user slash-command surface but stays in `discovered` and the tool
+      // description above, so the model can still run it through the slash_command tool.
+      if (!parsed.userInvocable) continue
       // pi has no unregister, so a command already registered this process keeps its
       // original file binding; re-registering would only add a numbered duplicate.
       if (registered.has(command.name)) continue