@mthanhlm/autodev 0.4.3 → 0.5.0

package/bin/install.js

@@ -1,29 +1,54 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
-const path = require('path');
 const os = require('os');
-const readline = require('readline');
+const path = require('path');
 
 const green = '\x1b[32m';
 const yellow = '\x1b[33m';
 const cyan = '\x1b[36m';
 const reset = '\x1b[0m';
 
-const MANAGED_PREFIX = 'autodev-';
 const ROOT_COMMAND = 'autodev';
-const HOOK_FILES = [
-  'hooks.json',
+const SUPPORTED_SCOPE = 'global';
+const LEGACY_SKILL_NAMES = [
+  'autodev',
+  'autodev-auto',
+  'autodev-cleanup',
+  'autodev-execute-phase',
+  'autodev-explore-codebase',
+  'autodev-help',
+  'autodev-new-project',
+  'autodev-plan-phase',
+  'autodev-progress',
+  'autodev-review-phase',
+  'autodev-review-task',
+  'autodev-status',
+  'autodev-verify-work'
+];
+const LEGACY_AGENT_FILES = [
+  'autodev-codebase-domain.md',
+  'autodev-codebase-quality.md',
+  'autodev-codebase-runtime.md',
+  'autodev-codebase-structure.md',
+  'autodev-review-integration.md',
+  'autodev-review-polish.md',
+  'autodev-review-quality.md',
+  'autodev-review-security.md',
+  'autodev-task-worker.md'
+];
+const MANAGED_HOOK_FILES = [
   'autodev-auto-format.js',
+  'autodev-git-guard.js',
   'autodev-paths.js',
   'autodev-context-monitor.js',
-  'autodev-git-guard.js',
   'autodev-phase-boundary.sh',
   'autodev-prompt-guard.js',
   'autodev-read-guard.js',
   'autodev-session-state.sh',
   'autodev-statusline.js',
-  'autodev-workflow-guard.js'
+  'autodev-workflow-guard.js',
+  'hooks.json'
 ];
 
 function stripJsonComments(input) {
@@ -148,7 +173,9 @@ function convertCommandToClaudeSkill(content, skillName) {
   const description = extractFrontmatterField(frontmatter, 'description') || '';
   const argumentHint = extractFrontmatterField(frontmatter, 'argument-hint');
   const toolsMatch = frontmatter.match(/^allowed-tools:\s*\n((?:\s+-\s+.+\n?)*)/m);
-  const toolsBlock = toolsMatch ? `allowed-tools:\n${toolsMatch[1].endsWith('\n') ? toolsMatch[1] : `${toolsMatch[1]}\n`}` : '';
+  const toolsBlock = toolsMatch
+    ? `allowed-tools:\n${toolsMatch[1].endsWith('\n') ? toolsMatch[1] : `${toolsMatch[1]}\n`}`
+    : '';
 
   let rebuilt = `---\nname: ${skillName}\ndescription: ${yamlQuote(description)}\n`;
   if (argumentHint) {
@@ -173,6 +200,11 @@ function transformInstalledContent(content, pathPrefix) {
     .replace(/\.\/\.claude\b/g, bare);
 }
 
+function commandNameFromSourceFile(fileName) {
+  const baseName = fileName.replace(/\.md$/, '');
+  return baseName === 'index' ? ROOT_COMMAND : `${ROOT_COMMAND}-${baseName}`;
+}
+
 function copyTextTree(srcDir, destDir, transform) {
   if (!fs.existsSync(srcDir)) {
     return;
@@ -182,6 +214,7 @@ function copyTextTree(srcDir, destDir, transform) {
   for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
     const srcPath = path.join(srcDir, entry.name);
     const destPath = path.join(destDir, entry.name);
+
     if (entry.isDirectory()) {
       copyTextTree(srcPath, destPath, transform);
       continue;
@@ -195,111 +228,57 @@ function copyTextTree(srcDir, destDir, transform) {
   }
 }
 
-function commandNameFromSourceFile(fileName) {
-  const baseName = fileName.replace(/\.md$/, '');
-  return baseName === 'index' ? ROOT_COMMAND : `${ROOT_COMMAND}-${baseName}`;
-}
-
-function skillNameFromSourceFile(fileName, prefix) {
-  const baseName = fileName.replace(/\.md$/, '');
-  return baseName === 'index' ? prefix : `${prefix}-${baseName}`;
-}
-
-function copyCommandsAsLocal(srcDir, destDir, transform) {
-  fs.mkdirSync(destDir, { recursive: true });
-
-  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-    if (!entry.isFile() || !entry.name.endsWith('.md')) {
-      continue;
-    }
-
-    const srcPath = path.join(srcDir, entry.name);
-    const destPath = path.join(destDir, `${commandNameFromSourceFile(entry.name)}.md`);
-    let content = fs.readFileSync(srcPath, 'utf8');
-    content = transform(content);
-    fs.writeFileSync(destPath, content, 'utf8');
-  }
-}
-
 function copyCommandsAsGlobalSkills(srcDir, skillsDir, prefix, transform) {
   fs.mkdirSync(skillsDir, { recursive: true });
 
-  for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-    if (entry.isDirectory() && (entry.name === prefix || entry.name.startsWith(`${prefix}-`))) {
-      fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
-    }
-  }
-
   for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith('.md')) {
       continue;
     }
 
-    const skillName = skillNameFromSourceFile(entry.name, prefix);
+    const skillName = commandNameFromSourceFile(entry.name);
     const skillDir = path.join(skillsDir, skillName);
     fs.mkdirSync(skillDir, { recursive: true });
 
     let content = fs.readFileSync(path.join(srcDir, entry.name), 'utf8');
     content = transform(content);
-    content = convertCommandToClaudeSkill(content, skillName);
+    content = convertCommandToClaudeSkill(content, skillName === prefix ? prefix : skillName);
     fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf8');
   }
 }
 
-function copyAgents(srcDir, destDir, transform) {
-  if (!fs.existsSync(srcDir)) {
-    return;
+function currentManagedSkillNames(srcRoot) {
+  const commandsDir = path.join(srcRoot, 'commands', 'autodev');
+  if (!fs.existsSync(commandsDir)) {
+    return [];
   }
 
-  fs.mkdirSync(destDir, { recursive: true });
-  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-    if (!entry.isFile()) {
-      continue;
-    }
-
-    const srcPath = path.join(srcDir, entry.name);
-    const destPath = path.join(destDir, entry.name);
-    let content = fs.readFileSync(srcPath, 'utf8');
-    content = transform(content);
-    fs.writeFileSync(destPath, content, 'utf8');
-  }
+  return fs.readdirSync(commandsDir, { withFileTypes: true })
+    .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+    .map(entry => commandNameFromSourceFile(entry.name));
 }
 
-function removeManagedSettings(settings) {
-  if (settings.statusLine?.command && settings.statusLine.command.includes('autodev-statusline')) {
-    delete settings.statusLine;
-  }
-
-  if (settings.env && typeof settings.env === 'object') {
-    delete settings.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS;
-    if (Object.keys(settings.env).length === 0) {
-      delete settings.env;
-    }
-  }
-
-  if (!settings.hooks || typeof settings.hooks !== 'object') {
-    return settings;
-  }
-
-  for (const eventName of Object.keys(settings.hooks)) {
-    const entries = Array.isArray(settings.hooks[eventName]) ? settings.hooks[eventName] : [];
-    const filtered = entries.filter(entry => {
-      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
-      return !hooks.some(hook => typeof hook.command === 'string' && hook.command.includes('autodev-'));
-    });
+function managedSkillNames(srcRoot) {
+  return [...new Set([...currentManagedSkillNames(srcRoot), ...LEGACY_SKILL_NAMES])];
+}
 
-    if (filtered.length > 0) {
-      settings.hooks[eventName] = filtered;
-    } else {
-      delete settings.hooks[eventName];
-    }
-  }
+function managedCommandStrings(targetDir) {
+  return [
+    `node "${path.join(targetDir, 'hooks', 'autodev-git-guard.js').replace(/\\/g, '/')}"`,
+    `node "${path.join(targetDir, 'hooks', 'autodev-auto-format.js').replace(/\\/g, '/')}"`,
+    ...MANAGED_HOOK_FILES
+      .filter(fileName => fileName.endsWith('.js') || fileName.endsWith('.sh'))
+      .map(fileName => path.join(targetDir, 'hooks', fileName).replace(/\\/g, '/'))
+  ];
+}
 
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
+function isManagedCommand(command, targetDir) {
+  if (typeof command !== 'string') {
+    return false;
   }
 
-  return settings;
+  return managedCommandStrings(targetDir).some(pattern => command.includes(pattern))
+    || /autodev-(?:auto-format|context-monitor|git-guard|phase-boundary|prompt-guard|read-guard|session-state|statusline|workflow-guard)\.(?:js|sh)/.test(command);
 }
 
 function ensureHook(settings, eventName, matcher, command, timeout) {
@@ -330,355 +309,263 @@ function ensureHook(settings, eventName, matcher, command, timeout) {
   settings.hooks[eventName].push(entry);
 }
 
-function ensureEnvSetting(settings, name, value) {
-  if (!settings.env || typeof settings.env !== 'object') {
-    settings.env = {};
+function removeManagedSettings(settings, targetDir) {
+  if (!settings || typeof settings !== 'object') {
+    return {};
   }
-  settings.env[name] = String(value);
-}
 
-function setExecutableBits(targetDir) {
-  const candidates = [
-    path.join(targetDir, 'hooks', 'autodev-phase-boundary.sh'),
-    path.join(targetDir, 'hooks', 'autodev-session-state.sh'),
-    path.join(targetDir, 'autodev', 'bin', 'autodev-tools.cjs')
-  ];
+  if (settings.statusLine?.command && isManagedCommand(settings.statusLine.command, targetDir)) {
+    delete settings.statusLine;
+  }
 
-  for (const file of candidates) {
-    if (fs.existsSync(file)) {
-      fs.chmodSync(file, 0o755);
+  if (settings.env && typeof settings.env === 'object') {
+    delete settings.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS;
+    if (Object.keys(settings.env).length === 0) {
+      delete settings.env;
     }
   }
-}
 
-function buildGlobalCommand(targetDir, fileName, shell = 'node') {
-  const filePath = path.join(targetDir, 'hooks', fileName).replace(/\\/g, '/');
-  return `${shell} "${filePath}"`;
-}
+  if (!settings.hooks || typeof settings.hooks !== 'object') {
+    return settings;
+  }
 
-function buildLocalCommand(fileName, shell = 'node') {
-  return `${shell} "$CLAUDE_PROJECT_DIR"/.claude/hooks/${fileName}`;
+  for (const eventName of Object.keys(settings.hooks)) {
+    const entries = Array.isArray(settings.hooks[eventName]) ? settings.hooks[eventName] : [];
+    const filtered = entries.filter(entry => {
+      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+      return !hooks.some(hook => isManagedCommand(hook?.command, targetDir));
+    });
+
+    if (filtered.length > 0) {
+      settings.hooks[eventName] = filtered;
+    } else {
+      delete settings.hooks[eventName];
+    }
+  }
+
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  return settings;
 }
 
-function configureSettings(targetDir, isGlobal, options = {}) {
+function configureSettings(targetDir) {
   const settingsPath = path.join(targetDir, 'settings.json');
   const settings = readSettings(settingsPath);
   if (settings === null) {
     return null;
   }
 
-  removeManagedSettings(settings);
-
-  const preToolEvent = 'PreToolUse';
-  const postToolEvent = 'PostToolUse';
-  const sessionStartEvent = 'SessionStart';
-
-  const contextMonitorCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-context-monitor.js')
-    : buildLocalCommand('autodev-context-monitor.js');
-  const autoFormatCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-auto-format.js')
-    : buildLocalCommand('autodev-auto-format.js');
-  const promptGuardCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-prompt-guard.js')
-    : buildLocalCommand('autodev-prompt-guard.js');
-  const readGuardCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-read-guard.js')
-    : buildLocalCommand('autodev-read-guard.js');
-  const workflowGuardCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-workflow-guard.js')
-    : buildLocalCommand('autodev-workflow-guard.js');
-  const gitGuardCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-git-guard.js')
-    : buildLocalCommand('autodev-git-guard.js');
-  const sessionStateCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-session-state.sh', 'bash')
-    : buildLocalCommand('autodev-session-state.sh', 'bash');
-  const phaseBoundaryCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-phase-boundary.sh', 'bash')
-    : buildLocalCommand('autodev-phase-boundary.sh', 'bash');
-  const statusLineCommand = isGlobal
-    ? buildGlobalCommand(targetDir, 'autodev-statusline.js')
-    : buildLocalCommand('autodev-statusline.js');
-
-  ensureHook(settings, sessionStartEvent, null, sessionStateCommand);
-  ensureHook(settings, preToolEvent, 'Write|Edit', promptGuardCommand, 5);
-  ensureHook(settings, preToolEvent, 'Write|Edit', readGuardCommand, 5);
-  ensureHook(settings, preToolEvent, 'Write|Edit', workflowGuardCommand, 5);
-  ensureHook(settings, preToolEvent, 'Bash', gitGuardCommand, 5);
-  ensureHook(settings, postToolEvent, 'Edit|Write|MultiEdit', autoFormatCommand, 10);
-  ensureHook(settings, postToolEvent, 'Bash|Edit|Write|MultiEdit|Agent|Task', contextMonitorCommand, 10);
-  ensureHook(settings, postToolEvent, 'Write|Edit', phaseBoundaryCommand, 5);
-
-  if (options.installStatusLine !== false) {
-    settings.statusLine = {
-      type: 'command',
-      command: statusLineCommand
-    };
-  }
-
-  if (options.disableBackgroundTasks) {
-    ensureEnvSetting(settings, 'CLAUDE_CODE_DISABLE_BACKGROUND_TASKS', '1');
+  removeManagedSettings(settings, targetDir);
+
+  ensureHook(
+    settings,
+    'PreToolUse',
+    'Bash',
+    `node "${path.join(targetDir, 'hooks', 'autodev-git-guard.js').replace(/\\/g, '/')}"`,
+    5
+  );
+  ensureHook(
+    settings,
+    'PostToolUse',
+    'Edit|Write|MultiEdit',
+    `node "${path.join(targetDir, 'hooks', 'autodev-auto-format.js').replace(/\\/g, '/')}"`,
+    10
+  );
+
+  if (!settings.env || typeof settings.env !== 'object') {
+    settings.env = {};
   }
+  settings.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS = '1';
 
   writeSettings(settingsPath, settings);
   return settingsPath;
 }
 
-function removeInstalledFiles(targetDir, isGlobal) {
+function removeManagedFiles(targetDir) {
   const supportDir = path.join(targetDir, 'autodev');
   if (fs.existsSync(supportDir)) {
     fs.rmSync(supportDir, { recursive: true, force: true });
   }
 
-  const agentsDir = path.join(targetDir, 'agents');
-  if (fs.existsSync(agentsDir)) {
-    for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.startsWith(MANAGED_PREFIX) && entry.name.endsWith('.md')) {
-        fs.rmSync(path.join(agentsDir, entry.name), { force: true });
-      }
+  const hooksDir = path.join(targetDir, 'hooks');
+  for (const fileName of MANAGED_HOOK_FILES) {
+    const hookPath = path.join(hooksDir, fileName);
+    if (fs.existsSync(hookPath)) {
+      fs.rmSync(hookPath, { recursive: true, force: true });
     }
   }
 
-  const hooksDir = path.join(targetDir, 'hooks');
-  for (const hookName of HOOK_FILES) {
-    const hookPath = path.join(hooksDir, hookName);
-    if (fs.existsSync(hookPath)) {
-      fs.rmSync(hookPath, { force: true });
+  const agentsDir = path.join(targetDir, 'agents');
+  for (const fileName of LEGACY_AGENT_FILES) {
+    const agentPath = path.join(agentsDir, fileName);
+    if (fs.existsSync(agentPath)) {
+      fs.rmSync(agentPath, { force: true });
     }
   }
 
-  if (isGlobal) {
-    const skillsDir = path.join(targetDir, 'skills');
-    if (fs.existsSync(skillsDir)) {
-      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && (entry.name === ROOT_COMMAND || entry.name.startsWith(MANAGED_PREFIX))) {
-          fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
-        }
-      }
+  const skillsDir = path.join(targetDir, 'skills');
+  for (const skillName of managedSkillNames(path.resolve(__dirname, '..'))) {
+    const skillPath = path.join(skillsDir, skillName);
+    if (fs.existsSync(skillPath)) {
+      fs.rmSync(skillPath, { recursive: true, force: true });
     }
-  } else {
-    const commandsDir = path.join(targetDir, 'commands');
-    if (fs.existsSync(commandsDir)) {
-      for (const entry of fs.readdirSync(commandsDir, { withFileTypes: true })) {
-        if (entry.isFile() && entry.name.startsWith(ROOT_COMMAND) && entry.name.endsWith('.md')) {
-          fs.rmSync(path.join(commandsDir, entry.name), { force: true });
-        }
+  }
+
+  const legacyCommandsDir = path.join(targetDir, 'commands');
+  if (fs.existsSync(legacyCommandsDir)) {
+    for (const skillName of managedSkillNames(path.resolve(__dirname, '..'))) {
+      const commandPath = path.join(legacyCommandsDir, `${skillName}.md`);
+      if (fs.existsSync(commandPath)) {
+        fs.rmSync(commandPath, { force: true });
       }
     }
-    const legacyCommandsDir = path.join(commandsDir, ROOT_COMMAND);
-    if (fs.existsSync(legacyCommandsDir)) {
-      fs.rmSync(legacyCommandsDir, { recursive: true, force: true });
-    }
-    const skillsDir = path.join(targetDir, 'skills');
-    if (fs.existsSync(skillsDir)) {
-      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && (entry.name === ROOT_COMMAND || entry.name.startsWith(MANAGED_PREFIX))) {
-          fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
-        }
-      }
+    const nestedLegacy = path.join(legacyCommandsDir, ROOT_COMMAND);
+    if (fs.existsSync(nestedLegacy)) {
+      fs.rmSync(nestedLegacy, { recursive: true, force: true });
     }
   }
 }
 
-function resolveTargetDir({ scope, cwd, targetDir }) {
-  if (targetDir) {
-    return path.resolve(targetDir);
+function resolveTargetDir(options = {}) {
+  if (options.targetDir) {
+    return path.resolve(options.targetDir);
   }
 
-  if (scope === 'global') {
-    return path.resolve(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'));
-  }
+  return path.resolve(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'));
+}
 
-  return path.join(path.resolve(cwd), '.claude');
+function setExecutableBits(targetDir) {
+  const candidates = [
+    path.join(targetDir, 'autodev', 'bin', 'autodev-tools.cjs'),
+    path.join(targetDir, 'hooks', 'autodev-auto-format.js'),
+    path.join(targetDir, 'hooks', 'autodev-git-guard.js'),
+    path.join(targetDir, 'hooks', 'autodev-paths.js')
+  ];
+
+  for (const filePath of candidates) {
+    if (fs.existsSync(filePath)) {
+      fs.chmodSync(filePath, 0o755);
+    }
+  }
 }
 
 function install(options = {}) {
-  const scope = options.scope === 'local' ? 'local' : 'global';
-  const cwd = options.cwd || process.cwd();
-  const targetDir = resolveTargetDir({ scope, cwd, targetDir: options.targetDir });
-  const isGlobal = scope === 'global';
-  const silent = Boolean(options.silent);
+  if ((options.scope || SUPPORTED_SCOPE) !== SUPPORTED_SCOPE) {
+    throw new Error('local install is no longer supported; install autodev globally');
+  }
+
   const srcRoot = path.resolve(__dirname, '..');
-  const pathPrefix = isGlobal
-    ? `${targetDir.replace(/\\/g, '/')}/`
-    : './.claude/';
+  const targetDir = resolveTargetDir(options);
+  const pathPrefix = `${targetDir.replace(/\\/g, '/')}/`;
   const transform = content => transformInstalledContent(content, pathPrefix);
 
   fs.mkdirSync(targetDir, { recursive: true });
-  removeInstalledFiles(targetDir, isGlobal);
-
-  if (isGlobal) {
-    copyCommandsAsGlobalSkills(
-      path.join(srcRoot, 'commands', 'autodev'),
-      path.join(targetDir, 'skills'),
-      'autodev',
-      transform
-    );
-  } else {
-    copyCommandsAsLocal(
-      path.join(srcRoot, 'commands', 'autodev'),
-      path.join(targetDir, 'commands'),
-      transform
-    );
-  }
+  removeManagedFiles(targetDir);
 
+  copyCommandsAsGlobalSkills(
+    path.join(srcRoot, 'commands', 'autodev'),
+    path.join(targetDir, 'skills'),
+    ROOT_COMMAND,
+    transform
+  );
   copyTextTree(path.join(srcRoot, 'autodev'), path.join(targetDir, 'autodev'), transform);
-  copyAgents(path.join(srcRoot, 'agents'), path.join(targetDir, 'agents'), transform);
-  copyTextTree(path.join(srcRoot, 'hooks'), path.join(targetDir, 'hooks'), transform);
+
+  const hookDestRoot = path.join(targetDir, 'hooks');
+  fs.mkdirSync(hookDestRoot, { recursive: true });
+  for (const fileName of ['autodev-auto-format.js', 'autodev-git-guard.js', 'autodev-paths.js']) {
+    let content = fs.readFileSync(path.join(srcRoot, 'hooks', fileName), 'utf8');
+    content = transform(content);
+    fs.writeFileSync(path.join(hookDestRoot, fileName), content, 'utf8');
+  }
+
   setExecutableBits(targetDir);
-  const settingsPath = configureSettings(targetDir, isGlobal, options);
+  const settingsPath = configureSettings(targetDir);
 
-  if (!silent) {
-    const locationLabel = isGlobal ? 'global' : 'local';
-    console.log(`  ${green}Installed${reset} autodev (${locationLabel}) at ${cyan}${targetDir}${reset}`);
+  if (!options.silent) {
+    console.log(`${cyan}autodev${reset} installed to ${green}${targetDir}${reset}`);
     if (settingsPath) {
       console.log(`  ${green}Updated${reset} ${cyan}${settingsPath}${reset}`);
     }
-    console.log(`  Run ${cyan}/autodev${reset} in Claude Code.`);
+    console.log(`  ${yellow}Background tasks disabled${reset} via CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1`);
   }
 
   return { targetDir, settingsPath };
 }
 
 function uninstall(options = {}) {
-  const scope = options.scope === 'local' ? 'local' : 'global';
-  const cwd = options.cwd || process.cwd();
-  const targetDir = resolveTargetDir({ scope, cwd, targetDir: options.targetDir });
-  const isGlobal = scope === 'global';
-  const silent = Boolean(options.silent);
-
-  removeInstalledFiles(targetDir, isGlobal);
+  if ((options.scope || SUPPORTED_SCOPE) !== SUPPORTED_SCOPE) {
+    throw new Error('local install is no longer supported; uninstall the global install instead');
+  }
 
+  const targetDir = resolveTargetDir(options);
   const settingsPath = path.join(targetDir, 'settings.json');
   const settings = readSettings(settingsPath);
-  if (settings) {
-    removeManagedSettings(settings);
+
+  removeManagedFiles(targetDir);
+
+  if (settings !== null) {
+    removeManagedSettings(settings, targetDir);
     writeSettings(settingsPath, settings);
   }
 
-  if (!silent) {
-    console.log(`  ${green}Removed${reset} autodev from ${cyan}${targetDir}${reset}`);
+  if (!options.silent) {
+    console.log(`${cyan}autodev${reset} removed from ${green}${targetDir}${reset}`);
+    if (settings !== null) {
+      console.log(`  ${green}Updated${reset} ${cyan}${settingsPath}${reset}`);
+    }
   }
 
   return { targetDir, settingsPath };
 }
 
 function printHelp() {
-  console.log(`Usage: npx @mthanhlm/autodev [--global|--local] [--uninstall]
-
-Options:
-  --global      Install to Claude Code config directory
-  --local       Install to the current project (.claude/)
-  --disable-background-tasks
-                Set CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1 in Claude Code settings.json
-  --uninstall   Remove autodev from the selected location
-  --help        Show this help
-
-Examples:
-  npx @mthanhlm/autodev@latest
-  npx @mthanhlm/autodev@latest --global
-  npx @mthanhlm/autodev@latest --local
-  npx @mthanhlm/autodev@latest --global --disable-background-tasks
-  npx @mthanhlm/autodev@latest --global --uninstall
-`);
-}
-
-function askScope() {
-  return new Promise(resolve => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(`
-${cyan}autodev install${reset}
-
-Runtime:
-  Claude Code only
-
-Location:
-  ${cyan}1${reset}) Global  ${yellow}(Recommended)${reset}  -> ~/.claude
-  ${cyan}2${reset}) Local                    -> ./.claude
-`);
-    rl.question(`Select install location ${yellow}[1]${reset}: `, answer => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      if (trimmed === '2' || trimmed === 'l' || trimmed === 'local') {
-        resolve('local');
-        return;
-      }
-      resolve('global');
-    });
-  });
-}
-
-function askDisableBackgroundTasks() {
-  return new Promise(resolve => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(`
-Background tasks:
-  ${cyan}1${reset}) Disable in Claude Code settings ${yellow}(Recommended for autodev)${reset}
-      -> sets CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1
-  ${cyan}2${reset}) Leave background-task settings unchanged
-`);
-    rl.question(`Select background-task policy ${yellow}[1]${reset}: `, answer => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      if (trimmed === '2' || trimmed === 'n' || trimmed === 'no' || trimmed === 'leave') {
-        resolve(false);
-        return;
-      }
-      resolve(true);
-    });
-  });
+  process.stdout.write(`Usage: npx @mthanhlm/autodev [--global] [--uninstall]\n\n`);
+  process.stdout.write(`Defaults:\n`);
+  process.stdout.write(`  --global     Install into ~/.claude (default)\n`);
+  process.stdout.write(`  --uninstall  Remove autodev from ~/.claude\n`);
+  process.stdout.write(`\nNotes:\n`);
+  process.stdout.write(`  - Global install is the supported mode.\n`);
+  process.stdout.write(`  - Install always sets CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1.\n`);
 }
 
-async function main() {
+function main() {
   const args = process.argv.slice(2);
+
   if (args.includes('--help') || args.includes('-h')) {
     printHelp();
     return;
   }
 
-  let scope = null;
-  let scopeWasExplicit = false;
-  if (args.includes('--global') || args.includes('-g')) {
-    scope = 'global';
-    scopeWasExplicit = true;
-  } else if (args.includes('--local') || args.includes('-l')) {
-    scope = 'local';
-    scopeWasExplicit = true;
-  }
-
-  if (!scope) {
-    scope = await askScope();
+  if (args.includes('--local')) {
+    process.stderr.write('autodev: local install is no longer supported\n');
+    process.exit(1);
   }
 
   const uninstallRequested = args.includes('--uninstall') || args.includes('-u');
-  const disableBackgroundTasks = args.includes('--disable-background-tasks')
-    ? true
-    : uninstallRequested || scopeWasExplicit
-      ? false
-      : await askDisableBackgroundTasks();
 
-  if (uninstallRequested) {
-    uninstall({ scope });
-  } else {
-    install({ scope, disableBackgroundTasks });
+  try {
+    if (uninstallRequested) {
+      uninstall({ scope: SUPPORTED_SCOPE });
+    } else {
+      install({ scope: SUPPORTED_SCOPE });
+    }
+  } catch (error) {
+    process.stderr.write(`autodev: ${error.message}\n`);
+    process.exit(1);
   }
 }
 
 if (require.main === module) {
-  main().catch(error => {
-    console.error(error);
-    process.exit(1);
-  });
+  main();
 }
 
 module.exports = {
   configureSettings,
-  convertCommandToClaudeSkill,
   install,
-  readSettings,
+  managedSkillNames,
+  removeManagedFiles,
   removeManagedSettings,
-  stripJsonComments,
-  transformInstalledContent,
   uninstall
 };