pi-code 1.0.9 → 1.0.10

package/extensions/memory.ts

@@ -14,11 +14,12 @@ import * as path from 'node:path'
 import { StringEnum } from '@earendil-works/pi-ai'
 import { type ExtensionAPI, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
+import { claudeConfigDir } from './internal/config-dir.js'
 import { capForContext } from './internal/output-guard.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { findNearestFile, repoRoot } from './internal/project-root.js'
 
-const INDEX_FILE = 'MEMORY.md'
+export const INDEX_FILE = 'MEMORY.md'
 
 /** Claude loads the first 200 lines or 25KB of the memory index at startup. */
 export const INDEX_MAX_LINES = 200
@@ -282,7 +283,7 @@ function writeIndex(indexPath: string, content: string): void {
  * approved, since a project's `autoMemoryDirectory` is honored under the same trust
  * rule as hooks in settings files. Later files win. */
 export function memorySettingsFiles(cwd: string, home: string, approved: boolean): string[] {
-  const files = [path.join(home, '.claude', 'settings.json')]
+  const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (!approved) return files
   for (const name of ['settings.json', 'settings.local.json']) {
     files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))
@@ -306,6 +307,40 @@ export function readMemorySettings(files: string[]): { autoMemoryEnabled?: unkno
   return merged
 }
 
+/** Write `autoMemoryEnabled` into the user settings file, preserving every other key
+ * and creating the file and its config directory when absent. Claude's /memory toggle
+ * writes to the user scope (relocated by CLAUDE_CONFIG_DIR); the value takes effect from
+ * the next session start, which is where autoMemoryEnabled is read.
+ *
+ * An absent file starts from an empty object so the toggle still lands. A file that is
+ * PRESENT but unparseable is refused, not overwritten: clobbering it would destroy the
+ * user's hooks, env and permissions config. The caller surfaces the returned failure. */
+export function setAutoMemoryEnabledSetting(home: string, value: boolean): { ok: true } | { ok: false; error: string } {
+  const dir = claudeConfigDir(home)
+  const file = path.join(dir, 'settings.json')
+  let current: Record<string, unknown> = {}
+  let raw: string | undefined
+  try {
+    raw = fs.readFileSync(file, 'utf-8')
+  } catch (error) {
+    // Only a missing file means start fresh; any other read failure propagates.
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+  }
+  if (raw !== undefined) {
+    try {
+      const parsed = JSON.parse(raw)
+      if (parsed !== null && typeof parsed === 'object') current = parsed as Record<string, unknown>
+    } catch {
+      // Present but unparseable: refuse rather than overwrite the user's config.
+      return { ok: false, error: 'settings.json is not valid JSON; not modified' }
+    }
+  }
+  current.autoMemoryEnabled = value
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(file, `${JSON.stringify(current, null, 2)}\n`)
+  return { ok: true }
+}
+
 export default function memoryExtension(pi: ExtensionAPI) {
   let dir = memoryDir(process.cwd())
   let enabled = true
@@ -409,4 +444,53 @@ export default function memoryExtension(pi: ExtensionAPI) {
       return { content: [{ type: 'text' as const, text: index.trim() || 'No memories saved for this project yet.' }], details: {} }
     },
   })
+
+  // Claude's /memory lists the memory locations and toggles auto memory. pi has no
+  // editor seam, so the paths are printed rather than opened. The listing reads the
+  // settings chain live so it reflects a toggle written in the same session.
+  pi.registerCommand('memory', {
+    description: 'Show memory file locations and toggle auto memory (/memory [on|off])',
+    handler: async (args, ctx) => {
+      const home = os.homedir()
+      const arg = args.trim().toLowerCase()
+
+      if (arg === 'on' || arg === 'off') {
+        const next = arg === 'on'
+        let result: { ok: true } | { ok: false; error: string }
+        try {
+          result = setAutoMemoryEnabledSetting(home, next)
+        } catch (error) {
+          ctx.ui.notify(`Could not update auto memory: ${error instanceof Error ? error.message : String(error)}`, 'error')
+          return
+        }
+        if (!result.ok) {
+          ctx.ui.notify(result.error, 'error')
+          return
+        }
+        ctx.ui.notify(`Auto memory ${next ? 'enabled' : 'disabled'} in ${path.join(claudeConfigDir(home), 'settings.json')} (applies next session).`, 'info')
+        return
+      }
+
+      if (arg.length > 0) {
+        ctx.ui.notify('Usage: /memory [on|off]', 'error')
+        return
+      }
+
+      const approved = isProjectApprovedSilently(ctx)
+      const settings = readMemorySettings(memorySettingsFiles(ctx.cwd, home, approved))
+      const isEnabled = autoMemoryEnabled(settings.autoMemoryEnabled, process.env)
+      const override = typeof settings.autoMemoryDirectory === 'string' ? settings.autoMemoryDirectory : undefined
+      const store = resolveMemoryDir(ctx.cwd, override)
+      const lines = [
+        'Memory',
+        `  Auto memory: ${isEnabled ? 'on' : 'off'}`,
+        `  Store:       ${store}`,
+        `  Index:       ${path.join(store, INDEX_FILE)}`,
+        `  User memory (CLAUDE.md):    ${path.join(home, '.claude', 'CLAUDE.md')}`,
+        `  Project memory (CLAUDE.md): ${path.join(ctx.cwd, 'CLAUDE.md')}`,
+        'Toggle with /memory on or /memory off.',
+      ]
+      ctx.ui.notify(lines.join('\n'), 'info')
+    },
+  })
 }

package/extensions/notify.ts

@@ -21,6 +21,8 @@ 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'
+
 /** How a finished turn is announced, from Claude's `preferredNotifChannel`. */
 export type NotifChannel = 'desktop' | 'bell' | 'both' | 'off'
 
@@ -55,7 +57,7 @@ export function isAway(lastInputAt: number | undefined, now: number, thresholdMs
  * or change your notifications. */
 function readPreferredNotifChannel(home: string): unknown {
   try {
-    const settings = JSON.parse(fs.readFileSync(path.join(home, '.claude', 'settings.json'), 'utf-8'))
+    const settings = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(home), 'settings.json'), 'utf-8'))
     return settings?.preferredNotifChannel
   } catch {
     return undefined

package/extensions/output-styles.ts

@@ -24,6 +24,7 @@ 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 { installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { findNearestDir, findNearestFile } from './internal/project-root.js'
@@ -82,7 +83,7 @@ function isDirectory(target: string): boolean {
  * verbatim into the system prompt.
  */
 export function styleDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const dirs = [path.join(home, '.claude', 'output-styles')]
+  const dirs = [path.join(claudeConfigDir(home), 'output-styles')]
   if (trusted) dirs.push(findNearestDir(cwd, path.join('.claude', 'output-styles')) ?? path.join(cwd, '.claude', 'output-styles'))
   return dirs.filter((dir) => isDirectory(dir))
 }
@@ -129,7 +130,7 @@ export function loadStyles(dirs: string[]): OutputStyle[] {
 /** Settings files that carry `outputStyle`. Project settings apply only when trusted,
  * each the nearest of its name at or above cwd, as the hooks settings chain reads. */
 export function settingsFiles(cwd: string, home: string, trusted: boolean): string[] {
-  const files = [path.join(home, '.claude', 'settings.json')]
+  const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (!trusted) return files
   for (const name of ['settings.json', 'settings.local.json']) {
     files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))

package/extensions/skills.ts

@@ -15,6 +15,7 @@ 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 { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { findNearestDir } from './internal/project-root.js'
@@ -33,7 +34,7 @@ function isDirectory(target: string): boolean {
  * name and description to the model, so an untrusted repository would otherwise get
  * text into the prompt without the user ever agreeing to load its config. */
 export function skillDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(home, '.claude', 'skills')]
+  const candidates = [path.join(claudeConfigDir(home), 'skills')]
   // Enabled plugins contribute their skills directories. pi's loader names a
   // skill by its directory, so a plugin skill registers without Claude's
   // /plugin: prefix; a rename-free approximation, disclosed in the README.

package/extensions/subagent/agents.ts

@@ -11,6 +11,7 @@ import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works
 // Claude field, and `--tools` is an exact-name allowlist, so a name pi has no tool for
 // is not merely ignored, it narrows the child's registry.
 import { parseToolGrants } from '../internal/command-file.js'
+import { claudeConfigDir } from '../internal/config-dir.js'
 import { installedPlugins } from '../internal/plugins.js'
 import { findNearestDir } from '../internal/project-root.js'
 
@@ -291,7 +292,7 @@ function pluginAgentDirs(home: string): string[] {
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents')
-  const claudeUserDir = path.join(os.homedir(), '.claude', 'agents')
+  const claudeUserDir = path.join(claudeConfigDir(os.homedir()), 'agents')
   const projectPiDir = findNearestDir(cwd, path.join('.pi', 'agents'))
   const projectClaudeDir = findNearestDir(cwd, path.join('.claude', 'agents'))
 

package/extensions/subagent/index.ts

@@ -24,6 +24,7 @@ import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme, type Theme,
 import { Container, Markdown, Spacer, Text } from '@earendil-works/pi-tui'
 import { type Static, Type } from 'typebox'
 import { type AgentRunRequest, setAgentRunner } from '../internal/agent-run.js'
+import { claudeConfigDir } from '../internal/config-dir.js'
 import { capForContext } from '../internal/output-guard.js'
 import { isProjectApproved, isProjectApprovedSilently } from '../internal/project-approval.js'
 import { repoRoot } from '../internal/project-root.js'
@@ -697,7 +698,7 @@ export function agentMemoryDir(scope: AgentMemoryScope, name: string, cwd: strin
   const sanitized = name.replace(/[^\w.-]+/g, '_')
   // A name of only dots ('.', '..') survives the character filter but still traverses.
   const segment = /^\.+$/.test(sanitized) ? '_' : sanitized
-  if (scope === 'user') return path.join(home, '.claude', 'agent-memory', segment)
+  if (scope === 'user') return path.join(claudeConfigDir(home), 'agent-memory', segment)
   const root = repoRoot(cwd) ?? cwd
   return path.join(root, '.claude', scope === 'project' ? 'agent-memory' : 'agent-memory-local', segment)
 }

package/extensions/thinking.ts

@@ -0,0 +1,80 @@
+/**
+ * Thinking Keyword Escalation
+ *
+ * Claude Code raises reasoning effort for a single turn when the prompt carries a
+ * think keyword: `ultrathink` asks for the maximum, `think hard`/`think harder` for
+ * a high level, and a bare `think` for a medium one. The word stays in the prompt
+ * (the input is observed, never consumed or transformed), the escalation only ever
+ * raises the level, and the prior level is restored once the turn settles, mirroring
+ * how commands.ts restores a per-command model override on agent_settled.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+// The pi ThinkingLevel union, taken from the setter's parameter so it tracks the SDK.
+type ThinkingLevel = Parameters<ExtensionAPI['setThinkingLevel']>[0]
+
+/** Lowest to highest, matching pi's ThinkingLevel union; rank is the index. */
+const THINKING_ORDER: readonly ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+
+export function thinkingRank(level: ThinkingLevel): number {
+  const i = THINKING_ORDER.indexOf(level)
+  return Math.max(i, 0)
+}
+
+/** The reasoning level a prompt requests through Claude's think keywords, or undefined
+ * when it names none. Checked most-specific first so `think harder` does not fall
+ * through to the bare-`think` branch, and on word boundaries so `rethink`/`thinking`
+ * and the whole word `ultrathink` never trip the bare match. */
+export function requestedThinkingLevel(text: string): ThinkingLevel | undefined {
+  if (/\bultrathink\b/i.test(text)) return 'max'
+  if (/\bthink harder\b/i.test(text) || /\bthink hard\b/i.test(text)) return 'high'
+  if (/\bthink\b/i.test(text)) return 'medium'
+  return undefined
+}
+
+export default function thinkingExtension(pi: ExtensionAPI) {
+  // The level to restore once the escalated turn settles, captured the first time a
+  // turn escalates so back-to-back keywords in one turn still restore the original.
+  // Cleared on agent_settled, the run's true end past any retry/compaction/Stop
+  // continuation, the same clearing point commands.ts uses for its model override.
+  let pendingRestore: ThinkingLevel | undefined
+  // The level this extension last escalated to. The restore is conditional on the level
+  // still being this target at settle: commands.ts also restores an `effort:` override
+  // on agent_settled, so both fire on the same event. Keying the restore on the target
+  // makes the outcome order-independent: if a command's restore (or a manual change)
+  // already moved the level, thinking stands down instead of clobbering it.
+  let pendingTarget: ThinkingLevel | undefined
+
+  pi.on('input', (event, ctx) => {
+    // Only genuine user input escalates. sendUserMessage emits an input event with
+    // source 'extension' (a subagent prompt, a command body replayed through it); a
+    // think keyword the user did not type must not escalate, mirroring hooks.ts's guard.
+    if (event.source === 'extension') return
+    const target = requestedThinkingLevel(event.text)
+    if (!target) return
+    const current = pi.getThinkingLevel?.() ?? ctx.thinkingLevel ?? 'off'
+    // A keyword only raises reasoning: leave a level already at or above the target.
+    if (thinkingRank(current) >= thinkingRank(target)) return
+    pendingRestore = pendingRestore ?? current
+    pendingTarget = target
+    pi.setThinkingLevel?.(target)
+    // Return nothing so the input is neither consumed nor transformed: Claude keeps
+    // the keyword in the prompt.
+  })
+
+  pi.on('agent_settled', () => {
+    if (pendingRestore === undefined) return
+    const restore = pendingRestore
+    const target = pendingTarget
+    pendingRestore = undefined
+    pendingTarget = undefined
+    // Restore only if nothing else moved the level since this extension set it. If a
+    // command's effort restore or the user's manual change already took over (current
+    // no longer equals our target), leave that value in place and stand down. When the
+    // level cannot be read, restore unconditionally, the prior best-effort behavior.
+    const current = pi.getThinkingLevel?.()
+    if (current !== undefined && current !== target) return
+    pi.setThinkingLevel?.(restore)
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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",