@carter-mcalister/pi-mise-toolchain 0.6.2

package/src/config.ts

@@ -0,0 +1,325 @@
+import { existsSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, resolve } from 'node:path'
+import { ConfigLoader, type Migration } from '@aliou/pi-utils-settings'
+import { DEFAULT_PROJECT_TOOLCHAIN_CONFIG } from './project-config'
+import { isValidBashSourceMode } from './utils/bash-source-mode'
+import {
+  isMissingBashSourceMode,
+  isV0,
+  migrateMissingBashSourceMode,
+  migrateV0,
+  pendingWarnings,
+} from './utils/migration'
+
+/**
+ * Configuration schema for the toolchain extension.
+ *
+ * ToolchainConfig is the JSON-backed user-facing schema (all fields optional).
+ * ResolvedExtensionConfig is the JSON-backed internal schema.
+ * ResolvedToolchainConfig is the final runtime schema after overlaying project
+ * toolchain settings derived from mise.toml.
+ *
+ * Feature modes:
+ * - "disabled": feature is off
+ * - "rewrite": transparently rewrite matching commands via spawn hook
+ * - "block": block matching commands via tool_call hook (bash tool not overridden)
+ */
+
+export type FeatureMode = 'disabled' | 'rewrite' | 'block'
+export type BashSourceMode = 'override-bash' | 'composed-bash'
+export type PackageManager = 'bun' | 'pnpm' | 'npm'
+
+export interface ToolchainConfig {
+  version?: string
+  enabled?: boolean
+  features?: {
+    enforcePackageManager?: FeatureMode
+    rewritePython?: FeatureMode
+    gitRebaseEditor?: FeatureMode
+  }
+  packageManager?: {
+    selected?: PackageManager
+  }
+  bash?: {
+    sourceMode?: BashSourceMode
+  }
+  ui?: {
+    showRewriteNotifications?: boolean
+  }
+}
+
+export interface ProjectToolchainConfig {
+  sourcePath: string | null
+  features: {
+    enforcePackageManager: FeatureMode
+    rewritePython: FeatureMode
+  }
+  packageManager: {
+    selected: PackageManager | null
+  }
+}
+
+export interface ResolvedExtensionConfig {
+  enabled: boolean
+  features: {
+    gitRebaseEditor: FeatureMode
+  }
+  bash: {
+    sourceMode: BashSourceMode
+  }
+  ui: {
+    showRewriteNotifications: boolean
+  }
+}
+
+export interface ResolvedToolchainConfig {
+  enabled: boolean
+  features: {
+    enforcePackageManager: FeatureMode
+    rewritePython: FeatureMode
+    gitRebaseEditor: FeatureMode
+  }
+  packageManager: {
+    selected: PackageManager
+  }
+  bash: {
+    sourceMode: BashSourceMode
+  }
+  ui: {
+    showRewriteNotifications: boolean
+  }
+}
+
+export const DEFAULT_EXTENSION_CONFIG: ResolvedExtensionConfig = {
+  enabled: true,
+  features: {
+    gitRebaseEditor: 'rewrite',
+  },
+  bash: {
+    sourceMode: 'override-bash',
+  },
+  ui: {
+    showRewriteNotifications: false,
+  },
+}
+
+export const DEFAULT_CONFIG: ResolvedToolchainConfig = {
+  enabled: DEFAULT_EXTENSION_CONFIG.enabled,
+  features: {
+    enforcePackageManager:
+      DEFAULT_PROJECT_TOOLCHAIN_CONFIG.features.enforcePackageManager,
+    rewritePython: DEFAULT_PROJECT_TOOLCHAIN_CONFIG.features.rewritePython,
+    gitRebaseEditor: DEFAULT_EXTENSION_CONFIG.features.gitRebaseEditor,
+  },
+  packageManager: {
+    selected:
+      DEFAULT_PROJECT_TOOLCHAIN_CONFIG.packageManager.selected ?? 'pnpm',
+  },
+  bash: {
+    sourceMode: DEFAULT_EXTENSION_CONFIG.bash.sourceMode,
+  },
+  ui: {
+    showRewriteNotifications:
+      DEFAULT_EXTENSION_CONFIG.ui.showRewriteNotifications,
+  },
+}
+
+export const IGNORED_PROJECT_SETTINGS_WARNING =
+  '[toolchain] Ignoring legacy toolchain.json project settings for package-manager and Python rewrites. These settings now come from the nearest mise.toml.'
+
+let hasQueuedIgnoredProjectSettingsWarning = false
+let hasQueuedIgnoredLocalConfigWarning = false
+
+const migrations: Migration<ToolchainConfig>[] = [
+  {
+    name: 'v0-to-current',
+    shouldRun: (config) => isV0(config),
+    run: (config) => migrateV0(config),
+  },
+  {
+    name: 'add-bash-source-mode',
+    shouldRun: (config) => isMissingBashSourceMode(config),
+    run: (config) => migrateMissingBashSourceMode(config),
+  },
+]
+
+function deepMerge(target: object, source: object): void {
+  const t = target as Record<string, unknown>
+  const s = source as Record<string, unknown>
+
+  for (const key in s) {
+    if (s[key] === undefined) continue
+    if (
+      typeof s[key] === 'object' &&
+      !Array.isArray(s[key]) &&
+      s[key] !== null
+    ) {
+      if (!t[key] || typeof t[key] !== 'object') t[key] = {}
+      deepMerge(t[key] as object, s[key] as object)
+    } else {
+      t[key] = s[key]
+    }
+  }
+}
+
+function mergeToolchainConfigs(
+  ...configs: Array<ToolchainConfig | null | undefined>
+): ToolchainConfig {
+  const merged: ToolchainConfig = {}
+
+  for (const config of configs) {
+    if (config) {
+      deepMerge(merged, config)
+    }
+  }
+
+  return merged
+}
+
+export function getIgnoredLegacyProjectSettingsWarning(
+  config: ToolchainConfig | null | undefined,
+): string | null {
+  const hasLegacyProjectSettings =
+    config?.features?.enforcePackageManager !== undefined ||
+    config?.features?.rewritePython !== undefined ||
+    config?.packageManager?.selected !== undefined
+
+  return hasLegacyProjectSettings ? IGNORED_PROJECT_SETTINGS_WARNING : null
+}
+
+function queueIgnoredLegacyProjectSettingsWarning(
+  config: ToolchainConfig | null | undefined,
+): void {
+  if (hasQueuedIgnoredProjectSettingsWarning) return
+
+  const warning = getIgnoredLegacyProjectSettingsWarning(config)
+  if (!warning) return
+
+  pendingWarnings.push(warning)
+  hasQueuedIgnoredProjectSettingsWarning = true
+}
+
+export function findLegacyLocalConfigPath(
+  startDir = process.cwd(),
+): string | null {
+  let dir = startDir
+  const home = homedir()
+
+  while (true) {
+    if (dir === home) return null
+
+    const candidate = resolve(dir, '.pi/extensions/toolchain.json')
+    if (existsSync(candidate) && statSync(candidate).isFile()) {
+      return candidate
+    }
+
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+export function queueIgnoredLegacyLocalConfigWarning(
+  startDir = process.cwd(),
+): void {
+  if (hasQueuedIgnoredLocalConfigWarning) return
+
+  const path = findLegacyLocalConfigPath(startDir)
+  if (!path) return
+
+  pendingWarnings.push(
+    `[toolchain] Ignoring legacy project config at ${path}. Project package-manager and Python rewrites now come from the nearest mise.toml.`,
+  )
+  hasQueuedIgnoredLocalConfigWarning = true
+}
+
+function validateResolvedExtensionConfig(
+  config: ResolvedExtensionConfig,
+): ResolvedExtensionConfig {
+  if (!isValidBashSourceMode(config.bash.sourceMode)) {
+    throw new Error(
+      '[toolchain] Invalid config: bash.sourceMode must be "override-bash" or "composed-bash"',
+    )
+  }
+
+  return config
+}
+
+function validateResolvedConfig(
+  config: ResolvedToolchainConfig,
+): ResolvedToolchainConfig {
+  validateResolvedExtensionConfig({
+    enabled: config.enabled,
+    features: {
+      gitRebaseEditor: config.features.gitRebaseEditor,
+    },
+    bash: config.bash,
+    ui: config.ui,
+  })
+
+  return config
+}
+
+export function resolveExtensionConfig(
+  config: ToolchainConfig | null | undefined,
+): ResolvedExtensionConfig {
+  return validateResolvedExtensionConfig({
+    enabled: config?.enabled ?? DEFAULT_EXTENSION_CONFIG.enabled,
+    features: {
+      gitRebaseEditor:
+        config?.features?.gitRebaseEditor ??
+        DEFAULT_EXTENSION_CONFIG.features.gitRebaseEditor,
+    },
+    bash: {
+      sourceMode:
+        config?.bash?.sourceMode ?? DEFAULT_EXTENSION_CONFIG.bash.sourceMode,
+    },
+    ui: {
+      showRewriteNotifications:
+        config?.ui?.showRewriteNotifications ??
+        DEFAULT_EXTENSION_CONFIG.ui.showRewriteNotifications,
+    },
+  })
+}
+
+export function resolveRuntimeConfig(
+  extensionConfig: ResolvedExtensionConfig,
+  projectConfig: ProjectToolchainConfig = DEFAULT_PROJECT_TOOLCHAIN_CONFIG,
+): ResolvedToolchainConfig {
+  return validateResolvedConfig({
+    enabled: extensionConfig.enabled,
+    features: {
+      enforcePackageManager: projectConfig.features.enforcePackageManager,
+      rewritePython: projectConfig.features.rewritePython,
+      gitRebaseEditor: extensionConfig.features.gitRebaseEditor,
+    },
+    packageManager: {
+      selected:
+        projectConfig.packageManager.selected ??
+        DEFAULT_CONFIG.packageManager.selected,
+    },
+    bash: extensionConfig.bash,
+    ui: extensionConfig.ui,
+  })
+}
+
+/** @deprecated Use resolveExtensionConfig for JSON-backed settings or resolveRuntimeConfig for final runtime config. */
+export function resolveToolchainConfig(
+  config: ToolchainConfig | null | undefined,
+): ResolvedExtensionConfig {
+  return resolveExtensionConfig(config)
+}
+
+export const configLoader = new ConfigLoader<
+  ToolchainConfig,
+  ResolvedExtensionConfig
+>('toolchain', DEFAULT_EXTENSION_CONFIG, {
+  scopes: ['global', 'memory'],
+  migrations,
+  afterMerge: (_resolved, global, _local, memory) => {
+    const merged = mergeToolchainConfigs(global, memory)
+    queueIgnoredLegacyProjectSettingsWarning(merged)
+    return resolveExtensionConfig(merged)
+  },
+})

package/src/hooks/bash-integration.ts

@@ -0,0 +1,35 @@
+import {
+  createBashTool,
+  type ExtensionAPI,
+} from '@mariozechner/pi-coding-agent'
+import type { ResolvedToolchainConfig } from '../config'
+import { createSpawnHook } from '../rewriters'
+import {
+  BASH_SPAWN_HOOK_REQUEST_EVENT,
+  isSpawnHookRequestPayload,
+  TOOLCHAIN_SPAWN_HOOK_CONTRIBUTOR_ID,
+  TOOLCHAIN_SPAWN_HOOK_PRIORITY,
+} from '../utils/bash-composition'
+
+export function registerBashIntegration(
+  pi: ExtensionAPI,
+  config: ResolvedToolchainConfig,
+): void {
+  const spawnHook = createSpawnHook(config)
+
+  if (config.bash.sourceMode === 'composed-bash') {
+    pi.events.on(BASH_SPAWN_HOOK_REQUEST_EVENT, (data: unknown) => {
+      if (!isSpawnHookRequestPayload(data)) return
+
+      data.register({
+        id: TOOLCHAIN_SPAWN_HOOK_CONTRIBUTOR_ID,
+        priority: TOOLCHAIN_SPAWN_HOOK_PRIORITY,
+        spawnHook,
+      })
+    })
+    return
+  }
+
+  const bashTool = createBashTool(process.cwd(), { spawnHook })
+  pi.registerTool({ ...bashTool })
+}

package/src/hooks/rewrite-notifications.ts

@@ -0,0 +1,42 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent'
+import type { ResolvedToolchainConfig } from '../config'
+import { analyzeRewrite } from '../rewriters'
+import { formatRewriteSourcePrefix } from '../utils/bash-composition'
+
+export function registerRewriteNotifications(
+  pi: ExtensionAPI,
+  config: ResolvedToolchainConfig,
+): void {
+  if (!config.ui.showRewriteNotifications) return
+
+  pi.on('tool_call', async (event, ctx) => {
+    if (event.toolName !== 'bash') return
+
+    const command = String(event.input.command ?? '')
+    if (!command) return
+
+    const rewriteResult = analyzeRewrite(
+      {
+        command,
+        cwd: process.cwd(),
+        env: process.env,
+      },
+      config,
+    )
+
+    const prefix = formatRewriteSourcePrefix(config.bash.sourceMode)
+    for (const notice of rewriteResult.notices) {
+      ctx.ui.notify(`${prefix} ${notice.message}`, 'warning')
+    }
+
+    return undefined
+  })
+}
+
+export function hasRewriteFeatures(config: ResolvedToolchainConfig): boolean {
+  return (
+    config.features.enforcePackageManager === 'rewrite' ||
+    config.features.rewritePython === 'rewrite' ||
+    config.features.gitRebaseEditor === 'rewrite'
+  )
+}

package/src/hooks/session-start.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent'
+import { pendingWarnings } from '../utils/migration'
+
+export function registerSessionStartWarnings(pi: ExtensionAPI): void {
+  pi.on('session_start', (_event, ctx) => {
+    for (const warning of pendingWarnings.splice(0)) {
+      ctx.ui.notify(warning, 'warning')
+    }
+  })
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent'
+import { setupBlockers } from './blockers'
+import { registerToolchainSettings } from './commands/settings-command'
+import {
+  configLoader,
+  queueIgnoredLegacyLocalConfigWarning,
+  resolveRuntimeConfig,
+} from './config'
+import { registerBashIntegration } from './hooks/bash-integration'
+import {
+  hasRewriteFeatures,
+  registerRewriteNotifications,
+} from './hooks/rewrite-notifications'
+import { registerSessionStartWarnings } from './hooks/session-start'
+import { findProjectToolchainConfig } from './project-config'
+
+/**
+ * Toolchain Extension
+ *
+ * Enforces opinionated toolchain preferences per feature, each independently
+ * set to one of three modes:
+ *
+ * - "disabled": no action taken
+ * - "rewrite": transparently rewrite matching commands via spawn hook
+ * - "block": block commands via tool_call hook
+ *
+ * Configuration:
+ * - Global settings: ~/.pi/agent/extensions/toolchain.json
+ * - Memory settings: session-only overrides via /toolchain:settings
+ * - Project toolchain: nearest mise.toml
+ */
+export default async function (pi: ExtensionAPI) {
+  queueIgnoredLegacyLocalConfigWarning()
+  await configLoader.load()
+  const extensionConfig = configLoader.getConfig()
+  const projectConfig = await findProjectToolchainConfig()
+  const config = resolveRuntimeConfig(extensionConfig, projectConfig)
+  if (!config.enabled) return
+
+  registerToolchainSettings(pi)
+  registerSessionStartWarnings(pi)
+  setupBlockers(pi, config)
+  registerRewriteNotifications(pi, config)
+
+  if (!hasRewriteFeatures(config)) return
+  registerBashIntegration(pi, config)
+}

package/src/project-config.ts

@@ -0,0 +1,98 @@
+import { existsSync, statSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { parse as parseToml } from '@iarna/toml'
+import type { PackageManager, ProjectToolchainConfig } from './config'
+
+const SUPPORTED_PACKAGE_MANAGERS: PackageManager[] = ['bun', 'pnpm', 'npm']
+
+export const DEFAULT_PROJECT_TOOLCHAIN_CONFIG: ProjectToolchainConfig = {
+  sourcePath: null,
+  features: {
+    enforcePackageManager: 'disabled',
+    rewritePython: 'disabled',
+  },
+  packageManager: {
+    selected: null,
+  },
+}
+
+function createDefaultProjectToolchainConfig(): ProjectToolchainConfig {
+  return structuredClone(DEFAULT_PROJECT_TOOLCHAIN_CONFIG)
+}
+
+function findNearestMiseTomlPath(startDir: string): string | null {
+  let dir = startDir
+  const home = homedir()
+
+  while (true) {
+    if (dir === home) return null
+
+    const candidate = join(dir, 'mise.toml')
+    if (existsSync(candidate) && statSync(candidate).isFile()) {
+      return candidate
+    }
+
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+function getToolsTable(parsed: unknown): Record<string, unknown> {
+  if (!parsed || typeof parsed !== 'object') return {}
+
+  const tools = (parsed as { tools?: unknown }).tools
+  if (!tools || typeof tools !== 'object' || Array.isArray(tools)) {
+    return {}
+  }
+
+  return tools as Record<string, unknown>
+}
+
+function hasTool(tools: Record<string, unknown>, name: string): boolean {
+  return Object.hasOwn(tools, name)
+}
+
+function deriveProjectToolchainConfig(
+  sourcePath: string,
+  rawConfig: string,
+): ProjectToolchainConfig {
+  const parsed = parseToml(rawConfig)
+  const tools = getToolsTable(parsed)
+  const hasUv = hasTool(tools, 'uv')
+  const packageManagers = SUPPORTED_PACKAGE_MANAGERS.filter((manager) =>
+    hasTool(tools, manager),
+  )
+
+  return {
+    sourcePath,
+    features: {
+      rewritePython: hasUv ? 'rewrite' : 'disabled',
+      enforcePackageManager:
+        packageManagers.length === 1 ? 'rewrite' : 'disabled',
+    },
+    packageManager: {
+      selected: packageManagers.length === 1 ? packageManagers[0] : null,
+    },
+  }
+}
+
+export async function findProjectToolchainConfig(
+  startDir = process.cwd(),
+): Promise<ProjectToolchainConfig> {
+  const sourcePath = findNearestMiseTomlPath(startDir)
+  if (!sourcePath) {
+    return createDefaultProjectToolchainConfig()
+  }
+
+  try {
+    const rawConfig = await readFile(sourcePath, 'utf8')
+    return deriveProjectToolchainConfig(sourcePath, rawConfig)
+  } catch {
+    const fallback = createDefaultProjectToolchainConfig()
+    fallback.sourcePath = sourcePath
+    return fallback
+  }
+}

package/src/rewriters/git-rebase.ts

@@ -0,0 +1,75 @@
+/**
+ * Git rebase editor rewriter.
+ *
+ * Injects GIT_EDITOR and GIT_SEQUENCE_EDITOR env vars for git rebase
+ * commands so they run non-interactively without opening an editor.
+ *
+ * - GIT_EDITOR=true: prevents commit message editor (rebase --continue)
+ * - GIT_SEQUENCE_EDITOR=: accepts default rebase sequence (interactive rebase)
+ *
+ * Skips injection if the command already has editor configuration via
+ * AST assignments or existing env vars.
+ */
+
+import { parse } from '@aliou/sh'
+import { walkCommandsWithAssignments, wordToString } from '../utils/shell-utils'
+import type { Rewriter } from './types'
+
+export function createGitRebaseRewriter(): Rewriter {
+  return (ctx) => {
+    let needsEditor = false
+
+    try {
+      const { ast } = parse(ctx.command)
+
+      walkCommandsWithAssignments(ast, (cmd, assignments) => {
+        const words = (cmd.words ?? []).map(wordToString)
+        if (words[0] !== 'git' || words[1] !== 'rebase') return
+
+        // Skip if already configured via inline assignments
+        if (hasEditorAssignment(assignments)) return
+
+        needsEditor = true
+        return true
+      })
+    } catch {
+      // Fallback: check raw string for git rebase pattern
+      if (/\bgit\s+rebase\b/.test(ctx.command)) {
+        // Skip if already has editor config
+        if (!/GIT_SEQUENCE_EDITOR|GIT_EDITOR|core\.editor/.test(ctx.command)) {
+          needsEditor = true
+        }
+      }
+    }
+
+    if (!needsEditor) return { ctx, notices: [] }
+
+    // Skip if env vars already set in the context
+    if (ctx.env.GIT_EDITOR || ctx.env.GIT_SEQUENCE_EDITOR) {
+      return { ctx, notices: [] }
+    }
+
+    return {
+      ctx: {
+        ...ctx,
+        env: {
+          ...ctx.env,
+          GIT_EDITOR: 'true',
+          GIT_SEQUENCE_EDITOR: ':',
+        },
+      },
+      notices: [
+        {
+          message:
+            'Rewrote command behavior: injected GIT_EDITOR=true and GIT_SEQUENCE_EDITOR=: for git rebase',
+        },
+      ],
+    }
+  }
+}
+
+function hasEditorAssignment(assignments: { name: string }[]): boolean {
+  return assignments.some(
+    (a) => a.name === 'GIT_SEQUENCE_EDITOR' || a.name === 'GIT_EDITOR',
+  )
+}

package/src/rewriters/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Composes individual rewriters into a single BashSpawnHook and exposes
+ * rewrite analysis for optional UI notifications.
+ */
+
+import type { BashSpawnContext } from '@mariozechner/pi-coding-agent'
+import type { ResolvedToolchainConfig } from '../config'
+import { createGitRebaseRewriter } from './git-rebase'
+import { createPackageManagerRewriter } from './package-manager'
+import { createPythonRewriter } from './python'
+import type { RewriteNotice, Rewriter } from './types'
+
+function createRewriters(config: ResolvedToolchainConfig): Rewriter[] {
+  const rewriters: Rewriter[] = []
+
+  if (config.features.enforcePackageManager === 'rewrite') {
+    rewriters.push(createPackageManagerRewriter(config))
+  }
+  if (config.features.rewritePython === 'rewrite') {
+    rewriters.push(createPythonRewriter())
+  }
+  if (config.features.gitRebaseEditor === 'rewrite') {
+    rewriters.push(createGitRebaseRewriter())
+  }
+
+  return rewriters
+}
+
+export function analyzeRewrite(
+  ctx: BashSpawnContext,
+  config: ResolvedToolchainConfig,
+): { ctx: BashSpawnContext; notices: RewriteNotice[] } {
+  let result = ctx
+  const notices: RewriteNotice[] = []
+
+  for (const rewrite of createRewriters(config)) {
+    const rewriteResult = rewrite(result)
+    result = rewriteResult.ctx
+    notices.push(...rewriteResult.notices)
+  }
+
+  return { ctx: result, notices }
+}
+
+export function createSpawnHook(
+  config: ResolvedToolchainConfig,
+): (ctx: BashSpawnContext) => BashSpawnContext {
+  return (ctx) => analyzeRewrite(ctx, config).ctx
+}