@ghl-ai/aw 0.1.0

package/commands/status.mjs

@@ -0,0 +1,108 @@
+// commands/status.mjs — Show workspace status
+
+import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import * as config from '../config.mjs';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+import { load as loadManifest } from '../manifest.mjs';
+import { hashFile } from '../registry.mjs';
+
+export function statusCommand(args) {
+  const cwd = process.cwd();
+  const workspaceDir = join(cwd, '.aw_registry');
+
+  const cfg = config.load(workspaceDir);
+  if (!cfg) {
+    fmt.cancel('No .sync-config.json found. Run: aw --init');
+  }
+
+  const manifest = loadManifest(workspaceDir);
+
+  fmt.intro(`aw status`);
+
+  // Info note
+  const infoLines = [
+    `${chalk.dim('namespace:')}  ${cfg.namespace || 'none'}`,
+    cfg.user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
+    manifest.synced_at ? `${chalk.dim('last sync:')}  ${manifest.synced_at}` : null,
+  ].filter(Boolean).join('\n');
+  fmt.note(infoLines, 'Workspace');
+
+  // Show synced paths
+  if (cfg.include.length > 0) {
+    const pathLines = cfg.include.map(p => `  ${chalk.cyan(p)}`).join('\n');
+    fmt.note(pathLines, 'Synced Paths');
+  } else {
+    fmt.logInfo('No paths synced. Run: aw pull <path>');
+  }
+
+  const files = Object.entries(manifest.files || {});
+  const modified = [];
+  const missing = [];
+  const conflicts = [];
+
+  for (const [key, entry] of files) {
+    const filePath = join(workspaceDir, key);
+    if (!existsSync(filePath)) {
+      missing.push(key);
+      continue;
+    }
+
+    const currentHash = hashFile(filePath);
+
+    if (currentHash !== entry.sha256) {
+      const content = readFileSync(filePath, 'utf8');
+      if (content.includes('<<<<<<<')) {
+        conflicts.push(key);
+        continue;
+      }
+      modified.push(key);
+    }
+  }
+
+  // Summary line
+  const summaryParts = [
+    `${files.length} synced`,
+    modified.length > 0 ? chalk.yellow(`${modified.length} modified`) : null,
+    conflicts.length > 0 ? chalk.red(`${conflicts.length} conflicts`) : null,
+    missing.length > 0 ? chalk.dim(`${missing.length} missing`) : null,
+  ].filter(Boolean).join(chalk.dim(' · '));
+
+  fmt.logInfo(summaryParts);
+
+  if (conflicts.length > 0) {
+    fmt.note(
+      conflicts.map(c => chalk.red(c)).join('\n'),
+      chalk.red('Unresolved Conflicts')
+    );
+  }
+
+  if (modified.length > 0) {
+    fmt.note(
+      modified.map(m => chalk.yellow(m)).join('\n'),
+      chalk.yellow('Modified')
+    );
+  }
+
+  if (missing.length > 0) {
+    fmt.note(
+      missing.map(m => chalk.dim(m)).join('\n'),
+      chalk.dim('Missing (deleted locally)')
+    );
+  }
+
+  if (modified.length === 0 && conflicts.length === 0 && missing.length === 0) {
+    fmt.logSuccess('Workspace is clean');
+  }
+
+  // Hints
+  if (conflicts.length > 0) {
+    fmt.logWarn(`Fix conflicts: ${chalk.dim('grep -r "<<<<<<< " .aw_registry/')}`);
+  }
+  if (modified.length > 0) {
+    fmt.logInfo(`Push changes: ${chalk.dim('aw push <path>')}`);
+  }
+
+  fmt.outro(`${chalk.dim('aw pull <pattern>')} to pull latest`);
+}

package/config.mjs

@@ -0,0 +1,70 @@
+// config.mjs — .sync-config.json management. Zero dependencies.
+
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { REGISTRY_REPO } from './constants.mjs';
+
+const CONFIG_FILE = '.sync-config.json';
+
+const DEFAULTS = {
+  namespace: null,
+  user: '',
+  repo: REGISTRY_REPO,
+  include: [],
+};
+
+export function configPath(workspaceDir) {
+  return join(workspaceDir, CONFIG_FILE);
+}
+
+export function exists(workspaceDir) {
+  return existsSync(configPath(workspaceDir));
+}
+
+export function load(workspaceDir) {
+  const p = configPath(workspaceDir);
+  if (!existsSync(p)) return null;
+  try {
+    return { ...DEFAULTS, ...JSON.parse(readFileSync(p, 'utf8')) };
+  } catch {
+    return null;
+  }
+}
+
+export function save(workspaceDir, config) {
+  writeFileSync(configPath(workspaceDir), JSON.stringify(config, null, 2) + '\n');
+}
+
+export function create(workspaceDir, { namespace, user }) {
+  const config = {
+    ...DEFAULTS,
+    namespace: namespace || null,
+    user: user || '',
+    include: [],
+  };
+  save(workspaceDir, config);
+  return config;
+}
+
+export function addPattern(workspaceDir, pattern) {
+  const config = load(workspaceDir);
+  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  // If a parent path already covers this, skip
+  if (config.include.some(p => pattern === p || pattern.startsWith(p + '/'))) {
+    return config;
+  }
+  // Remove any children that the new parent covers
+  config.include = config.include.filter(p => !p.startsWith(pattern + '/'));
+  config.include.push(pattern);
+  save(workspaceDir, config);
+  return config;
+}
+
+export function removePattern(workspaceDir, pattern) {
+  const config = load(workspaceDir);
+  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  // Remove exact match + all children
+  config.include = config.include.filter(p => p !== pattern && !p.startsWith(pattern + '/'));
+  save(workspaceDir, config);
+  return config;
+}

package/constants.mjs

@@ -0,0 +1,7 @@
+// constants.mjs — Single source of truth for registry settings.
+
+/** Base branch for PRs and sync checkout */
+export const REGISTRY_BASE_BRANCH = 'master';
+
+/** Default registry repository */
+export const REGISTRY_REPO = 'GoHighLevel/ghl-agentic-workspace';

package/fmt.mjs

@@ -0,0 +1,99 @@
+// fmt.mjs — Terminal formatting with @clack/prompts + chalk + figlet
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import figlet from 'figlet';
+
+export { chalk };
+
+// ─── Banner ───
+
+export function banner(text, opts = {}) {
+  const {
+    font = 'ANSI Shadow',
+    color = chalk.hex('#FF6B35'),
+    subtitle = '',
+    dividerChar = '─',
+  } = opts;
+
+  const cols = process.stdout.columns || 80;
+  const art = figlet.textSync(text, { font, horizontalLayout: 'default' });
+  const divider = chalk.dim(dividerChar.repeat(Math.min(cols, 80)));
+
+  console.log('');
+  console.log(divider);
+  console.log(color(art));
+  console.log(divider);
+  if (subtitle) {
+    console.log('');
+    console.log(chalk.dim(subtitle));
+  }
+  console.log('');
+}
+
+// ─── Clack wrappers ───
+
+export const intro    = (msg) => p.intro(chalk.bgCyan.black(` ${msg} `));
+export const outro    = (msg) => p.outro(chalk.green(msg));
+export const spinner  = () => p.spinner();
+
+export function cancel(msg) {
+  p.cancel(msg);
+  process.exit(1);
+}
+
+// ─── Log helpers (clack-styled) ───
+
+export const note       = (msg, title) => p.note(msg, title);
+export const logInfo    = (msg) => p.log.info(msg);
+export const logSuccess = (msg) => p.log.success(msg);
+export const logWarn    = (msg) => p.log.warn(msg);
+export const logError   = (msg) => p.log.error(msg);
+export const logStep    = (msg) => p.log.step(msg);
+export const logMessage = (msg) => p.log.message(msg);
+
+// ─── Styled text helpers ───
+
+export const dim     = (s) => chalk.dim(s);
+export const bold    = (s) => chalk.bold(s);
+export const red     = (s) => chalk.red(s);
+export const green   = (s) => chalk.green(s);
+export const yellow  = (s) => chalk.yellow(s);
+export const blue    = (s) => chalk.blue(s);
+export const cyan    = (s) => chalk.cyan(s);
+export const magenta = (s) => chalk.magenta(s);
+
+// ─── Backward compat aliases (used by existing commands) ───
+
+export function log(msg = '')      { process.stderr.write(msg + '\n'); }
+export function info(msg)          { p.log.info(msg); }
+export function success(msg)       { p.log.success(msg); }
+export function warn(msg)          { p.log.warn(msg); }
+export function error(msg)         { p.log.error(msg); }
+export function heading(msg)       { p.log.step(chalk.bold(msg)); }
+export function item(label, value) { p.log.message(`${chalk.dim(label)} ${value}`); }
+
+// ─── Action labels ───
+
+export function actionLabel(action) {
+  switch (action) {
+    case 'ADD':       return chalk.bgGreen.black(' ADD ');
+    case 'UPDATE':    return chalk.bgCyan.black(' UPD ');
+    case 'SKIP':      return chalk.bgYellow.black(' SKP ');
+    case 'CONFLICT':  return chalk.bgRed.white(' CON ');
+    case 'ORPHAN':    return chalk.bgYellow.black(' ORP ');
+    case 'UNCHANGED': return chalk.dim(' --- ');
+    default:          return chalk.dim(` ${action} `);
+  }
+}
+
+export function countSummary(counts) {
+  const parts = [];
+  if (counts.ADD > 0)       parts.push(chalk.green(`${counts.ADD} added`));
+  if (counts.UPDATE > 0)    parts.push(chalk.cyan(`${counts.UPDATE} updated`));
+  if (counts.UNCHANGED > 0) parts.push(chalk.dim(`${counts.UNCHANGED} unchanged`));
+  if (counts.SKIP > 0)      parts.push(chalk.yellow(`${counts.SKIP} skipped`));
+  if (counts.CONFLICT > 0)  parts.push(chalk.red(`${counts.CONFLICT} conflict`));
+  if (counts.ORPHAN > 0)    parts.push(chalk.yellow(`${counts.ORPHAN} orphan`));
+  return parts.join(chalk.dim(' · '));
+}

package/git.mjs

@@ -0,0 +1,61 @@
+// git.mjs — Git sparse checkout helpers. Zero dependencies.
+
+import { execSync } from 'node:child_process';
+import { mkdtempSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { REGISTRY_BASE_BRANCH } from './constants.mjs';
+
+/**
+ * Sparse-checkout registry paths from GitHub.
+ * Returns the temp directory path containing the checkout.
+ */
+export function sparseCheckout(repo, paths) {
+  const tempDir = mkdtempSync(join(tmpdir(), 'aw-'));
+
+  try {
+    execSync(`gh repo clone ${repo} ${tempDir} -- --filter=blob:none --no-checkout`, {
+      stdio: 'pipe',
+    });
+  } catch (e) {
+    throw new Error(`Failed to clone ${repo}. Check: gh auth status`);
+  }
+
+  try {
+    execSync('git sparse-checkout init --cone', { cwd: tempDir, stdio: 'pipe' });
+    execSync(`git sparse-checkout set --skip-checks ${paths.map(p => `"${p}"`).join(' ')}`, {
+      cwd: tempDir, stdio: 'pipe',
+    });
+    execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir, stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed sparse checkout: ${e.message}`);
+  }
+
+  return tempDir;
+}
+
+/**
+ * Clean up temp directory.
+ */
+export function cleanup(tempDir) {
+  try {
+    execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' });
+  } catch {
+    // Best effort
+  }
+}
+
+/**
+ * Compute sparse checkout paths from include paths.
+ * e.g., ["ghl", "dev/agents/debugger"] -> ["registry/ghl", "registry/dev/agents/debugger"]
+ */
+export function includeToSparsePaths(paths) {
+  const result = new Set();
+  for (const p of paths) {
+    result.add(`registry/${p}`);
+  }
+  // Also fetch root instruction files
+  result.add('registry/CLAUDE.md');
+  result.add('registry/AGENTS.md');
+  return [...result];
+}

package/glob.mjs

@@ -0,0 +1,22 @@
+// glob.mjs — Simple path matching. Zero dependencies.
+// No wildcards. Path prefix matching only.
+// "ghl" matches "ghl/agents/foo", "ghl/skills/bar", etc.
+// "ghl/agents/foo" matches exactly "ghl/agents/foo"
+// "dev/skills/my-skill/references" matches "dev/skills/my-skill" (parent match)
+
+/**
+ * Test if a registry path matches any of the given paths.
+ * Matches if:
+ *   1. path equals pattern (exact match)
+ *   2. path starts with pattern/ (pattern is parent of path)
+ *   3. pattern starts with path/ (path is parent of pattern — e.g., pulling a subfolder pulls the skill)
+ */
+export function matchesAny(path, patterns) {
+  for (const p of patterns) {
+    const normalized = p.replace(/\.md$/, '');
+    if (path === normalized) return true;
+    if (path.startsWith(normalized + '/')) return true;
+    if (normalized.startsWith(path + '/')) return true;
+  }
+  return false;
+}