@mthanhlm/autodev 0.1.0

package/bin/install.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+
+const MANAGED_PREFIX = 'autodev-';
+const HOOK_FILES = [
+  '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'
+];
+
+function stripJsonComments(input) {
+  let output = '';
+  let inString = false;
+  let stringChar = '';
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = input[index + 1];
+
+    if (inLineComment) {
+      if (char === '\n') {
+        inLineComment = false;
+        output += char;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+
+    if ((char === '"' || char === "'") && !inString) {
+      inString = true;
+      stringChar = char;
+      output += char;
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (char === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+
+    output += char;
+  }
+
+  return output;
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return JSON.parse(stripJsonComments(raw));
+    }
+  } catch (error) {
+    console.warn(`  ${yellow}Warning:${reset} could not parse ${settingsPath}: ${error.message}`);
+    return null;
+  }
+}
+
+function writeSettings(settingsPath, settings) {
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+}
+
+function extractFrontmatterAndBody(content) {
+  if (!content.startsWith('---\n')) {
+    return { frontmatter: null, body: content };
+  }
+
+  const endIndex = content.indexOf('\n---\n', 4);
+  if (endIndex === -1) {
+    return { frontmatter: null, body: content };
+  }
+
+  return {
+    frontmatter: content.slice(4, endIndex),
+    body: content.slice(endIndex + 5).trim()
+  };
+}
+
+function extractFrontmatterField(frontmatter, name) {
+  const match = frontmatter.match(new RegExp(`^${name}:\\s*(.+)$`, 'm'));
+  return match ? match[1].trim() : null;
+}
+
+function yamlQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+function convertCommandToClaudeSkill(content, skillName) {
+  const { frontmatter, body } = extractFrontmatterAndBody(content);
+  if (!frontmatter) {
+    return content;
+  }
+
+  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`}` : '';
+
+  let rebuilt = `---\nname: ${skillName}\ndescription: ${yamlQuote(description)}\n`;
+  if (argumentHint) {
+    rebuilt += `argument-hint: ${yamlQuote(argumentHint)}\n`;
+  }
+  if (toolsBlock) {
+    rebuilt += toolsBlock;
+  }
+  rebuilt += '---';
+  return `${rebuilt}\n${body}\n`;
+}
+
+function transformInstalledContent(content, pathPrefix) {
+  const normalized = pathPrefix.endsWith('/') ? pathPrefix : `${pathPrefix}/`;
+  const bare = normalized.replace(/\/$/, '');
+  return content
+    .replace(/~\/\.claude\//g, normalized)
+    .replace(/\$HOME\/\.claude\//g, normalized)
+    .replace(/~\/\.claude\b/g, bare)
+    .replace(/\$HOME\/\.claude\b/g, bare)
+    .replace(/\.\/\.claude\//g, normalized)
+    .replace(/\.\/\.claude\b/g, bare);
+}
+
+function copyTextTree(srcDir, destDir, transform) {
+  if (!fs.existsSync(srcDir)) {
+    return;
+  }
+
+  fs.mkdirSync(destDir, { recursive: true });
+  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;
+    }
+
+    let content = fs.readFileSync(srcPath, 'utf8');
+    if (transform) {
+      content = transform(content);
+    }
+    fs.writeFileSync(destPath, content, 'utf8');
+  }
+}
+
+function copyCommandsAsLocal(srcDir, destDir, transform) {
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  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()) {
+      copyCommandsAsLocal(srcPath, destPath, transform);
+      continue;
+    }
+    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.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 baseName = entry.name.replace(/\.md$/, '');
+    const skillName = `${prefix}-${baseName}`;
+    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);
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf8');
+  }
+}
+
+function removeManagedSettings(settings) {
+  if (settings.statusLine?.command && settings.statusLine.command.includes('autodev-statusline')) {
+    delete settings.statusLine;
+  }
+
+  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-'));
+    });
+
+    if (filtered.length > 0) {
+      settings.hooks[eventName] = filtered;
+    } else {
+      delete settings.hooks[eventName];
+    }
+  }
+
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  return settings;
+}
+
+function ensureHook(settings, eventName, matcher, command, timeout) {
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks[eventName]) {
+    settings.hooks[eventName] = [];
+  }
+
+  const exists = settings.hooks[eventName].some(entry =>
+    Array.isArray(entry.hooks) && entry.hooks.some(hook => hook.command === command)
+  );
+  if (exists) {
+    return;
+  }
+
+  const hookEntry = { type: 'command', command };
+  if (timeout) {
+    hookEntry.timeout = timeout;
+  }
+
+  const entry = { hooks: [hookEntry] };
+  if (matcher) {
+    entry.matcher = matcher;
+  }
+
+  settings.hooks[eventName].push(entry);
+}
+
+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')
+  ];
+
+  for (const file of candidates) {
+    if (fs.existsSync(file)) {
+      fs.chmodSync(file, 0o755);
+    }
+  }
+}
+
+function buildGlobalCommand(targetDir, fileName, shell = 'node') {
+  const filePath = path.join(targetDir, 'hooks', fileName).replace(/\\/g, '/');
+  return `${shell} "${filePath}"`;
+}
+
+function buildLocalCommand(fileName, shell = 'node') {
+  return `${shell} "$CLAUDE_PROJECT_DIR"/.claude/hooks/${fileName}`;
+}
+
+function configureSettings(targetDir, isGlobal, options = {}) {
+  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 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, '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
+    };
+  }
+
+  writeSettings(settingsPath, settings);
+  return settingsPath;
+}
+
+function removeInstalledFiles(targetDir, isGlobal) {
+  const supportDir = path.join(targetDir, 'autodev');
+  if (fs.existsSync(supportDir)) {
+    fs.rmSync(supportDir, { 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 });
+    }
+  }
+
+  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.startsWith(MANAGED_PREFIX)) {
+          fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
+        }
+      }
+    }
+  } else {
+    const commandsDir = path.join(targetDir, 'commands', 'autodev');
+    if (fs.existsSync(commandsDir)) {
+      fs.rmSync(commandsDir, { 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.startsWith(MANAGED_PREFIX)) {
+          fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
+        }
+      }
+    }
+  }
+}
+
+function resolveTargetDir({ scope, cwd, targetDir }) {
+  if (targetDir) {
+    return path.resolve(targetDir);
+  }
+
+  if (scope === 'global') {
+    return path.resolve(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'));
+  }
+
+  return path.join(path.resolve(cwd), '.claude');
+}
+
+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);
+  const srcRoot = path.resolve(__dirname, '..');
+  const pathPrefix = isGlobal
+    ? `${targetDir.replace(/\\/g, '/')}/`
+    : './.claude/';
+  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', 'autodev'),
+      transform
+    );
+  }
+
+  copyTextTree(path.join(srcRoot, 'autodev'), path.join(targetDir, 'autodev'), transform);
+  copyTextTree(path.join(srcRoot, 'hooks'), path.join(targetDir, 'hooks'), transform);
+  setExecutableBits(targetDir);
+  const settingsPath = configureSettings(targetDir, isGlobal, options);
+
+  if (!silent) {
+    const locationLabel = isGlobal ? 'global' : 'local';
+    console.log(`  ${green}Installed${reset} autodev (${locationLabel}) at ${cyan}${targetDir}${reset}`);
+    if (settingsPath) {
+      console.log(`  ${green}Updated${reset} ${cyan}${settingsPath}${reset}`);
+    }
+    console.log(`  Run ${cyan}/autodev-help${reset} in Claude Code.`);
+  }
+
+  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);
+
+  const settingsPath = path.join(targetDir, 'settings.json');
+  const settings = readSettings(settingsPath);
+  if (settings) {
+    removeManagedSettings(settings);
+    writeSettings(settingsPath, settings);
+  }
+
+  if (!silent) {
+    console.log(`  ${green}Removed${reset} autodev from ${cyan}${targetDir}${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/)
+  --uninstall   Remove autodev from the selected location
+  --help        Show this help
+
+Examples:
+  npx @mthanhlm/autodev@latest --global
+  npx @mthanhlm/autodev@latest --local
+  npx @mthanhlm/autodev@latest --global --uninstall
+`);
+}
+
+function askScope() {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('Install autodev globally or locally? [g/l] ', answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase().startsWith('l') ? 'local' : 'global');
+    });
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return;
+  }
+
+  let scope = null;
+  if (args.includes('--global') || args.includes('-g')) {
+    scope = 'global';
+  } else if (args.includes('--local') || args.includes('-l')) {
+    scope = 'local';
+  }
+
+  if (!scope) {
+    scope = await askScope();
+  }
+
+  if (args.includes('--uninstall') || args.includes('-u')) {
+    uninstall({ scope });
+  } else {
+    install({ scope });
+  }
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  configureSettings,
+  convertCommandToClaudeSkill,
+  install,
+  readSettings,
+  removeManagedSettings,
+  stripJsonComments,
+  transformInstalledContent,
+  uninstall
+};

package/commands/autodev/execute-phase.md

@@ -0,0 +1,26 @@
+---
+name: autodev:execute-phase
+description: Execute a phase plan sequentially without git writes
+argument-hint: "[phase-number]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - TodoWrite
+  - AskUserQuestion
+---
+<objective>
+Execute one phase plan from `.autodev/phases/` and record the result in a summary.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/execute-phase.md
+@~/.claude/autodev/templates/summary.md
+</execution_context>
+
+<process>
+Execute the workflow in @~/.claude/autodev/workflows/execute-phase.md end-to-end.
+</process>

package/commands/autodev/help.md

@@ -0,0 +1,18 @@
+---
+name: autodev:help
+description: Show the compact autodev command reference
+allowed-tools:
+  - Read
+  - Bash
+---
+<objective>
+Show the autodev command reference and the default workflow.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/help.md
+</execution_context>
+
+<process>
+Output the reference from @~/.claude/autodev/workflows/help.md directly.
+</process>

package/commands/autodev/new-project.md

@@ -0,0 +1,28 @@
+---
+name: autodev:new-project
+description: Initialize a new autodev project with minimal ceremony
+argument-hint: "[idea or goals]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+  - Grep
+  - Glob
+---
+<objective>
+Create the `.autodev/` project state for a new or existing codebase without over-planning.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/new-project.md
+@~/.claude/autodev/templates/config.json
+@~/.claude/autodev/templates/project.md
+@~/.claude/autodev/templates/requirements.md
+@~/.claude/autodev/templates/roadmap.md
+@~/.claude/autodev/templates/state.md
+</execution_context>
+
+<process>
+Execute the workflow in @~/.claude/autodev/workflows/new-project.md end-to-end.
+</process>

package/commands/autodev/plan-phase.md

@@ -0,0 +1,25 @@
+---
+name: autodev:plan-phase
+description: Create a practical plan for one roadmap phase
+argument-hint: "[phase-number]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+  - Grep
+  - Glob
+  - WebFetch
+---
+<objective>
+Create or update a single executable phase plan under `.autodev/phases/`.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/plan-phase.md
+@~/.claude/autodev/templates/plan.md
+</execution_context>
+
+<process>
+Execute the workflow in @~/.claude/autodev/workflows/plan-phase.md end-to-end.
+</process>

package/commands/autodev/progress.md

@@ -0,0 +1,18 @@
+---
+name: autodev:progress
+description: Show the current autodev status for the project
+allowed-tools:
+  - Read
+  - Bash
+---
+<objective>
+Render the current `.autodev/` progress and next recommended command.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/progress.md
+</execution_context>
+
+<process>
+Execute the workflow in @~/.claude/autodev/workflows/progress.md end-to-end.
+</process>

package/commands/autodev/verify-work.md

@@ -0,0 +1,24 @@
+---
+name: autodev:verify-work
+description: Run lightweight user acceptance testing for a phase
+argument-hint: "[phase-number]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+  - Grep
+  - Glob
+---
+<objective>
+Record manual verification for one phase and keep the next step clear.
+</objective>
+
+<execution_context>
+@~/.claude/autodev/workflows/verify-work.md
+@~/.claude/autodev/templates/uat.md
+</execution_context>
+
+<process>
+Execute the workflow in @~/.claude/autodev/workflows/verify-work.md end-to-end.
+</process>