@ghl-ai/aw 0.1.0

package/apply.mjs

@@ -0,0 +1,49 @@
+// apply.mjs — Apply sync plan (file operations). Zero dependencies.
+
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+function writeConflictMarkers(filePath, localContent, registryContent) {
+  writeFileSync(filePath, [
+    '<<<<<<< LOCAL',
+    localContent.trimEnd(),
+    '=======',
+    registryContent.trimEnd(),
+    '>>>>>>> REGISTRY',
+    '',
+  ].join('\n'));
+}
+
+/**
+ * Apply actions to the workspace.
+ * All actions are file-level (no directory-level operations).
+ * Returns count of files with conflicts.
+ */
+export function applyActions(actions) {
+  let conflicts = 0;
+
+  for (const act of actions) {
+    switch (act.action) {
+      case 'ADD':
+      case 'UPDATE':
+        mkdirSync(dirname(act.targetPath), { recursive: true });
+        cpSync(act.sourcePath, act.targetPath);
+        break;
+
+      case 'CONFLICT': {
+        const local = existsSync(act.targetPath) ? readFileSync(act.targetPath, 'utf8') : '';
+        const registry = readFileSync(act.sourcePath, 'utf8');
+        mkdirSync(dirname(act.targetPath), { recursive: true });
+        writeConflictMarkers(act.targetPath, local, registry);
+        conflicts++;
+        break;
+      }
+
+      case 'ORPHAN':
+      case 'UNCHANGED':
+        break;
+    }
+  }
+
+  return conflicts;
+}

package/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// Standalone bin entrypoint for published npm package
+import('./cli.mjs').then(m => m.run(process.argv.slice(2)));

package/cli.mjs

@@ -0,0 +1,141 @@
+// cli.mjs — Argument parser and command router
+
+import * as fmt from './fmt.mjs';
+import { chalk } from './fmt.mjs';
+
+const VERSION = '0.1.0';
+
+const COMMANDS = {
+  init:   () => import('./commands/init.mjs').then(m => m.initCommand),
+  pull:    () => import('./commands/pull.mjs').then(m => m.pullCommand),
+  push:    () => import('./commands/push.mjs').then(m => m.pushCommand),
+  drop:    () => import('./commands/drop.mjs').then(m => m.dropCommand),
+  status:  () => import('./commands/status.mjs').then(m => m.statusCommand),
+  search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
+  nuke:    () => import('./commands/nuke.mjs').then(m => m.nukeCommand),
+};
+
+function parseArgs(argv) {
+  const args = { _positional: [] };
+  let command = null;
+  let i = 0;
+
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (!command && !arg.startsWith('-') && COMMANDS[arg]) {
+      command = arg;
+      i++;
+      continue;
+    }
+
+    if (arg === '--dry-run') {
+      args['--dry-run'] = true;
+      i++;
+    } else if (arg === '-v' || arg === '--verbose') {
+      args['-v'] = true;
+      i++;
+    } else if (arg === '--version') {
+      args['--version'] = true;
+      i++;
+    } else if (arg === '-h' || arg === '--help') {
+      args['--help'] = true;
+      i++;
+    } else if (arg.startsWith('--') && i + 1 < argv.length && !argv[i + 1].startsWith('-')) {
+      args[arg] = argv[i + 1];
+      i += 2;
+    } else if (arg.startsWith('--')) {
+      args[arg] = true;
+      i++;
+    } else {
+      args._positional.push(arg);
+      i++;
+    }
+  }
+
+  return { command, args };
+}
+
+function printHelp() {
+  fmt.banner('aw', {
+    subtitle: `  ${chalk.dim('v' + VERSION)}  ${chalk.hex('#FF6B35')('Agentic Workspace CLI')}  ${chalk.dim('— pull, push & manage agents, skills and more from the registry')}`,
+  });
+
+  const cmd = (c, d) => `  ${chalk.hex('#FF6B35')(c.padEnd(38))} ${chalk.dim(d)}`;
+  const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
+  const help = [
+    sec('Setup'),
+    cmd('aw init', 'Initialize workspace & pull ghl platform layer'),
+    cmd('aw init --namespace <team>', 'Init with ghl + team template'),
+
+    sec('Download'),
+    cmd('aw pull', 'Re-pull all synced paths (like git pull)'),
+    cmd('aw pull <path>', 'Pull agents, skills & more from registry'),
+    cmd('aw pull --dry-run <path>', 'Preview what would be downloaded'),
+
+    sec('Upload'),
+    cmd('aw push', 'Show modified files ready to push'),
+    cmd('aw push <path>', 'Create a PR to add/update registry content'),
+    cmd('aw push --dry-run <path>', 'Preview the upload without creating PR'),
+
+    sec('Discover'),
+    cmd('aw search <query>', 'Find agents & skills (local + registry)'),
+
+    sec('Manage'),
+    cmd('aw status', 'Show synced paths, modified files & conflicts'),
+    cmd('aw drop <path>', 'Stop syncing or delete local content'),
+    cmd('aw nuke', 'Remove entire .aw_registry/ & start fresh'),
+
+    sec('Examples'),
+    '',
+    `  ${chalk.dim('# Pull content from registry using path')}`,
+    cmd('aw pull ghl', 'All shared platform agents & skills'),
+    cmd('aw pull <team>', 'Everything from a team namespace'),
+    cmd('aw pull <team>/agents', 'All agents from a team'),
+    cmd('aw pull <team>/agents/<name>', 'One specific agent'),
+    cmd('aw pull <team>/skills/<name>', 'One specific skill folder'),
+    '',
+    `  ${chalk.dim('# Push your local changes to registry')}`,
+    cmd('aw push .aw_registry/agents/<name>.md', 'Upload an agent'),
+    cmd('aw push .aw_registry/skills/<name>/', 'Upload a skill folder'),
+    '',
+    `  ${chalk.dim('# Remove content from workspace')}`,
+    cmd('aw drop <team>', 'Stop syncing a namespace (removes all files)'),
+    cmd('aw drop <team>/agents/<name>', 'Stop syncing one agent'),
+    cmd('aw drop .aw_registry/agents/<name>.md', 'Delete a local file (next pull restores it)'),
+    '',
+    `  ${chalk.dim('# All commands accept both registry paths and local paths')}`,
+    `  ${chalk.dim('#   registry:  <team>/agents/<name>')}`,
+    `  ${chalk.dim('#   local:     .aw_registry/<team>/agents/<name>.md')}`,
+    '',
+  ].join('\n');
+
+  console.log(help);
+}
+
+export async function run(argv) {
+  const { command, args } = parseArgs(argv);
+
+  if (args['--version']) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  if (args['--help'] && !command) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (command && COMMANDS[command]) {
+    const handler = await COMMANDS[command]();
+    handler(args);
+    return;
+  }
+
+  if (!command) {
+    printHelp();
+    process.exit(0);
+  }
+
+  fmt.cancel(`Unknown command: ${command}`);
+}

package/commands/drop.mjs

@@ -0,0 +1,88 @@
+// commands/drop.mjs — Remove file or synced path from workspace
+
+import { join, resolve } from 'node:path';
+import { rmSync, existsSync } from 'node:fs';
+import * as config from '../config.mjs';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+import { matchesAny } from '../glob.mjs';
+import { resolveInput } from '../paths.mjs';
+import { load as loadManifest, save as saveManifest } from '../manifest.mjs';
+
+export function dropCommand(args) {
+  const input = args._positional?.[0];
+  const cwd = process.cwd();
+  const workspaceDir = join(cwd, '.aw_registry');
+
+  fmt.intro('aw drop');
+
+  if (!input) {
+    fmt.cancel('Missing target. Usage:\n  aw drop example-team                         (stop syncing namespace)\n  aw drop example-team/skills/example-skill     (stop syncing skill)\n  aw drop example-team/skills/example-skill/SKILL  (delete single file)');
+  }
+
+  const cfg = config.load(workspaceDir);
+  if (!cfg) fmt.cancel('No .sync-config.json found. Run: aw init');
+
+  // Resolve to registry path (accepts both local and registry paths)
+  const resolved = resolveInput(input, workspaceDir);
+  const regPath = resolved.registryPath;
+
+  if (!regPath) {
+    fmt.cancel(`Could not resolve "${input}" to a registry path`);
+  }
+
+  // Check if this path (or a parent) is in config → remove from config + delete files
+  const isConfigPath = cfg.include.some(p => p === regPath || p.startsWith(regPath + '/'));
+
+  if (isConfigPath) {
+    config.removePattern(workspaceDir, regPath);
+    fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sync config`);
+  }
+
+  // Delete matching local files
+  const removed = deleteMatchingFiles(workspaceDir, regPath);
+
+  if (removed > 0) {
+    fmt.logInfo(`${chalk.bold(removed)} file${removed > 1 ? 's' : ''} removed from workspace`);
+  } else if (!isConfigPath) {
+    fmt.cancel(`Nothing found for ${chalk.cyan(regPath)}.\n\n  Use ${chalk.dim('aw status')} to see synced paths.`);
+  }
+
+  if (!isConfigPath && removed > 0) {
+    fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
+  }
+
+  fmt.outro('Done');
+}
+
+/**
+ * Find and delete local files whose registry path matches the given path.
+ */
+function deleteMatchingFiles(workspaceDir, path) {
+  const manifest = loadManifest(workspaceDir);
+  let removed = 0;
+
+  for (const [manifestKey] of Object.entries(manifest.files)) {
+    const registryPath = manifestKeyToRegistryPath(manifestKey);
+
+    if (matchesAny(registryPath, [path])) {
+      const filePath = join(workspaceDir, manifestKey);
+      if (existsSync(filePath)) {
+        rmSync(filePath, { recursive: true, force: true });
+        removed++;
+      }
+      delete manifest.files[manifestKey];
+    }
+  }
+
+  saveManifest(workspaceDir, manifest);
+  return removed;
+}
+
+/**
+ * Convert manifest key to registry path.
+ * Manifest key now mirrors registry: "ghl/agents/architecture-reviewer.md" → "ghl/agents/architecture-reviewer"
+ */
+function manifestKeyToRegistryPath(manifestKey) {
+  return manifestKey.replace(/\.md$/, '');
+}

package/commands/init.mjs

@@ -0,0 +1,75 @@
+// commands/init.mjs — Initialize workspace config + pull ghl + template
+
+import { mkdirSync, existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import * as config from '../config.mjs';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+import { pullCommand } from './pull.mjs';
+import { linkWorkspace } from '../link.mjs';
+import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
+import { setupMcp } from '../mcp.mjs';
+
+export 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');
+
+  // Validate namespace slug if provided
+  if (namespace && !/^[a-z][a-z0-9-]{1,38}[a-z0-9]$/.test(namespace)) {
+    fmt.cancel(`Invalid namespace '${namespace}' — must match: ^[a-z][a-z0-9-]{1,38}[a-z0-9]$`);
+  }
+
+  if (namespace === 'ghl') {
+    fmt.cancel("'ghl' is a reserved namespace — it is the shared platform layer");
+  }
+
+  // Auto-detect user from GitHub if not provided
+  if (!user) {
+    try {
+      user = execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch {
+      // gh not available or not logged in — skip
+    }
+  }
+
+  // Create workspace dir
+  if (!existsSync(workspaceDir)) {
+    mkdirSync(workspaceDir, { recursive: true });
+    fmt.logStep('Created .aw_registry/');
+  }
+
+  // Check existing config
+  if (config.exists(workspaceDir)) {
+    fmt.cancel('.sync-config.json already exists. Delete it to re-init.');
+  }
+
+  // Create config
+  const cfg = config.create(workspaceDir, { namespace, user });
+
+  const infoLines = [
+    namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+    user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
+  ].filter(Boolean).join('\n');
+
+  fmt.note(infoLines, 'Config created');
+
+  // Always pull ghl/ (platform layer)
+  pullCommand({ ...args, _positional: ['ghl'] });
+
+  // Pull [template]/ as the team namespace
+  if (namespace) {
+    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace });
+  }
+
+  // Post-pull IDE integration
+  linkWorkspace(cwd);
+  generateCommands(cwd);
+  copyInstructions(cwd, null, namespace);
+  initAwDocs(cwd);
+  setupMcp(cwd, namespace);
+}

package/commands/nuke.mjs

@@ -0,0 +1,95 @@
+// 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 * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+
+// IDE dirs to scan for per-file symlinks
+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)
+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',
+];
+
+export function nukeCommand(args) {
+  const cwd = process.cwd();
+  const workspaceDir = join(cwd, '.aw_registry');
+
+  fmt.intro('aw nuke');
+
+  if (!existsSync(workspaceDir)) {
+    fmt.cancel('No .aw_registry/ found — nothing to remove');
+  }
+
+  // 1. Remove symlinks + generated files from all IDE dirs
+  for (const ide of IDE_DIRS) {
+    for (const type of CONTENT_TYPES) {
+      const dir = join(cwd, ide, type);
+      if (!existsSync(dir)) continue;
+      for (const entry of readdirSync(dir)) {
+        const p = join(dir, entry);
+        try {
+          const stat = lstatSync(p);
+          if (stat.isSymbolicLink()) {
+            unlinkSync(p);
+          }
+        } catch { /* best effort */ }
+      }
+    }
+    // Clean commands/aw/ (generated commands + symlinked registry commands)
+    const awCmdDir = join(cwd, ide, 'commands/aw');
+    if (existsSync(awCmdDir)) {
+      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) {
+    const p = join(cwd, rel);
+    try { if (existsSync(p)) rmSync(p); } catch { /* best effort */ }
+  }
+
+  // 4. Remove .aw_registry/ and .aw_docs/
+  rmSync(workspaceDir, { recursive: true, force: true });
+  const awDocsDir = join(cwd, '.aw_docs');
+  if (existsSync(awDocsDir)) {
+    rmSync(awDocsDir, { recursive: true, force: true });
+  }
+
+  // 5. Prune empty dirs
+  for (const rel of DIRS_TO_PRUNE) {
+    const p = join(cwd, rel);
+    try {
+      if (existsSync(p) && readdirSync(p).length === 0) {
+        rmSync(p, { recursive: true });
+      }
+    } catch { /* best effort */ }
+  }
+
+  fmt.logSuccess('Removed .aw_registry/ and all generated IDE files');
+  fmt.outro(`Run ${chalk.dim('aw init')} to start fresh`);
+}