@carter-mcalister/pi-mise-toolchain 0.6.2

package/src/rewriters/package-manager.ts

@@ -0,0 +1,152 @@
+/**
+ * Package manager rewriter.
+ *
+ * Rewrites commands that use a non-selected package manager to use the
+ * selected one. Uses AST parsing for surgical string replacement at exact
+ * character positions to avoid corrupting arguments or strings.
+ *
+ * If AST parse fails, returns the command unchanged (no regex fallback
+ * for rewrites -- a false positive rewrite is worse than a missed one).
+ */
+
+import type { Program } from '@aliou/sh'
+import { parse } from '@aliou/sh'
+import type { ResolvedToolchainConfig } from '../config'
+import { walkCommands, wordToString } from '../utils/shell-utils'
+import type { Rewriter } from './types'
+
+type PackageManager = 'bun' | 'pnpm' | 'npm'
+
+const ALL_MANAGERS = new Set<string>(['bun', 'pnpm', 'npm', 'npx', 'yarn'])
+
+/** Maps npx-like commands to the selected manager's equivalent. */
+const NPX_EQUIVALENT: Record<PackageManager, string> = {
+  pnpm: 'pnpm dlx',
+  bun: 'bunx',
+  npm: 'npx',
+}
+
+interface Replacement {
+  /** Start character offset in the original command string. */
+  start: number
+  /** End character offset (exclusive) in the original command string. */
+  end: number
+  /** The replacement text. */
+  text: string
+}
+
+export function createPackageManagerRewriter(
+  config: ResolvedToolchainConfig,
+): Rewriter {
+  const selected = config.packageManager.selected
+
+  return (ctx) => {
+    let ast: Program
+    try {
+      ;({ ast } = parse(ctx.command))
+    } catch {
+      return { ctx, notices: [] }
+    }
+
+    const replacements: Replacement[] = []
+
+    walkCommands(ast, (cmd) => {
+      const firstWord = cmd.words?.[0]
+      if (!firstWord) return
+
+      const name = wordToString(firstWord)
+      if (!ALL_MANAGERS.has(name) || name === selected) return
+
+      // Get the literal part for position info. Only rewrite if the
+      // first part is a simple Literal (no expansions in command name).
+      const firstPart = firstWord.parts[0]
+      if (!firstPart || firstPart.type !== 'Literal') return
+
+      const literalValue = firstPart.value
+      // The word's position in the source is derived from the literal value.
+      // @aliou/sh doesn't expose source positions, so we find the command
+      // name in the source string. We search from after the last replacement
+      // to handle multiple commands.
+      const searchFrom =
+        replacements.length > 0
+          ? (replacements[replacements.length - 1] as Replacement).end
+          : 0
+
+      const idx = findCommandPosition(ctx.command, literalValue, searchFrom)
+      if (idx === -1) return
+
+      if (name === 'npx') {
+        replacements.push({
+          start: idx,
+          end: idx + literalValue.length,
+          text: NPX_EQUIVALENT[selected],
+        })
+      } else if (name === 'yarn') {
+        replacements.push({
+          start: idx,
+          end: idx + literalValue.length,
+          text: selected,
+        })
+      } else if (name !== selected) {
+        // npm, pnpm, or bun -> selected
+        replacements.push({
+          start: idx,
+          end: idx + literalValue.length,
+          text: selected,
+        })
+      }
+
+      return undefined
+    })
+
+    if (replacements.length === 0) return { ctx, notices: [] }
+
+    // Apply replacements from right to left so offsets remain valid.
+    let result = ctx.command
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const r = replacements[i] as Replacement
+      result = result.slice(0, r.start) + r.text + result.slice(r.end)
+    }
+
+    return {
+      ctx: { ...ctx, command: result },
+      notices:
+        result === ctx.command
+          ? []
+          : [{ message: `Rewrote command: ${ctx.command} -> ${result}` }],
+    }
+  }
+}
+
+/**
+ * Find the position of a command name in the source string, starting
+ * from `searchFrom`. Matches on word boundary to avoid matching inside
+ * paths or URLs.
+ */
+function findCommandPosition(
+  source: string,
+  name: string,
+  searchFrom: number,
+): number {
+  let pos = searchFrom
+  while (pos < source.length) {
+    const idx = source.indexOf(name, pos)
+    if (idx === -1) return -1
+
+    // Check word boundaries: char before must be start-of-string or
+    // a shell delimiter, char after must be end-of-string or delimiter.
+    const before = idx > 0 ? source[idx - 1] : undefined
+    const after =
+      idx + name.length < source.length ? source[idx + name.length] : undefined
+
+    const validBefore =
+      before === undefined || /[\s;|&(]/.test(before) || before === '\n'
+    const validAfter =
+      after === undefined || /[\s;|&)]/.test(after) || after === '\n'
+
+    if (validBefore && validAfter) return idx
+
+    pos = idx + 1
+  }
+  return -1
+}

package/src/rewriters/python.ts

@@ -0,0 +1,130 @@
+/**
+ * Python/pip rewriter.
+ *
+ * Rewrites python/pip commands to uv equivalents:
+ *   python script.py  -> uv run python script.py
+ *   python3 script.py -> uv run python3 script.py
+ *   pip install X     -> uv pip install X
+ *   pip3 install X    -> uv pip install X
+ *
+ * Does NOT rewrite poetry, pyenv, virtualenv -- those are blocked by
+ * the python-confirm blocker, not rewritten.
+ *
+ * If AST parse fails, returns the command unchanged (no regex fallback
+ * for rewrites).
+ */
+
+import type { Program } from '@aliou/sh'
+import { parse } from '@aliou/sh'
+import { walkCommands, wordToString } from '../utils/shell-utils'
+import type { Rewriter } from './types'
+
+const PYTHON_COMMANDS = new Set(['python', 'python3'])
+const PIP_COMMANDS = new Set(['pip', 'pip3'])
+
+interface Replacement {
+  start: number
+  end: number
+  text: string
+}
+
+export function createPythonRewriter(): Rewriter {
+  return (ctx) => {
+    let ast: Program
+    try {
+      ;({ ast } = parse(ctx.command))
+    } catch {
+      return { ctx, notices: [] }
+    }
+
+    const replacements: Replacement[] = []
+
+    walkCommands(ast, (cmd) => {
+      const firstWord = cmd.words?.[0]
+      if (!firstWord) return
+
+      const name = wordToString(firstWord)
+
+      const isPython = PYTHON_COMMANDS.has(name)
+      const isPip = PIP_COMMANDS.has(name)
+      if (!isPython && !isPip) return
+
+      const firstPart = firstWord.parts[0]
+      if (!firstPart || firstPart.type !== 'Literal') return
+
+      const literalValue = firstPart.value
+      const searchFrom =
+        replacements.length > 0
+          ? (replacements[replacements.length - 1] as Replacement).end
+          : 0
+
+      const idx = findCommandPosition(ctx.command, literalValue, searchFrom)
+      if (idx === -1) return
+
+      if (isPython) {
+        // python X -> uv run python X (prepend "uv run ")
+        replacements.push({
+          start: idx,
+          end: idx,
+          text: 'uv run ',
+        })
+      } else {
+        // pip X -> uv pip X (replace pip/pip3 with "uv pip")
+        replacements.push({
+          start: idx,
+          end: idx + literalValue.length,
+          text: 'uv pip',
+        })
+      }
+
+      return undefined
+    })
+
+    if (replacements.length === 0) return { ctx, notices: [] }
+
+    // Apply replacements from right to left so offsets remain valid.
+    let result = ctx.command
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const r = replacements[i] as Replacement
+      result = result.slice(0, r.start) + r.text + result.slice(r.end)
+    }
+
+    return {
+      ctx: { ...ctx, command: result },
+      notices:
+        result === ctx.command
+          ? []
+          : [{ message: `Rewrote command: ${ctx.command} -> ${result}` }],
+    }
+  }
+}
+
+/**
+ * Find the position of a command name in the source string, starting
+ * from `searchFrom`. Matches on word boundary.
+ */
+function findCommandPosition(
+  source: string,
+  name: string,
+  searchFrom: number,
+): number {
+  let pos = searchFrom
+  while (pos < source.length) {
+    const idx = source.indexOf(name, pos)
+    if (idx === -1) return -1
+
+    const before = idx > 0 ? source[idx - 1] : undefined
+    const after =
+      idx + name.length < source.length ? source[idx + name.length] : undefined
+
+    const validBefore =
+      before === undefined || /[\s;|&(]/.test(before) || before === '\n'
+    const validAfter =
+      after === undefined || /[\s;|&)]/.test(after) || after === '\n'
+
+    if (validBefore && validAfter) return idx
+
+    pos = idx + 1
+  }
+  return -1
+}

package/src/rewriters/types.ts

@@ -0,0 +1,12 @@
+import type { BashSpawnContext } from '@mariozechner/pi-coding-agent'
+
+export interface RewriteNotice {
+  message: string
+}
+
+export interface RewriteResult {
+  ctx: BashSpawnContext
+  notices: RewriteNotice[]
+}
+
+export type Rewriter = (ctx: BashSpawnContext) => RewriteResult

package/src/toolchain.test.ts

@@ -0,0 +1,322 @@
+import { describe, expect, it } from 'bun:test'
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent'
+import {
+  configLoader,
+  DEFAULT_CONFIG,
+  DEFAULT_EXTENSION_CONFIG,
+  findLegacyLocalConfigPath,
+  getIgnoredLegacyProjectSettingsWarning,
+  type ResolvedToolchainConfig,
+  resolveExtensionConfig,
+  resolveRuntimeConfig,
+  type ToolchainConfig,
+} from './config'
+import { registerBashIntegration } from './hooks/bash-integration'
+import {
+  hasRewriteFeatures,
+  registerRewriteNotifications,
+} from './hooks/rewrite-notifications'
+import {
+  DEFAULT_PROJECT_TOOLCHAIN_CONFIG,
+  findProjectToolchainConfig,
+} from './project-config'
+import {
+  BASH_SPAWN_HOOK_REQUEST_EVENT,
+  TOOLCHAIN_SPAWN_HOOK_CONTRIBUTOR_ID,
+} from './utils/bash-composition'
+import {
+  CURRENT_VERSION,
+  isMissingBashSourceMode,
+  migrateV0,
+} from './utils/migration'
+
+function createPiStub() {
+  const toolCallHandlers: Array<Parameters<ExtensionAPI['on']>[1]> = []
+  const eventHandlers = new Map<string, (data: unknown) => void>()
+  const registeredTools: unknown[] = []
+
+  const pi = {
+    on(eventName: string, handler: Parameters<ExtensionAPI['on']>[1]) {
+      if (eventName === 'tool_call') {
+        toolCallHandlers.push(handler)
+      }
+    },
+    registerTool(tool: unknown) {
+      registeredTools.push(tool)
+    },
+    events: {
+      on(eventName: string, handler: (data: unknown) => void) {
+        eventHandlers.set(eventName, handler)
+      },
+    },
+  } as unknown as ExtensionAPI
+
+  return { pi, toolCallHandlers, eventHandlers, registeredTools }
+}
+
+function withRuntimeConfig(
+  extensionConfig: ToolchainConfig,
+  projectConfig = DEFAULT_PROJECT_TOOLCHAIN_CONFIG,
+): ResolvedToolchainConfig {
+  return resolveRuntimeConfig(
+    resolveExtensionConfig(extensionConfig),
+    projectConfig,
+  )
+}
+
+describe('toolchain config', () => {
+  it('defaults bash.sourceMode to override-bash', () => {
+    const resolved = resolveExtensionConfig({})
+
+    expect(resolved.bash.sourceMode).toBe('override-bash')
+  })
+
+  it('rejects invalid bash.sourceMode', () => {
+    expect(() =>
+      resolveExtensionConfig({
+        bash: {
+          sourceMode: 'wrong-mode' as 'override-bash',
+        },
+      }),
+    ).toThrow(/bash\.sourceMode must be "override-bash" or "composed-bash"/)
+  })
+
+  it('migrateV0 handles legacy feature migration and leaves sourceMode to the dedicated migration', () => {
+    const migrated = migrateV0({
+      enabled: true,
+      features: {
+        enforcePackageManager: true as unknown as never,
+      },
+    })
+
+    expect(migrated.bash?.sourceMode).toBeUndefined()
+    expect(isMissingBashSourceMode(migrated)).toBe(true)
+    expect(migrated.version).toBe(CURRENT_VERSION)
+    expect(migrated.features?.enforcePackageManager).toBe('rewrite')
+  })
+
+  it('does not run missing-source-mode migration when sourceMode already exists', () => {
+    const config = {
+      version: '0.5.1-old',
+      bash: { sourceMode: 'composed-bash' },
+    } satisfies ToolchainConfig
+
+    expect(isMissingBashSourceMode(config)).toBe(false)
+    expect(resolveExtensionConfig(config).bash.sourceMode).toBe('composed-bash')
+  })
+
+  it('uses only global and memory scopes for JSON-backed settings', () => {
+    expect(configLoader.getEnabledScopes()).toEqual(['global', 'memory'])
+  })
+
+  it('warns when legacy JSON project toolchain settings are still present', () => {
+    expect(
+      getIgnoredLegacyProjectSettingsWarning({
+        features: { rewritePython: 'rewrite' },
+        packageManager: { selected: 'pnpm' },
+      }),
+    ).toMatch(/nearest mise\.toml/)
+
+    expect(
+      getIgnoredLegacyProjectSettingsWarning({
+        features: { gitRebaseEditor: 'rewrite' },
+      }),
+    ).toBeNull()
+  })
+
+  it('finds an ignored legacy local toolchain config in parent directories', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-local-config-'))
+    const nestedDir = join(root, 'packages', 'extension')
+    const legacyConfigPath = join(root, '.pi', 'extensions', 'toolchain.json')
+
+    await mkdir(join(root, '.pi', 'extensions'), { recursive: true })
+    await writeFile(legacyConfigPath, '{}\n')
+    await mkdir(nestedDir, { recursive: true })
+
+    expect(findLegacyLocalConfigPath(nestedDir)).toBe(legacyConfigPath)
+  })
+
+  it('DEFAULT_CONFIG keeps backward-compatible override-bash behavior', () => {
+    expect(DEFAULT_CONFIG.bash.sourceMode).toBe('override-bash')
+    expect(DEFAULT_EXTENSION_CONFIG.bash.sourceMode).toBe('override-bash')
+  })
+})
+
+describe('project toolchain config from mise.toml', () => {
+  it('derives python rewrite when mise.toml declares uv', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-mise-'))
+    await writeFile(join(root, 'mise.toml'), "[tools]\nuv = 'latest'\n")
+
+    const project = await findProjectToolchainConfig(root)
+
+    expect(project.features.rewritePython).toBe('rewrite')
+    expect(project.features.enforcePackageManager).toBe('disabled')
+    expect(project.packageManager.selected).toBeNull()
+  })
+
+  it('enables package-manager rewriting only when exactly one supported manager is declared', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-mise-'))
+    await writeFile(join(root, 'mise.toml'), "[tools]\npnpm = '10'\n")
+
+    const project = await findProjectToolchainConfig(root)
+
+    expect(project.features.enforcePackageManager).toBe('rewrite')
+    expect(project.packageManager.selected).toBe('pnpm')
+  })
+
+  it('disables package-manager rewriting when multiple managers are declared', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-mise-'))
+    await writeFile(
+      join(root, 'mise.toml'),
+      "[tools]\npnpm = '10'\nbun = '1'\n",
+    )
+
+    const project = await findProjectToolchainConfig(root)
+
+    expect(project.features.enforcePackageManager).toBe('disabled')
+    expect(project.packageManager.selected).toBeNull()
+  })
+
+  it('uses the nearest ancestor mise.toml', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-mise-'))
+    const nestedDir = join(root, 'packages', 'extension')
+
+    await writeFile(join(root, 'mise.toml'), "[tools]\npnpm = '10'\n")
+    await mkdir(nestedDir, { recursive: true })
+    await writeFile(join(nestedDir, 'mise.toml'), "[tools]\nbun = '1'\n")
+
+    const project = await findProjectToolchainConfig(join(nestedDir, 'src'))
+
+    expect(project.packageManager.selected).toBe('bun')
+    expect(project.features.enforcePackageManager).toBe('rewrite')
+  })
+
+  it('fails open when mise.toml is malformed', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'toolchain-mise-'))
+    await writeFile(join(root, 'mise.toml'), '[tools\nuv = ')
+
+    const project = await findProjectToolchainConfig(root)
+
+    expect(project.features.rewritePython).toBe('disabled')
+    expect(project.features.enforcePackageManager).toBe('disabled')
+    expect(project.packageManager.selected).toBeNull()
+  })
+})
+
+describe('toolchain bash integration', () => {
+  it('hasRewriteFeatures is false when no rewrite feature is enabled', () => {
+    const config = withRuntimeConfig({
+      features: {
+        gitRebaseEditor: 'disabled',
+      },
+    })
+
+    expect(hasRewriteFeatures(config)).toBe(false)
+  })
+
+  it('registers local bash in override-bash mode', () => {
+    const { pi, eventHandlers, registeredTools } = createPiStub()
+    const config = withRuntimeConfig(
+      {
+        bash: { sourceMode: 'override-bash' },
+      },
+      {
+        sourcePath: '/tmp/mise.toml',
+        features: {
+          enforcePackageManager: 'rewrite',
+          rewritePython: 'disabled',
+        },
+        packageManager: {
+          selected: 'pnpm',
+        },
+      },
+    )
+
+    registerBashIntegration(pi, config)
+
+    expect(registeredTools).toHaveLength(1)
+    expect(eventHandlers.has(BASH_SPAWN_HOOK_REQUEST_EVENT)).toBe(false)
+  })
+
+  it('contributes to composer in composed-bash mode', () => {
+    const { pi, eventHandlers, registeredTools } = createPiStub()
+    const config = withRuntimeConfig(
+      {
+        bash: { sourceMode: 'composed-bash' },
+      },
+      {
+        sourcePath: '/tmp/mise.toml',
+        features: {
+          enforcePackageManager: 'rewrite',
+          rewritePython: 'disabled',
+        },
+        packageManager: {
+          selected: 'pnpm',
+        },
+      },
+    )
+
+    registerBashIntegration(pi, config)
+
+    expect(registeredTools).toHaveLength(0)
+    const handler = eventHandlers.get(BASH_SPAWN_HOOK_REQUEST_EVENT)
+    expect(handler).toBeTypeOf('function')
+
+    const contributions: Array<{ id: string; spawnHook: unknown }> = []
+    handler?.({
+      register(contributor: { id: string; spawnHook: unknown }) {
+        contributions.push(contributor)
+      },
+    })
+
+    expect(contributions).toHaveLength(1)
+    expect(contributions[0]?.id).toBe(TOOLCHAIN_SPAWN_HOOK_CONTRIBUTOR_ID)
+    expect(contributions[0]?.spawnHook).toBeTypeOf('function')
+  })
+
+  it('rewrite notifications include source-mode prefix', async () => {
+    const { pi, toolCallHandlers } = createPiStub()
+    const config = withRuntimeConfig(
+      {
+        features: { gitRebaseEditor: 'rewrite' },
+        bash: { sourceMode: 'composed-bash' },
+        ui: { showRewriteNotifications: true },
+      },
+      {
+        sourcePath: '/tmp/mise.toml',
+        features: {
+          enforcePackageManager: 'disabled',
+          rewritePython: 'disabled',
+        },
+        packageManager: {
+          selected: null,
+        },
+      },
+    )
+
+    registerRewriteNotifications(pi, config)
+
+    expect(toolCallHandlers).toHaveLength(1)
+
+    const messages: string[] = []
+    await toolCallHandlers[0](
+      {
+        toolName: 'bash',
+        input: { command: 'git rebase -i HEAD~1' },
+      } as never,
+      {
+        ui: {
+          notify(message: string) {
+            messages.push(message)
+          },
+        },
+      } as never,
+    )
+
+    expect(messages).toHaveLength(1)
+    expect(messages[0] ?? '').toMatch(/^\[composed-bash\] /)
+  })
+})

package/src/utils/bash-composition.ts

@@ -0,0 +1,28 @@
+import type { BashSpawnContext } from '@mariozechner/pi-coding-agent'
+import type { BashSourceMode } from '../config'
+
+export const BASH_SPAWN_HOOK_REQUEST_EVENT = 'ad:bash:spawn-hook:request'
+export const TOOLCHAIN_SPAWN_HOOK_CONTRIBUTOR_ID = 'toolchain'
+export const TOOLCHAIN_SPAWN_HOOK_PRIORITY = 100
+
+export function formatRewriteSourcePrefix(sourceMode: BashSourceMode): string {
+  return `[${sourceMode}]`
+}
+
+export type SpawnHookContributor = {
+  id: string
+  priority?: number
+  spawnHook: (ctx: BashSpawnContext) => BashSpawnContext
+}
+
+export type SpawnHookRequestPayload = {
+  register: (contributor: SpawnHookContributor) => void
+}
+
+export function isSpawnHookRequestPayload(
+  value: unknown,
+): value is SpawnHookRequestPayload {
+  if (!value || typeof value !== 'object') return false
+  const v = value as Partial<SpawnHookRequestPayload>
+  return typeof v.register === 'function'
+}

package/src/utils/bash-source-mode.ts

@@ -0,0 +1,5 @@
+import type { BashSourceMode } from '../config'
+
+export function isValidBashSourceMode(value: unknown): value is BashSourceMode {
+  return value === 'override-bash' || value === 'composed-bash'
+}