@ghl-ai/aw 0.1.0

package/manifest.mjs

@@ -0,0 +1,62 @@
+// manifest.mjs — .sync-manifest.json management. Zero dependencies.
+
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { hashFile } from './registry.mjs';
+
+const MANIFEST_FILE = '.sync-manifest.json';
+
+export function manifestPath(workspaceDir) {
+  return join(workspaceDir, MANIFEST_FILE);
+}
+
+export function load(workspaceDir) {
+  const p = manifestPath(workspaceDir);
+  if (!existsSync(p)) return { version: 3, synced_at: '', namespace: '', files: {} };
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return { version: 3, synced_at: '', namespace: '', files: {} };
+  }
+}
+
+export function save(workspaceDir, manifest) {
+  writeFileSync(manifestPath(workspaceDir), JSON.stringify(manifest, null, 2) + '\n');
+}
+
+export function update(workspaceDir, actions, namespaceName) {
+  const manifest = load(workspaceDir);
+  manifest.synced_at = new Date().toISOString();
+  manifest.namespace = namespaceName || manifest.namespace;
+  manifest.version = 3;
+
+  for (const act of actions) {
+    const manifestKey = act.targetFilename;
+
+    if (act.action === 'ADD' || act.action === 'UPDATE' || act.action === 'UNCHANGED') {
+      if (existsSync(act.targetPath)) {
+        manifest.files[manifestKey] = {
+          sha256: hashFile(act.targetPath),
+          source: act.source,
+          registry_sha256: act.registryHash,
+        };
+      }
+    } else if (act.action === 'CONFLICT') {
+      // Update local hash but keep OLD registry_sha256
+      // so next sync still detects the unacknowledged registry change
+      if (existsSync(act.targetPath)) {
+        const existing = manifest.files[manifestKey];
+        manifest.files[manifestKey] = {
+          sha256: hashFile(act.targetPath),
+          source: act.source,
+          registry_sha256: existing?.registry_sha256 ?? act.registryHash,
+        };
+      }
+    } else if (act.action === 'ORPHAN') {
+      delete manifest.files[manifestKey];
+    }
+  }
+
+  save(workspaceDir, manifest);
+  return manifest;
+}

package/mcp.mjs

@@ -0,0 +1,166 @@
+// mcp.mjs — MCP config generation for all 3 IDEs (init only, never overwrites)
+
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import * as fmt from './fmt.mjs';
+
+const HOME = homedir();
+
+/**
+ * Auto-detect MCP server paths.
+ */
+function detectPaths() {
+  const ghlAiBridge = join(HOME, '.claude', 'ghl-ai-bridge.mjs');
+  const gitJenkinsCandidates = [
+    join(HOME, 'Documents', 'GitHub', 'git-jenkins-mcp', 'dist', 'index.js'),
+    resolve('..', 'git-jenkins-mcp', 'dist', 'index.js'),
+  ];
+
+  const gitJenkinsPath = gitJenkinsCandidates.find(p => existsSync(p)) || null;
+  const ghlMcpUrl = process.env.GHL_MCP_URL || 'https://ghl-ai-staging.highlevel-staging.com';
+
+  return {
+    ghlAiBridge: existsSync(ghlAiBridge) ? ghlAiBridge : null,
+    gitJenkinsPath,
+    ghlMcpUrl,
+  };
+}
+
+/**
+ * Setup MCP configs for all IDEs. Only writes if file doesn't exist.
+ */
+export function setupMcp(cwd, namespace) {
+  const paths = detectPaths();
+  let created = 0;
+
+  // .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';
+    }
+  );
+
+  // .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';
+    }
+  );
+
+  // .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
+    );
+  }
+
+  // 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';
+    }
+  );
+
+  if (created > 0) {
+    fmt.logSuccess(`Created ${created} MCP config${created > 1 ? 's' : ''}`);
+  }
+
+  const warnings = [];
+  if (!paths.ghlAiBridge) warnings.push('ghl-ai bridge not found at ~/.claude/ghl-ai-bridge.mjs');
+  if (!paths.gitJenkinsPath) warnings.push('git-jenkins MCP not found');
+  for (const w of warnings) {
+    fmt.logWarn(w);
+  }
+
+  return created;
+}
+
+function writeIfMissing(filePath, contentFn, append = false) {
+  if (!append && existsSync(filePath)) return 0;
+  const content = contentFn();
+  if (!content) return 0;
+  mkdirSync(join(filePath, '..'), { recursive: true });
+  if (append && existsSync(filePath)) {
+    const existing = readFileSync(filePath, 'utf8');
+    writeFileSync(filePath, existing + '\n' + content);
+  } else {
+    writeFileSync(filePath, content);
+  }
+  return 1;
+}
+
+function hasMcpSection(filePath) {
+  if (!existsSync(filePath)) return false;
+  const content = readFileSync(filePath, 'utf8');
+  return content.includes('[mcp_servers');
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@ghl-ai/aw",
+  "version": "0.1.0",
+  "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
+  "type": "module",
+  "bin": {
+    "aw": "./bin.js"
+  },
+  "files": [
+    "bin.js",
+    "cli.mjs",
+    "commands/",
+    "config.mjs",
+    "constants.mjs",
+    "fmt.mjs",
+    "git.mjs",
+    "glob.mjs",
+    "integrate.mjs",
+    "link.mjs",
+    "manifest.mjs",
+    "mcp.mjs",
+    "paths.mjs",
+    "plan.mjs",
+    "registry.mjs",
+    "apply.mjs"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "agentic-workspace",
+    "cli"
+  ],
+  "author": "GoHighLevel",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "chalk": "^5.6.2",
+    "figlet": "^1.11.0"
+  }
+}

package/paths.mjs

@@ -0,0 +1,139 @@
+// paths.mjs — Convert between local workspace paths and registry paths. Zero dependencies.
+
+import { existsSync, statSync, lstatSync, readlinkSync } from 'node:fs';
+import { join, resolve, relative, basename, dirname } from 'node:path';
+
+const VALID_TYPES = new Set(['agents', 'skills', 'commands', 'blueprints', 'evals']);
+
+// IDE dirs that may contain symlinks into .aw_registry/
+const IDE_PREFIXES = ['.claude/', '.cursor/', '.codex/', '.agents/'];
+
+/**
+ * Convert a local workspace path to a registry path.
+ *
+ * .aw_registry/ghl/agents/architecture-reviewer.md
+ *   → ghl/agents/architecture-reviewer
+ *
+ * .aw_registry/dev-nitro/skills/my-skill/SKILL.md
+ *   → dev-nitro/skills/my-skill/SKILL
+ */
+export function localToRegistry(localPath) {
+  // Normalize to relative path inside .aw_registry/
+  let rel = localPath;
+  const awIdx = rel.indexOf('.aw_registry/');
+  if (awIdx !== -1) {
+    rel = rel.slice(awIdx + '.aw_registry/'.length);
+  } else if (rel.startsWith('.aw_registry\\')) {
+    rel = rel.slice('.aw_registry\\'.length);
+  }
+
+  // Strip .md extension and return — path mirrors registry directly
+  return rel.replace(/\.md$/, '') || null;
+}
+
+/**
+ * Convert a registry path to a local workspace path.
+ *
+ * ghl/agents/architecture-reviewer
+ *   → ghl/agents/architecture-reviewer.md
+ *
+ * dev-nitro/skills/my-skill/SKILL
+ *   → dev-nitro/skills/my-skill/SKILL.md
+ *
+ * Returns relative path inside .aw_registry/
+ */
+export function registryToLocal(registryPath) {
+  const clean = registryPath.replace(/\.md$/, '');
+  const parts = clean.split('/');
+
+  // Find the type segment
+  let typeIdx = -1;
+  for (let i = 0; i < parts.length; i++) {
+    if (VALID_TYPES.has(parts[i])) {
+      typeIdx = i;
+      break;
+    }
+  }
+
+  if (typeIdx === -1 || typeIdx + 1 >= parts.length) return null;
+  if (typeIdx === 0) return null; // no namespace
+
+  const type = parts[typeIdx];
+
+  if (type === 'skills') {
+    // Skills may reference a subfile or just the folder
+    if (parts.length > typeIdx + 2) {
+      // Subfile: namespace/skills/slug/subpath → namespace/skills/slug/subpath.md
+      return clean + '.md';
+    }
+    // Just the skill folder
+    return clean;
+  } else {
+    // Flat files: namespace/agents/slug → namespace/agents/slug.md
+    return clean + '.md';
+  }
+}
+
+/**
+ * Detect input type and normalize to registry path.
+ * Accepts either local path or registry path.
+ * Returns { registryPath, localPath (if resolvable) }
+ */
+export function resolveInput(input, workspaceDir) {
+  const normalized = input.replace(/\/+$/, '');
+
+  // Resolve IDE symlink paths → .aw_registry/ paths
+  const rewritten = resolveIdePath(normalized);
+
+  // Local path — starts with .aw_registry/
+  if (rewritten.startsWith('.aw_registry/') || rewritten.startsWith('.aw_registry\\')) {
+    const registryPath = localToRegistry(rewritten);
+    const absPath = resolve(rewritten);
+    return {
+      registryPath: registryPath?.replace(/\.md$/, '') || null,
+      localAbsPath: absPath,
+      isLocalPath: true,
+    };
+  }
+
+  // Registry path
+  const cleanPath = rewritten.replace(/\.md$/, '');
+  const localRel = registryToLocal(cleanPath);
+  return {
+    registryPath: cleanPath,
+    localAbsPath: localRel ? join(workspaceDir, localRel) : null,
+    isLocalPath: false,
+  };
+}
+
+/**
+ * Rewrite IDE paths (.claude/agents/foo.md) to .aw_registry/ paths
+ * by resolving the symlink target. Falls back to input if not a symlink.
+ */
+function resolveIdePath(input) {
+  const isIde = IDE_PREFIXES.some(p => input.startsWith(p));
+  if (!isIde) return input;
+
+  // Try each file/dir in the path to find a symlink
+  const parts = input.split('/');
+  for (let i = 2; i <= parts.length; i++) {
+    const candidate = parts.slice(0, i).join('/');
+    try {
+      const stat = lstatSync(candidate);
+      if (stat.isSymbolicLink()) {
+        const target = resolve(dirname(candidate), readlinkSync(candidate));
+        const rest = parts.slice(i).join('/');
+        // Convert absolute target back to relative with .aw_registry/
+        const awIdx = target.indexOf('.aw_registry/');
+        if (awIdx !== -1) {
+          const awRel = target.slice(awIdx);
+          return rest ? `${awRel}/${rest}` : awRel;
+        }
+      }
+    } catch {
+      // doesn't exist yet, keep trying
+    }
+  }
+
+  return input;
+}

package/plan.mjs

@@ -0,0 +1,133 @@
+// plan.mjs — Compute sync plan (what actions to take). Zero dependencies.
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { walkRegistryTree, hashFile } from './registry.mjs';
+import { load as loadManifest } from './manifest.mjs';
+import { matchesAny } from './glob.mjs';
+
+/**
+ * Compute sync actions from registry dirs → workspace.
+ *
+ * @param {Array<{name: string, path: string}>} registryDirs — sources to scan
+ * @param {string} workspaceDir — .aw_registry path
+ * @param {string[]} includePatterns — paths to filter (empty = all)
+ * @returns {{ actions: Array }}
+ */
+export function computePlan(registryDirs, workspaceDir, includePatterns = [], { skipOrphans = false } = {}) {
+  const plan = new Map();
+
+  for (const { name, path } of registryDirs) {
+    for (const entry of walkRegistryTree(path, name)) {
+      // Apply include filter
+      if (includePatterns.length > 0 && !matchesAny(entry.registryPath, includePatterns)) {
+        continue;
+      }
+
+      // For skill files: key includes relative path to avoid collisions
+      // For other files: key is type/slug
+      const key = entry.skillRelPath
+        ? `${entry.type}/${entry.slug}/${entry.skillRelPath}`
+        : `${entry.type}/${entry.slug}`;
+      plan.set(key, { ...entry, source: entry.namespacePath || name });
+    }
+  }
+
+  const manifest = loadManifest(workspaceDir);
+  const actions = [];
+
+  for (const [key, entry] of plan) {
+    // Mirror registry structure: namespace/type/slug
+    // Skills: namespace/skills/slug/relPath
+    // Others: namespace/agents/slug.md
+    let targetFilename, targetPath;
+    if (entry.skillRelPath) {
+      targetFilename = `${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath}`;
+      targetPath = join(workspaceDir, entry.namespacePath, entry.type, entry.slug, entry.skillRelPath);
+    } else {
+      targetFilename = `${entry.namespacePath}/${entry.type}/${entry.slug}.md`;
+      targetPath = join(workspaceDir, entry.namespacePath, entry.type, `${entry.slug}.md`);
+    }
+
+    const manifestKey = targetFilename;
+    const registryHash = hashFile(entry.sourcePath);
+
+    let action;
+
+    if (!existsSync(targetPath)) {
+      action = 'ADD';
+    } else {
+      const localHash = hashFile(targetPath);
+
+      if (localHash === registryHash) {
+        action = 'UNCHANGED';
+      } else {
+        const manifestEntry = manifest.files?.[manifestKey];
+        if (!manifestEntry) {
+          action = 'UPDATE';
+        } else {
+          const localChanged = localHash !== manifestEntry.sha256;
+          const registryChanged = registryHash !== manifestEntry.registry_sha256;
+          if (localChanged && registryChanged) {
+            action = 'CONFLICT';
+          } else if (localChanged) {
+            action = 'UNCHANGED';
+          } else {
+            action = 'UPDATE';
+          }
+        }
+      }
+    }
+
+    actions.push({
+      slug: entry.slug,
+      source: entry.source,
+      type: entry.type,
+      action,
+      sourcePath: entry.sourcePath,
+      targetPath,
+      targetFilename,
+      isDirectory: false,
+      registryHash,
+      namespacePath: entry.namespacePath,
+      registryPath: entry.registryPath,
+    });
+  }
+
+  // Orphans: in manifest but not in plan
+  if (manifest.files && !skipOrphans) {
+    for (const [manifestKey, manifestEntry] of Object.entries(manifest.files)) {
+      // manifestKey is now namespace/type/slug.md or namespace/type/slug/relPath
+      const parts = manifestKey.split('/');
+      // Find the type segment
+      let typeIdx = -1;
+      for (let i = 0; i < parts.length; i++) {
+        if (['agents', 'skills', 'commands', 'blueprints', 'evals'].includes(parts[i])) {
+          typeIdx = i;
+          break;
+        }
+      }
+      if (typeIdx === -1) continue;
+      const type = parts[typeIdx];
+      const slug = parts[typeIdx + 1]?.replace(/\.md$/, '');
+      const key = `${type}/${slug}`;
+      if (!plan.has(key)) {
+        actions.push({
+          slug,
+          source: manifestEntry.source || 'unknown',
+          type,
+          action: 'ORPHAN',
+          sourcePath: '',
+          targetPath: join(workspaceDir, manifestKey),
+          targetFilename: manifestKey,
+          isDirectory: false,
+          registryHash: '',
+          namespacePath: parts.slice(0, typeIdx).join('/'),
+          registryPath: '',
+        });
+      }
+    }
+  }
+
+  return { actions };
+}

package/registry.mjs

@@ -0,0 +1,138 @@
+// registry.mjs — Registry walking, scanning, hashing. Zero dependencies.
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const TYPE_DIRS = new Set(['agents', 'skills', 'commands', 'blueprints', 'evals']);
+
+export function sha256(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+export function hashFile(filePath) {
+  return sha256(readFileSync(filePath));
+}
+
+export function getAllFiles(dirPath) {
+  const results = [];
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const full = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...getAllFiles(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+/**
+ * Walk a registry directory tree and collect file-level entries.
+ * Every file gets its own entry with its full registry path.
+ * Skills are NOT atomic — each file inside a skill is registered individually.
+ */
+export function walkRegistryTree(baseDir, baseName) {
+  const entries = [];
+  if (!baseDir || !existsSync(baseDir)) return entries;
+
+  function recurse(dir, pathSegments) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory() && TYPE_DIRS.has(entry.name)) {
+        const typeDir = entry.name;
+        const namespace = pathSegments.join('/');
+
+        if (typeDir === 'skills') {
+          // Skills are directories — register each file inside individually
+          for (const skillEntry of readdirSync(fullPath, { withFileTypes: true })) {
+            if (skillEntry.name.startsWith('.')) continue;
+            const skillPath = join(fullPath, skillEntry.name);
+            if (!statSync(skillPath).isDirectory()) continue;
+            const slug = skillEntry.name;
+
+            for (const file of getAllFiles(skillPath)) {
+              const relPath = relative(skillPath, file);
+              const relNoExt = relPath.replace(/\.md$/, '');
+              const registryPath = `${namespace}/${typeDir}/${slug}/${relNoExt}`;
+              entries.push({
+                slug, type: typeDir, sourcePath: file,
+                isDirectory: false, namespacePath: namespace, registryPath,
+                filename: relPath,
+                skillRelPath: relPath,
+              });
+            }
+          }
+        } else if (typeDir === 'evals') {
+          // Evals: evals/agents/<name>/<files>, evals/skills/<name>/<files>
+          for (const file of getAllFiles(fullPath)) {
+            const relFromEvals = relative(fullPath, file);
+            const parts = relFromEvals.split('/');
+            // slug = subtype/name (e.g., agents/architecture-reviewer)
+            const slug = parts.slice(0, -1).join('/');
+            const filename = parts[parts.length - 1];
+            const relNoExt = relFromEvals.replace(/\.md$/, '');
+            const registryPath = `${namespace}/${typeDir}/${relNoExt}`;
+            entries.push({
+              slug, type: typeDir, sourcePath: file,
+              isDirectory: false, namespacePath: namespace, registryPath,
+              filename,
+              skillRelPath: filename,
+            });
+          }
+        } else {
+          // Agents, commands, blueprints — flat files
+          for (const fileEntry of readdirSync(fullPath)) {
+            if (fileEntry === '.gitkeep' || fileEntry.startsWith('.')) continue;
+            const filePath = join(fullPath, fileEntry);
+            if (!statSync(filePath).isFile()) continue;
+            const slug = fileEntry.replace(/\.md$/, '');
+            const registryPath = `${namespace}/${typeDir}/${slug}`;
+            entries.push({
+              slug, type: typeDir, sourcePath: filePath,
+              isDirectory: false, namespacePath: namespace, registryPath,
+              filename: fileEntry,
+            });
+          }
+        }
+      } else if (entry.isDirectory()) {
+        recurse(fullPath, [...pathSegments, entry.name]);
+      }
+    }
+  }
+
+  recurse(baseDir, baseName ? [baseName] : []);
+  return entries;
+}
+
+/**
+ * Extract metadata from a file (name, description from frontmatter).
+ */
+export function extractMeta(filePath, slug) {
+  let name = slug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+  let description = '';
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    if (content.startsWith('---')) {
+      const endIdx = content.indexOf('---', 3);
+      if (endIdx !== -1) {
+        const fm = content.slice(3, endIdx);
+        const nameMatch = fm.match(/^name:\s*(.+)$/m);
+        if (nameMatch) name = nameMatch[1].trim().replace(/^["']|["']$/g, '');
+        const descMatch = fm.match(/^description:\s*(.+)$/m);
+        if (descMatch) description = descMatch[1].trim().replace(/^["']|["']$/g, '');
+      }
+    }
+    if (name === slug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase())) {
+      const headingMatch = content.match(/^#\s+(.+)$/m);
+      if (headingMatch) name = headingMatch[1].trim();
+    }
+  } catch {
+    // Fall through
+  }
+
+  return { name, description };
+}