@ghl-ai/aw 0.1.70 → 0.1.71

package/cli.mjs

@@ -60,6 +60,9 @@ function parseArgs(argv) {
     } else if (arg === '-v' || arg === '--verbose') {
       args['-v'] = true;
       i++;
+    } else if (arg === '-y') {
+      args['-y'] = true;
+      i++;
     } else if (arg === '--version') {
       args['--version'] = true;
       i++;
@@ -150,8 +153,8 @@ function printHelp() {
 
     sec('Upload'),
     cmd('aw push', 'Push all modified files (creates one PR)'),
-    cmd('aw push --aw-docs-only', 'Publish generated .aw_docs companions and print share links'),
     cmd('aw push --aw-docs-only --feature <slug>', 'Publish one .aw_docs feature folder and print share links'),
+    cmd('aw push --aw-docs-only --all', 'Publish ALL .aw_docs feature folders (explicit opt-in; otherwise scope with --feature)'),
     cmd('aw push <path>', 'Push file, folder, or namespace to registry'),
     cmd('aw push-rules [path]', 'Push platform rules to platform-docs'),
     cmd('aw push --dry-run [path]', 'Preview what would be pushed'),
@@ -163,6 +166,7 @@ function printHelp() {
     cmd('aw docs validate --feature <slug>', 'Validate .aw_docs planning HTML companions before build handoff'),
     cmd('aw status', 'Show synced paths, modified files & conflicts'),
     cmd('aw doctor', 'Run a health check for routing, MCP, plugin, and AW ECC surfaces'),
+    cmd('aw doctor --fix', 'Apply safe, deduped doctor fixes after confirmation'),
     cmd('aw link', 'Link current project as a git worktree (wires IDE symlinks)'),
     cmd('aw routing status', 'Show global AW session-routing mode for Claude/Cursor/Codex'),
     cmd('aw routing disable', 'Disable default AW router/rules injection globally'),
@@ -236,7 +240,11 @@ export async function run(argv) {
     process.exit(0);
   }
 
-  if (args['--help'] && !command) {
+  // Help must short-circuit BEFORE dispatching any command. Otherwise a
+  // command combined with --help (e.g. `aw push --help`) skips this gate and
+  // executes the command — which is how `aw push --help` triggered a real
+  // publish instead of printing help.
+  if (args['--help']) {
     printHelp();
     process.exit(0);
   }

package/commands/doctor.mjs

@@ -1,8 +1,10 @@
-import { execSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, readFileSync, readlinkSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
+import * as p from '@clack/prompts';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { AW_ECC_TAG } from '../ecc.mjs';
@@ -16,6 +18,45 @@ const STATUS_LABEL = {
   warn: chalk.yellow('WARN'),
   fail: chalk.red('FAIL'),
 };
+const AW_BIN_PATH = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin.js');
+const FIX_COMMANDS = [
+  { key: 'init', display: 'aw init --silent', argv: ['init', '--silent'], snippets: ['aw init'] },
+  { key: 'pull-platform', display: 'aw pull platform --silent', argv: ['pull', 'platform', '--silent'], snippets: ['aw pull platform'] },
+  { key: 'routing-enable', display: 'aw routing enable', argv: ['routing', 'enable'], snippets: ['aw routing enable'] },
+  { key: 'link', display: 'aw link', argv: ['link'], snippets: ['aw link'] },
+  {
+    key: 'integrations-add-context-mode',
+    display: 'aw integrations add context-mode',
+    argv: ['integrations', 'add', 'context-mode'],
+    snippets: ['aw integrations add context-mode'],
+  },
+];
+const FIX_COMMAND_BY_SNIPPET = new Map(FIX_COMMANDS.flatMap(command =>
+  command.snippets.map(snippet => [snippet, command]),
+));
+const FIX_COMMAND_ORDER = new Map(FIX_COMMANDS.map((command, index) => [command.key, index]));
+const GLOBAL_INSTALL_REPAIR_CHECK_IDS = new Set([
+  'claude-home-hooks',
+  'claude-install-state',
+  'claude-mcp',
+  'claude-home-instructions',
+  'codex-install-state',
+  'codex-mcp',
+  'codex-prompts',
+  'codex-agents-md',
+  'cursor-install-state',
+  'cursor-mcp',
+  'cursor-home-instructions',
+  'cursor-commands',
+  'aw-ecc',
+]);
+const ROUTING_REPAIR_CHECK_IDS = new Set([
+  'routing-mode',
+  'repo-legacy-routing',
+  'claude-session-start',
+  'codex-routing',
+  'cursor-routing',
+]);
 
 const GENERATED_RULE_HEADER = '<!-- Generated by aw — do not edit manually -->';
 const AW_ROUTER_BRIDGE_START_MARKER = '<!-- aw-managed:start router-bridge -->';
@@ -1066,24 +1107,329 @@ function statusIcon(status) {
   }
 }
 
-export function doctorCommand() {
-  const homeDir = homedir();
-  const report = getDoctorReport(homeDir, process.cwd());
+function normalizeAwSnippet(snippet) {
+  return String(snippet || '').trim().replace(/\s+/g, ' ');
+}
 
-  fmt.intro('aw doctor');
+function backtickedAwSnippets(fix) {
+  const snippets = [];
+  for (const match of String(fix || '').matchAll(/`([^`]+)`/g)) {
+    const snippet = normalizeAwSnippet(match[1]);
+    if (snippet.startsWith('aw ')) snippets.push(snippet);
+  }
+  return snippets;
+}
+
+export function extractFixCommands(fix) {
+  const commands = [];
+  const seen = new Set();
+  for (const snippet of backtickedAwSnippets(fix)) {
+    const command = FIX_COMMAND_BY_SNIPPET.get(snippet);
+    if (!command || seen.has(command.key)) continue;
+    commands.push(command);
+    seen.add(command.key);
+  }
+  return commands;
+}
+
+function hasGlobalInstallRepair(report) {
+  return report.checks.some(check =>
+    check.status !== 'pass' && (
+      GLOBAL_INSTALL_REPAIR_CHECK_IDS.has(check.id)
+      || String(check.id || '').endsWith('-install-state')
+    ),
+  );
+}
+
+function isRoutingRepairCheck(check) {
+  return ROUTING_REPAIR_CHECK_IDS.has(check.id) || String(check.id || '').includes('routing');
+}
+
+function commandByKey(commands, key) {
+  return commands.find(command => command.key === key) || null;
+}
+
+function chooseFixCommand(check, commands, report) {
+  const init = commandByKey(commands, 'init');
+  const pullPlatform = commandByKey(commands, 'pull-platform');
+  const routingEnable = commandByKey(commands, 'routing-enable');
+  const link = commandByKey(commands, 'link');
+  const hasGlobalRepair = hasGlobalInstallRepair(report);
+
+  if (init && pullPlatform) {
+    return hasGlobalRepair ? init : pullPlatform;
+  }
+
+  if (init && routingEnable) {
+    return hasGlobalRepair && !isRoutingRepairCheck(check) ? init : routingEnable;
+  }
+
+  if (init && link) {
+    return hasGlobalRepair ? init : link;
+  }
+
+  return sortFixCommands(commands)[0] || null;
+}
+
+export function sortFixCommands(commands) {
+  return [...commands].sort((left, right) => (
+    (FIX_COMMAND_ORDER.get(left.key) ?? Number.MAX_SAFE_INTEGER)
+    - (FIX_COMMAND_ORDER.get(right.key) ?? Number.MAX_SAFE_INTEGER)
+  ));
+}
+
+export function buildDoctorFixPlan(report) {
+  const commandsByKey = new Map();
+  const manualFixes = [];
+  const seenManualFixes = new Set();
+
+  for (const check of report.checks) {
+    if (!check.fix || check.status === 'pass') continue;
+
+    const commands = extractFixCommands(check.fix);
+    const selected = commands.length > 0 ? chooseFixCommand(check, commands, report) : null;
+
+    if (selected) {
+      const existing = commandsByKey.get(selected.key) || {
+        ...selected,
+        sourceCheckIds: [],
+        sourceFixes: [],
+      };
+      existing.sourceCheckIds.push(check.id);
+      if (!existing.sourceFixes.includes(check.fix)) {
+        existing.sourceFixes.push(check.fix);
+      }
+      commandsByKey.set(selected.key, existing);
+      continue;
+    }
+
+    if (!seenManualFixes.has(check.fix)) {
+      manualFixes.push(check.fix);
+      seenManualFixes.add(check.fix);
+    }
+  }
+
+  return {
+    commands: sortFixCommands(commandsByKey.values()),
+    manualFixes,
+  };
+}
+
+export function diffDoctorReports(beforeReport, afterReport) {
+  const beforeById = new Map(beforeReport.checks.map(check => [check.id, check]));
+  const afterById = new Map(afterReport.checks.map(check => [check.id, check]));
+  const ids = [...new Set([...beforeById.keys(), ...afterById.keys()])];
+
+  return ids
+    .map(id => {
+      const before = beforeById.get(id);
+      const after = afterById.get(id);
+      if (!before || !after) {
+        return {
+          id,
+          title: after?.title || before?.title || id,
+          beforeStatus: before?.status || 'missing',
+          beforeSummary: before?.summary || '',
+          afterStatus: after?.status || 'missing',
+          afterSummary: after?.summary || '',
+        };
+      }
+      if (before.status === after.status && before.summary === after.summary) return null;
+      return {
+        id,
+        title: after.title || before.title || id,
+        beforeStatus: before.status,
+        beforeSummary: before.summary,
+        afterStatus: after.status,
+        afterSummary: after.summary,
+      };
+    })
+    .filter(Boolean);
+}
 
-  const summary = report.checks
+function formatDoctorSummary(report) {
+  return report.checks
     .map(check => `${statusIcon(check.status)} ${check.title}: ${check.summary}`)
     .join('\n');
-  fmt.note(summary, `Health ${STATUS_LABEL[report.status]}`);
+}
+
+function formatFixPlan(plan) {
+  const lines = [];
+  if (plan.commands.length > 0) {
+    lines.push('Will run:');
+    lines.push(...plan.commands.map(command => `- ${command.display}`));
+  } else {
+    lines.push('No automatic fixes are available for the current doctor report.');
+  }
 
-  if (report.fixes.length > 0) {
-    fmt.note(report.fixes.map(fix => `- ${fix}`).join('\n'), 'Suggested Fixes');
+  if (plan.manualFixes.length > 0) {
+    lines.push('');
+    lines.push('Not fixable automatically:');
+    lines.push(...plan.manualFixes.map(fix => `- ${fix}`));
   }
 
+  return lines.join('\n');
+}
+
+function formatFixes(fixes) {
+  return fixes.map(fix => `- ${fix}`).join('\n');
+}
+
+function formatExecutedFixes(results) {
+  if (results.length === 0) return 'No automatic fixes were executed.';
+  return results
+    .map(result => {
+      const icon = result.ok ? chalk.green('✓') : chalk.red('✖');
+      const suffix = result.ok ? '' : ` (exit ${result.exitCode})`;
+      return `${icon} ${result.command.display}${suffix}`;
+    })
+    .join('\n');
+}
+
+function formatDoctorDiff(diff) {
+  if (diff.length === 0) return 'No check status changes detected.';
+  return diff
+    .map(change => {
+      const statusChange = `${change.beforeStatus.toUpperCase()} -> ${change.afterStatus.toUpperCase()}`;
+      return `${change.title}: ${statusChange}\n  before: ${change.beforeSummary}\n  after: ${change.afterSummary}`;
+    })
+    .join('\n');
+}
+
+function runAwFixCommand(command, { cwd = process.cwd(), env = process.env } = {}) {
+  const awBin = env.AW_DOCTOR_FIX_AW_BIN || AW_BIN_PATH;
+  const result = spawnSync(process.execPath, [awBin, ...command.argv], {
+    cwd,
+    env: {
+      ...env,
+      AW_DOCTOR_FIX: '1',
+    },
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: false,
+  });
+
+  return {
+    command,
+    ok: !result.error && result.status === 0,
+    exitCode: result.status ?? 1,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error || null,
+  };
+}
+
+function executeDoctorFixPlan(plan, options = {}) {
+  const results = [];
+  for (const command of plan.commands) {
+    const result = runAwFixCommand(command, options);
+    results.push(result);
+    if (!result.ok) break;
+  }
+  return results;
+}
+
+async function confirmDoctorFixPlan(plan) {
+  const answer = await p.confirm({
+    message: `Run ${plan.commands.length} automatic doctor fix${plan.commands.length === 1 ? '' : 'es'}?`,
+    initialValue: false,
+  });
+  return !p.isCancel(answer) && answer === true;
+}
+
+function setDoctorExitCode(report) {
   if (report.status === 'fail') {
     process.exitCode = 1;
   }
+}
+
+export async function doctorCommand(args = {}) {
+  const homeDir = homedir();
+  const cwd = process.cwd();
+  const report = getDoctorReport(homeDir, cwd);
+  const shouldFix = args['--fix'] === true;
+  const assumeYes = args['--yes'] === true || args['-y'] === true;
+  const dryRun = args['--dry-run'] === true;
+
+  fmt.intro('aw doctor');
+
+  fmt.note(formatDoctorSummary(report), `Health ${STATUS_LABEL[report.status]}`);
+
+  if (!shouldFix) {
+    if (report.fixes.length > 0) {
+      fmt.note(formatFixes(report.fixes), 'Suggested Fixes');
+    }
 
-  fmt.outro(`⟁  aw doctor complete (${report.status.toUpperCase()})`);
+    setDoctorExitCode(report);
+    fmt.outro(`⟁  aw doctor complete (${report.status.toUpperCase()})`);
+    return;
+  }
+
+  const plan = buildDoctorFixPlan(report);
+  fmt.note(formatFixPlan(plan), 'Auto-Fix Plan');
+
+  if (dryRun) {
+    setDoctorExitCode(report);
+    fmt.outro(`⟁  aw doctor auto-fix dry run complete (${report.status.toUpperCase()})`);
+    return;
+  }
+
+  if (plan.commands.length === 0) {
+    setDoctorExitCode(report);
+    fmt.outro(`⟁  aw doctor auto-fix complete (${report.status.toUpperCase()})`);
+    return;
+  }
+
+  if (!assumeYes && !process.stdin.isTTY) {
+    process.exitCode = 1;
+    fmt.note('Auto-fix needs confirmation in an interactive terminal. Re-run with `aw doctor --fix --yes` to execute the plan non-interactively.', 'Confirmation Required');
+    fmt.outro('⟁  aw doctor auto-fix cancelled');
+    return;
+  }
+
+  if (!assumeYes) {
+    const confirmed = await confirmDoctorFixPlan(plan);
+    if (!confirmed) {
+      setDoctorExitCode(report);
+      fmt.outro('⟁  aw doctor auto-fix cancelled');
+      return;
+    }
+  }
+
+  const results = executeDoctorFixPlan(plan, { cwd, env: process.env });
+  const failedResult = results.find(result => !result.ok);
+  const afterReport = getDoctorReport(homeDir, cwd);
+  const diff = diffDoctorReports(report, afterReport);
+
+  fmt.note(formatExecutedFixes(results), 'Executed Fixes');
+
+  if (failedResult) {
+    const details = [
+      `${failedResult.command.display} failed with exit ${failedResult.exitCode}.`,
+      failedResult.stderr.trim() ? `stderr:\n${failedResult.stderr.trim()}` : null,
+      failedResult.stdout.trim() ? `stdout:\n${failedResult.stdout.trim()}` : null,
+      failedResult.error ? `error: ${failedResult.error.message}` : null,
+    ].filter(Boolean).join('\n\n');
+    fmt.note(details, 'Auto-fix command failed');
+  }
+
+  fmt.note(formatDoctorDiff(diff), 'Before/After');
+
+  const remainingPlan = buildDoctorFixPlan(afterReport);
+  if (remainingPlan.manualFixes.length > 0) {
+    fmt.note(formatFixes(remainingPlan.manualFixes), 'Remaining Manual Fixes');
+  }
+
+  if (failedResult || afterReport.status === 'fail') {
+    process.exitCode = 1;
+  }
+
+  fmt.outro(`⟁  aw doctor auto-fix complete (${afterReport.status.toUpperCase()})`);
 }
+
+export const __test__ = {
+  extractFixCommands,
+  buildDoctorFixPlan,
+  sortFixCommands,
+  diffDoctorReports,
+};

package/commands/push.mjs

@@ -188,6 +188,20 @@ function resolveAwDocsScope(input, featureFlag) {
   return flagScope || inputScope;
 }
 
+// A docs-only publish with no resolved scope would sweep EVERY
+// .aw_docs/features/** folder into the shared docs repo. Require an explicit
+// --all opt-in so an unscoped invocation (or one that lands here accidentally)
+// fails closed instead of mass-publishing unrelated feature folders.
+function assertDocsOnlyScopeOrAll(scope, all) {
+  if (!scope && all !== true) {
+    throw new Error(
+      'Refusing to publish ALL .aw_docs/features/** at once. Pass --feature <slug> ' +
+      '(or a .aw_docs/features/<slug> path) to publish one feature folder, or pass ' +
+      '--all to publish everything intentionally.'
+    );
+  }
+}
+
 function collectProjectAwDocs(cwd, home, scope = null) {
   const projectRoot = getProjectRoot(cwd, home);
   const source = join(projectRoot, AW_DOCS_DIR);
@@ -1284,6 +1298,7 @@ export async function pushCommand(args) {
   if (docsOnly) {
     try {
       const scope = resolveAwDocsScope(input, args['--feature']);
+      assertDocsOnlyScopeOrAll(scope, args['--all'] === true);
       const result = await publishProjectAwDocs(cwd, HOME, dryRun, scope);
       if (!result.hasDocs) {
         fmt.cancel(scope
@@ -1608,3 +1623,10 @@ function groupBy(arr, key) {
   }
   return result;
 }
+
+export const __test__ = {
+  featureScopeFromInput,
+  awDocsFeatureScope,
+  resolveAwDocsScope,
+  assertDocsOnlyScopeOrAll,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {