@ghl-ai/aw 0.1.0 → 0.1.1

package/cli.mjs

@@ -128,7 +128,7 @@ export async function run(argv) {
 
   if (command && COMMANDS[command]) {
     const handler = await COMMANDS[command]();
-    handler(args);
+    await handler(args);
     return;
   }
 

package/commands/init.mjs

@@ -1,8 +1,10 @@
 // commands/init.mjs — Initialize workspace config + pull ghl + template
 
-import { mkdirSync, existsSync } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { select, isCancel } from '@clack/prompts';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
@@ -11,11 +13,72 @@ import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
 
-export function initCommand(args) {
+// Scope definitions
+const SCOPES = {
+  user: {
+    label: 'Install for you (user scope)',
+    hint: 'Available in all your projects — stored in ~/.claude/',
+    rootDir: () => homedir(),
+    gitignore: false,
+  },
+  project: {
+    label: 'Install for all collaborators (project scope)',
+    hint: 'Checked into git — shared with your whole team via .claude/',
+    rootDir: () => process.cwd(),
+    gitignore: false,
+  },
+  local: {
+    label: 'Install for you, in this repo only (local scope)',
+    hint: 'Added to .gitignore — only you see it in this project',
+    rootDir: () => process.cwd(),
+    gitignore: true,
+  },
+};
+
+async function pickScope(preselected) {
+  if (preselected && SCOPES[preselected]) return preselected;
+
+  const result = await select({
+    message: 'Where would you like to install?',
+    options: Object.entries(SCOPES).map(([value, s]) => ({
+      value,
+      label: s.label,
+      hint: s.hint,
+    })),
+    initialValue: 'project',
+  });
+
+  if (isCancel(result)) {
+    fmt.cancel('Installation cancelled.');
+    process.exit(0);
+  }
+
+  return result;
+}
+
+function addToGitignore(cwd, patterns) {
+  const gitignorePath = join(cwd, '.gitignore');
+  const toAdd = patterns.filter(p => {
+    if (!existsSync(gitignorePath)) return true;
+    const content = readFileSync(gitignorePath, 'utf8');
+    return !content.split('\n').some(line => line.trim() === p);
+  });
+
+  if (toAdd.length === 0) return;
+
+  const block = `\n# Agentic Workspace (local scope)\n${toAdd.join('\n')}\n`;
+  if (existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, readFileSync(gitignorePath, 'utf8') + block);
+  } else {
+    writeFileSync(gitignorePath, block.trimStart());
+  }
+  fmt.logStep(`Added to .gitignore: ${toAdd.join(', ')}`);
+}
+
+export async function initCommand(args) {
   const namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const cwd = process.cwd();
-  const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw init');
 
@@ -28,6 +91,14 @@ export function initCommand(args) {
     fmt.cancel("'ghl' is a reserved namespace — it is the shared platform layer");
   }
 
+  // Pick install scope
+  const scopeKey = await pickScope(args['--scope']);
+  const scope = SCOPES[scopeKey];
+  const rootDir = scope.rootDir();
+  const workspaceDir = join(rootDir, '.aw_registry');
+
+  fmt.logStep(`Scope: ${chalk.bold(scope.label)}`);
+
   // Auto-detect user from GitHub if not provided
   if (!user) {
     try {
@@ -40,7 +111,7 @@ export function initCommand(args) {
   // Create workspace dir
   if (!existsSync(workspaceDir)) {
     mkdirSync(workspaceDir, { recursive: true });
-    fmt.logStep('Created .aw_registry/');
+    fmt.logStep(`Created ${scopeKey === 'user' ? '~/' : ''}.aw_registry/`);
   }
 
   // Check existing config
@@ -48,28 +119,49 @@ export function initCommand(args) {
     fmt.cancel('.sync-config.json already exists. Delete it to re-init.');
   }
 
-  // Create config
-  const cfg = config.create(workspaceDir, { namespace, user });
+  // Create config (store scope so other commands know where to look)
+  const cfg = config.create(workspaceDir, { namespace, user, scope: scopeKey });
 
   const infoLines = [
     namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
     user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
+    `${chalk.dim('scope:')}      ${scopeKey} → ${resolve(workspaceDir)}`,
   ].filter(Boolean).join('\n');
 
   fmt.note(infoLines, 'Config created');
 
   // Always pull ghl/ (platform layer)
-  pullCommand({ ...args, _positional: ['ghl'] });
+  pullCommand({ ...args, _positional: ['ghl'], _workspaceDir: workspaceDir });
 
   // Pull [template]/ as the team namespace
   if (namespace) {
-    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace });
+    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: workspaceDir });
   }
 
   // Post-pull IDE integration
-  linkWorkspace(cwd);
-  generateCommands(cwd);
-  copyInstructions(cwd, null, namespace);
-  initAwDocs(cwd);
-  setupMcp(cwd, namespace);
+  linkWorkspace(rootDir);
+  generateCommands(rootDir);
+  const instructionFiles = copyInstructions(rootDir, null, namespace);
+  initAwDocs(rootDir);
+  const mcpFiles = setupMcp(rootDir, namespace);
+
+  // Write manifest of files created by aw init so nuke only deletes what we made
+  const manifestPath = join(workspaceDir, '.created-files.json');
+  const createdFiles = [...instructionFiles, ...mcpFiles].map(p =>
+    p.startsWith(rootDir) ? p.slice(rootDir.length + 1) : p
+  );
+  writeFileSync(manifestPath, JSON.stringify(createdFiles, null, 2) + '\n');
+
+  // For local scope: add to .gitignore
+  if (scope.gitignore) {
+    addToGitignore(cwd, ['.aw_registry/', '.aw_docs/', '.claude/', '.cursor/', '.codex/', '.agents/', 'mcp.json', 'CLAUDE.md', 'AGENTS.md']);
+  }
+
+  fmt.outro(
+    scopeKey === 'user'
+      ? `Installed to ~/  — available in all your projects`
+      : scopeKey === 'project'
+      ? `Installed to .claude/  — commit this to share with your team`
+      : `Installed locally — added to .gitignore`
+  );
 }

package/commands/nuke.mjs

@@ -1,7 +1,7 @@
 // commands/nuke.mjs — Remove entire .aw_registry/ and all generated IDE files
 
 import { join } from 'node:path';
-import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync } from 'node:fs';
+import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync, readFileSync } from 'node:fs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 
@@ -9,22 +9,10 @@ import { chalk } from '../fmt.mjs';
 const IDE_DIRS = ['.claude', '.cursor', '.codex'];
 const CONTENT_TYPES = ['agents', 'skills', 'commands', 'blueprints', 'evals'];
 
-// Generated files from mcp.mjs + integrate.mjs
-const FILES_TO_CLEAN = [
-  '.claude/settings.local.json',
-  '.cursor/mcp.json',
-  '.codex/config.toml',
-  'mcp.json',
-  'CLAUDE.md',
-  'AGENTS.md',
-];
-
-// Dirs to remove if empty after cleanup (deepest first)
+// Dirs to remove if empty after cleanup (deepest first — IDE roots intentionally excluded)
 const DIRS_TO_PRUNE = [
   // IDE content dirs
   ...IDE_DIRS.flatMap(ide => CONTENT_TYPES.map(t => `${ide}/${t}`)),
-  // IDE root dirs
-  ...IDE_DIRS,
   // Codex agents dir
   '.agents/skills',
   '.agents',
@@ -40,7 +28,7 @@ export function nukeCommand(args) {
     fmt.cancel('No .aw_registry/ found — nothing to remove');
   }
 
-  // 1. Remove symlinks + generated files from all IDE dirs
+  // 1. Remove symlinks from all IDE dirs
   for (const ide of IDE_DIRS) {
     for (const type of CONTENT_TYPES) {
       const dir = join(cwd, ide, type);
@@ -61,14 +49,22 @@ export function nukeCommand(args) {
       rmSync(awCmdDir, { recursive: true, force: true });
     }
   }
+
   // 2. Clean .agents/skills/ (symlinks + generated Codex skill dirs)
   const agentsSkillsDir = join(cwd, '.agents/skills');
   if (existsSync(agentsSkillsDir)) {
     rmSync(agentsSkillsDir, { recursive: true, force: true });
   }
 
-  // 3. Remove generated files
-  for (const rel of FILES_TO_CLEAN) {
+  // 3. Remove only files that aw init actually created (from manifest)
+  const manifestPath = join(workspaceDir, '.created-files.json');
+  let filesToClean = [];
+  if (existsSync(manifestPath)) {
+    try {
+      filesToClean = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    } catch { /* ignore parse errors */ }
+  }
+  for (const rel of filesToClean) {
     const p = join(cwd, rel);
     try { if (existsSync(p)) rmSync(p); } catch { /* best effort */ }
   }
@@ -80,7 +76,7 @@ export function nukeCommand(args) {
     rmSync(awDocsDir, { recursive: true, force: true });
   }
 
-  // 5. Prune empty dirs
+  // 5. Prune empty dirs (IDE roots are excluded — never fully delete .claude/.cursor/.codex)
   for (const rel of DIRS_TO_PRUNE) {
     const p = join(cwd, rel);
     try {
@@ -90,6 +86,6 @@ export function nukeCommand(args) {
     } catch { /* best effort */ }
   }
 
-  fmt.logSuccess('Removed .aw_registry/ and all generated IDE files');
+  fmt.logSuccess('Removed .aw_registry/, .aw_docs/, and all generated IDE files');
   fmt.outro(`Run ${chalk.dim('aw init')} to start fresh`);
 }

package/integrate.mjs

@@ -92,6 +92,7 @@ export function generateCommands(cwd) {
  * Copy CLAUDE.md and AGENTS.md to project root.
  */
 export function copyInstructions(cwd, tempDir, namespace) {
+  const createdFiles = [];
   for (const file of ['CLAUDE.md', 'AGENTS.md']) {
     const dest = join(cwd, file);
     if (existsSync(dest)) continue;
@@ -105,6 +106,7 @@ export function copyInstructions(cwd, tempDir, namespace) {
         }
         writeFileSync(dest, content);
         fmt.logSuccess(`Created ${file}`);
+        createdFiles.push(dest);
         continue;
       }
     }
@@ -115,8 +117,10 @@ export function copyInstructions(cwd, tempDir, namespace) {
     if (content) {
       writeFileSync(dest, content);
       fmt.logSuccess(`Created ${file}`);
+      createdFiles.push(dest);
     }
   }
+  return createdFiles;
 }
 
 function generateClaudeMd(cwd, namespace) {

package/mcp.mjs

@@ -29,110 +29,98 @@ function detectPaths() {
 
 /**
  * Setup MCP configs for all IDEs. Only writes if file doesn't exist.
+ * Returns list of file paths that were actually created.
  */
 export function setupMcp(cwd, namespace) {
   const paths = detectPaths();
-  let created = 0;
+  const createdFiles = [];
+
+  const attempt = (filePath, contentFn, append = false) => {
+    if (writeIfMissing(filePath, contentFn, append)) {
+      createdFiles.push(filePath);
+    }
+  };
 
   // .claude/settings.local.json
-  created += writeIfMissing(
-    join(cwd, '.claude', 'settings.local.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (paths.gitJenkinsPath) {
-        servers['git-jenkins'] = {
-          command: 'node',
-          args: [paths.gitJenkinsPath],
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, '.claude', 'settings.local.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
+    }
+    if (paths.gitJenkinsPath) {
+      servers['git-jenkins'] = { command: 'node', args: [paths.gitJenkinsPath] };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
   // .cursor/mcp.json
-  created += writeIfMissing(
-    join(cwd, '.cursor', 'mcp.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (paths.gitJenkinsPath) {
-        servers['git-jenkins'] = {
-          command: 'node',
-          args: [paths.gitJenkinsPath],
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, '.cursor', 'mcp.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
+    }
+    if (paths.gitJenkinsPath) {
+      servers['git-jenkins'] = { command: 'node', args: [paths.gitJenkinsPath] };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
   // .codex/config.toml — append MCP servers
   const codexConfig = join(cwd, '.codex', 'config.toml');
   if (!hasMcpSection(codexConfig)) {
-    created += writeIfMissing(
-      codexConfig,
-      () => {
-        const lines = [];
-        if (paths.ghlAiBridge) {
-          lines.push(
-            '[mcp_servers.ghl-ai]',
-            'command = "node"',
-            `args = ["${paths.ghlAiBridge}"]`,
-            '',
-            '[mcp_servers.ghl-ai.env]',
-            `GHL_MCP_URL = "${paths.ghlMcpUrl}"`,
-            `TEAM_NAME = "${namespace || ''}"`,
-            '',
-          );
-        }
-        if (paths.gitJenkinsPath) {
-          lines.push(
-            '[mcp_servers.git-jenkins]',
-            'command = "node"',
-            `args = ["${paths.gitJenkinsPath}"]`,
-            '',
-          );
-        }
-        if (lines.length === 0) return null;
-        return lines.join('\n');
-      },
-      true // append mode
-    );
+    attempt(codexConfig, () => {
+      const lines = [];
+      if (paths.ghlAiBridge) {
+        lines.push(
+          '[mcp_servers.ghl-ai]',
+          'command = "node"',
+          `args = ["${paths.ghlAiBridge}"]`,
+          '',
+          '[mcp_servers.ghl-ai.env]',
+          `GHL_MCP_URL = "${paths.ghlMcpUrl}"`,
+          `TEAM_NAME = "${namespace || ''}"`,
+          '',
+        );
+      }
+      if (paths.gitJenkinsPath) {
+        lines.push(
+          '[mcp_servers.git-jenkins]',
+          'command = "node"',
+          `args = ["${paths.gitJenkinsPath}"]`,
+          '',
+        );
+      }
+      if (lines.length === 0) return null;
+      return lines.join('\n');
+    }, true /* append mode */);
   }
 
   // mcp.json at project root (Claude Code auto-discovery)
-  created += writeIfMissing(
-    join(cwd, 'mcp.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, 'mcp.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
-  if (created > 0) {
-    fmt.logSuccess(`Created ${created} MCP config${created > 1 ? 's' : ''}`);
+  if (createdFiles.length > 0) {
+    fmt.logSuccess(`Created ${createdFiles.length} MCP config${createdFiles.length > 1 ? 's' : ''}`);
   }
 
   const warnings = [];
@@ -142,13 +130,13 @@ export function setupMcp(cwd, namespace) {
     fmt.logWarn(w);
   }
 
-  return created;
+  return createdFiles;
 }
 
 function writeIfMissing(filePath, contentFn, append = false) {
-  if (!append && existsSync(filePath)) return 0;
+  if (!append && existsSync(filePath)) return false;
   const content = contentFn();
-  if (!content) return 0;
+  if (!content) return false;
   mkdirSync(join(filePath, '..'), { recursive: true });
   if (append && existsSync(filePath)) {
     const existing = readFileSync(filePath, 'utf8');
@@ -156,7 +144,7 @@ function writeIfMissing(filePath, contentFn, append = false) {
   } else {
     writeFileSync(filePath, content);
   }
-  return 1;
+  return true;
 }
 
 function hasMcpSection(filePath) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
-    "aw": "./bin.js"
+    "aw": "bin.js"
   },
   "files": [
     "bin.js",