pumuki 6.3.88 → 6.3.90

package/docs/operations/RELEASE_NOTES.md

@@ -1,3 +1,8 @@
+## 2026-04-20 (v6.3.89)
+- **Aislamiento por worktree**: `pumuki install` detecta worktrees sin `core.hooksPath` explícito y fija un `core.hooksPath` local a `.pumuki/git-hooks`, evitando que los hooks gestionados se escriban en `.git/hooks` del checkout principal compartido.
+- **Rollback limpio**: `pumuki uninstall` retira ese `core.hooksPath` solo si fue creado por Pumuki para el worktree.
+- **Rollout recomendado**: publicar `pumuki@6.3.89`, repin inmediato en `Flux_training` y repetir la repro de worktree (`install`, `bootstrap-manifest`, `status --json`, checksums de hooks en checkout principal).
+
 ## 2026-04-20 (v6.3.87)
 - Cierra el segundo tramo de PUM-026: si PRE_WRITE solo arregla el receipt MCP y el gate pasa a verde, fuerza un refresh de paridad contra PRE_COMMIT antes del veredicto final.
 - Rollout recomendado: actualizar Flux_training y repetir la repro mínima de validate/pre-commit/.ai_evidence.

package/integrations/lifecycle/hookManager.ts

@@ -27,6 +27,81 @@ export type PumukiHooksDirectoryResolution = {
 };
 
 const HOOK_FILE_MODE = 0o755;
+const PUMUKI_WORKTREE_HOOKS_PATH = '.pumuki/git-hooks';
+
+const readLocalGitConfigValue = (repoRoot: string, key: string): string | null => {
+  try {
+    const value = execFileSync('git', ['config', '--local', '--get', key], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+};
+
+const writeLocalGitConfigValue = (repoRoot: string, key: string, value: string): void => {
+  execFileSync('git', ['config', '--local', key, value], {
+    cwd: repoRoot,
+    stdio: ['ignore', 'ignore', 'ignore'],
+  });
+};
+
+const unsetLocalGitConfigValue = (repoRoot: string, key: string): void => {
+  try {
+    execFileSync('git', ['config', '--local', '--unset-all', key], {
+      cwd: repoRoot,
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+  } catch {
+    // noop
+  }
+};
+
+const isWorktreeCheckout = (repoRoot: string): boolean => {
+  try {
+    const gitPointer = readFileSync(join(repoRoot, '.git'), 'utf8').trim();
+    return /^gitdir:\s+/i.test(gitPointer);
+  } catch {
+    return false;
+  }
+};
+
+const isPumukiManagedWorktreeHooksPath = (repoRoot: string, hooksPath: string): boolean => {
+  const normalizedHooksPath = hooksPath.trim();
+  return (
+    normalizedHooksPath === PUMUKI_WORKTREE_HOOKS_PATH ||
+    normalizedHooksPath === resolve(repoRoot, PUMUKI_WORKTREE_HOOKS_PATH)
+  );
+};
+
+const ensureWorktreeLocalHooksPath = (repoRoot: string): void => {
+  if (!isWorktreeCheckout(repoRoot)) {
+    return;
+  }
+
+  const currentHooksPath = readLocalGitConfigValue(repoRoot, 'core.hooksPath');
+  if (currentHooksPath) {
+    return;
+  }
+
+  writeLocalGitConfigValue(repoRoot, 'core.hooksPath', PUMUKI_WORKTREE_HOOKS_PATH);
+};
+
+const clearWorktreeLocalHooksPath = (repoRoot: string): void => {
+  if (!isWorktreeCheckout(repoRoot)) {
+    return;
+  }
+
+  const currentHooksPath = readLocalGitConfigValue(repoRoot, 'core.hooksPath');
+  if (!currentHooksPath || !isPumukiManagedWorktreeHooksPath(repoRoot, currentHooksPath)) {
+    return;
+  }
+
+  unsetLocalGitConfigValue(repoRoot, 'core.hooksPath');
+};
 
 const resolveGitPath = (repoRoot: string, gitPathTarget: string): string | null => {
   try {
@@ -137,6 +212,7 @@ const ensureHooksDirectory = (repoRoot: string): void => {
 };
 
 export const installPumukiHooks = (repoRoot: string): HookInstallResult => {
+  ensureWorktreeLocalHooksPath(repoRoot);
   ensureHooksDirectory(repoRoot);
   const changedHooks: PumukiManagedHook[] = [];
 
@@ -180,6 +256,7 @@ export const uninstallPumukiHooks = (repoRoot: string): HookUninstallResult => {
     changedHooks.push(hook);
   }
 
+  clearWorktreeLocalHooksPath(repoRoot);
   return { changedHooks };
 };
 

package/integrations/lifecycle/npmService.ts

@@ -1,21 +1,173 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { spawnSync as runSpawnSync } from 'node:child_process';
 
 export interface ILifecycleNpmService {
   runNpm(args: ReadonlyArray<string>, cwd: string): void;
 }
 
+type LifecyclePackageManager = 'npm' | 'pnpm' | 'yarn';
+
+type PackageManagerManifest = {
+  packageManager?: string;
+  workspaces?: unknown;
+};
+
+const resolvePackageManagerFromManifest = (cwd: string): LifecyclePackageManager | undefined => {
+  const packageJsonPath = join(cwd, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return undefined;
+  }
+
+  try {
+    const raw = readFileSync(packageJsonPath, 'utf8');
+    const manifest = JSON.parse(raw) as PackageManagerManifest;
+    const packageManager = manifest.packageManager?.trim().toLowerCase();
+    if (!packageManager) {
+      return undefined;
+    }
+    if (packageManager.startsWith('pnpm@')) {
+      return 'pnpm';
+    }
+    if (packageManager.startsWith('yarn@')) {
+      return 'yarn';
+    }
+    if (packageManager.startsWith('npm@')) {
+      return 'npm';
+    }
+  } catch {
+    return undefined;
+  }
+
+  return undefined;
+};
+
+export const resolveLifecyclePackageManager = (cwd: string): LifecyclePackageManager => {
+  const fromManifest = resolvePackageManagerFromManifest(cwd);
+  if (fromManifest) {
+    return fromManifest;
+  }
+  if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  if (existsSync(join(cwd, 'yarn.lock'))) {
+    return 'yarn';
+  }
+  return 'npm';
+};
+
+const isWorkspaceRoot = (cwd: string): boolean => {
+  if (existsSync(join(cwd, 'pnpm-workspace.yaml'))) {
+    return true;
+  }
+  const packageJsonPath = join(cwd, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const raw = readFileSync(packageJsonPath, 'utf8');
+    const manifest = JSON.parse(raw) as PackageManagerManifest;
+    return Array.isArray(manifest.workspaces) || typeof manifest.workspaces === 'object';
+  } catch {
+    return false;
+  }
+};
+
+const translateInstallLikeArgs = (
+  packageManager: Exclude<LifecyclePackageManager, 'npm'>,
+  args: ReadonlyArray<string>,
+  cwd: string
+): ReadonlyArray<string> => {
+  const packageSpecs = args.filter((arg) => !arg.startsWith('-')).slice(1);
+  if (packageSpecs.length === 0) {
+    return args;
+  }
+
+  const useExact = args.includes('--save-exact');
+  const useDev = args.includes('--save-dev');
+
+  if (packageManager === 'pnpm') {
+    return [
+      'add',
+      ...(isWorkspaceRoot(cwd) ? ['-w'] : []),
+      ...(useDev ? ['-D'] : []),
+      ...(useExact ? ['-E'] : []),
+      ...packageSpecs,
+    ];
+  }
+
+  return [
+    'add',
+    ...(useDev ? ['--dev'] : []),
+    ...(useExact ? ['--exact'] : []),
+    ...packageSpecs,
+  ];
+};
+
+const translateUninstallLikeArgs = (
+  packageManager: Exclude<LifecyclePackageManager, 'npm'>,
+  args: ReadonlyArray<string>,
+  cwd: string
+): ReadonlyArray<string> => {
+  const packageSpecs = args.filter((arg) => !arg.startsWith('-')).slice(1);
+  if (packageSpecs.length === 0) {
+    return args;
+  }
+  if (packageManager === 'pnpm') {
+    return ['remove', ...(isWorkspaceRoot(cwd) ? ['-w'] : []), ...packageSpecs];
+  }
+  return ['remove', ...packageSpecs];
+};
+
+export const resolveLifecyclePackageManagerCommand = (
+  args: ReadonlyArray<string>,
+  cwd: string
+): {
+  command: LifecyclePackageManager;
+  args: ReadonlyArray<string>;
+} => {
+  const packageManager = resolveLifecyclePackageManager(cwd);
+  if (packageManager === 'npm') {
+    return {
+      command: 'npm',
+      args,
+    };
+  }
+
+  const primaryCommand = args[0];
+  if (primaryCommand === 'install') {
+    return {
+      command: packageManager,
+      args: translateInstallLikeArgs(packageManager, args, cwd),
+    };
+  }
+  if (primaryCommand === 'uninstall') {
+    return {
+      command: packageManager,
+      args: translateUninstallLikeArgs(packageManager, args, cwd),
+    };
+  }
+
+  return {
+    command: packageManager,
+    args,
+  };
+};
+
 export class LifecycleNpmService implements ILifecycleNpmService {
   runNpm(args: ReadonlyArray<string>, cwd: string): void {
-    const result = runSpawnSync('npm', args, {
+    const execution = resolveLifecyclePackageManagerCommand(args, cwd);
+    const renderedCommand = `${execution.command} ${execution.args.join(' ')}`.trim();
+    const result = runSpawnSync(execution.command, execution.args, {
       cwd,
       stdio: 'inherit',
       env: process.env,
     });
     if (result.error) {
-      throw new Error(`npm ${args.join(' ')} failed: ${result.error.message}`);
+      throw new Error(`${renderedCommand} failed: ${result.error.message}`);
     }
     if (typeof result.status !== 'number' || result.status !== 0) {
-      throw new Error(`npm ${args.join(' ')} failed with exit code ${result.status ?? 'unknown'}`);
+      throw new Error(`${renderedCommand} failed with exit code ${result.status ?? 'unknown'}`);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.88",
+  "version": "6.3.90",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {