@ghl-ai/aw 0.1.35 → 0.1.36-beta.2

package/commands/push.mjs

@@ -1,32 +1,157 @@
-// commands/push.mjs — Push local agents/skills to registry via PR (single file or batch)
+// commands/push.mjs — Push local agents/skills to registry via PR using persistent git clone
 
-import { existsSync, statSync, mkdirSync, cpSync, mkdtempSync, readFileSync, appendFileSync, readdirSync } from 'node:fs';
-import { basename, dirname, resolve, join, relative } from 'node:path';
+import { existsSync, statSync, readFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { execSync, execFileSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
+import { homedir } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { REGISTRY_REPO, REGISTRY_BASE_BRANCH, REGISTRY_DIR } from '../constants.mjs';
 import { resolveInput } from '../paths.mjs';
-import { load as loadManifest, save as saveManifest } from '../manifest.mjs';
-import { hashFile, walkRegistryTree } from '../registry.mjs';
+import { walkRegistryTree } from '../registry.mjs';
+import {
+  detectChanges,
+  createPushBranch,
+  checkoutMain,
+  isValidClone,
+} from '../git.mjs';
 
 const PUSHABLE_TYPES = ['agents', 'skills', 'commands', 'evals'];
 
-// ── Batch file collection ────────────────────────────────────────────
+// ── PR content generation ────────────────────────────────────────────
+
+function generateBranchName(files) {
+  const shortId = Date.now().toString(36).slice(-5);
+  const namespaces = [...new Set(files.map(f => f.namespace))];
+  const hasDeletes = files.some(f => f.deleted);
+  const allDeletes = files.every(f => f.deleted);
+  const prefix = allDeletes ? 'remove' : hasDeletes ? 'sync' : 'upload';
+
+  if (files.length === 1) {
+    const f = files[0];
+    const nsSlug = f.namespace.replace(/\//g, '-');
+    return `${prefix}/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
+  }
+
+  if (namespaces.length === 1) {
+    return `${prefix}/${namespaces[0].replace(/\//g, '-')}-${shortId}`;
+  }
+
+  return `${prefix}/batch-${shortId}`;
+}
+
+function generatePrTitle(files) {
+  if (files.length === 1) {
+    const f = files[0];
+    const verb = f.deleted ? 'Remove' : 'Add';
+    const prep = f.deleted ? 'from' : 'to';
+    return `${verb} ${f.slug} (${f.type}) ${prep} ${f.namespace}`;
+  }
+
+  const addCounts = {};
+  const deleteCounts = {};
+  for (const f of files) {
+    const target = f.deleted ? deleteCounts : addCounts;
+    target[f.type] = (target[f.type] || 0) + 1;
+  }
+  const parts = [];
+  for (const [type, count] of Object.entries(addCounts)) {
+    parts.push(`+${count} ${type}`);
+  }
+  for (const [type, count] of Object.entries(deleteCounts)) {
+    parts.push(`-${count} ${type}`);
+  }
+  const namespaces = [...new Set(files.map(f => f.namespace))];
+
+  if (namespaces.length === 1) {
+    return `sync: ${parts.join(', ')} in ${namespaces[0]}`;
+  }
+  return `sync: ${parts.join(', ')} across ${namespaces.join(', ')}`;
+}
+
+function generatePrBody(files, newNamespaces) {
+  if (files.length === 1) {
+    const f = files[0];
+    const action = f.deleted ? 'Registry Removal' : 'Registry Upload';
+    const bodyParts = [
+      `## ${action}`,
+      '',
+      `- **Type:** ${f.type}`,
+      `- **Slug:** ${f.slug}`,
+      `- **Namespace:** ${f.namespace}`,
+      `- **Path:** \`${f.registryTarget}\``,
+    ];
+    if (f.deleted) {
+      bodyParts.push('', '> File was deleted locally and removed from registry.');
+    }
+    if (newNamespaces.length > 0) {
+      bodyParts.push('', '> **New namespace** — CODEOWNERS entry auto-added.');
+    }
+    bodyParts.push('', `${f.deleted ? 'Removed' : 'Uploaded'} via \`aw push\``);
+    return bodyParts.join('\n');
+  }
+
+  const added = files.filter(f => !f.deleted);
+  const deleted = files.filter(f => f.deleted);
+
+  const bodyParts = ['## Registry Sync', ''];
+
+  if (added.length > 0) {
+    const grouped = groupBy(added, 'type');
+    bodyParts.push('### Added / Updated');
+    for (const [type, items] of Object.entries(grouped)) {
+      bodyParts.push(`**${type}**`);
+      for (const item of items.sort((a, b) => a.slug.localeCompare(b.slug))) {
+        bodyParts.push(`- \`${item.slug}\` (${item.namespace})`);
+      }
+    }
+    bodyParts.push('');
+  }
+
+  if (deleted.length > 0) {
+    const grouped = groupBy(deleted, 'type');
+    bodyParts.push('### Removed');
+    for (const [type, items] of Object.entries(grouped)) {
+      bodyParts.push(`**${type}**`);
+      for (const item of items.sort((a, b) => a.slug.localeCompare(b.slug))) {
+        bodyParts.push(`- ~~\`${item.slug}\`~~ (${item.namespace})`);
+      }
+    }
+    bodyParts.push('');
+  }
+
+  if (newNamespaces.length > 0) {
+    bodyParts.push(`> **New namespace${newNamespaces.length > 1 ? 's' : ''}:** ${newNamespaces.join(', ')} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} auto-added.`);
+    bodyParts.push('');
+  }
+
+  bodyParts.push(`---`, `Synced via \`aw push\` (${files.length} files: ${added.length} added/updated, ${deleted.length} removed)`);
+  return bodyParts.join('\n');
+}
+
+function generateCommitMsg(files) {
+  const added = files.filter(f => !f.deleted);
+  const deleted = files.filter(f => f.deleted);
+  const addedParts = Object.entries(groupBy(added, 'type')).map(([t, items]) => `${items.length} ${t}`);
+  const deletedParts = Object.entries(groupBy(deleted, 'type')).map(([t, items]) => `${items.length} ${t} removed`);
+  const countParts = [...addedParts, ...deletedParts];
+
+  if (files.length === 1) {
+    const f = files[0];
+    return `registry: ${f.deleted ? 'remove' : 'add'} ${f.type}/${f.slug} ${f.deleted ? 'from' : 'to'} ${f.namespace}`;
+  }
+  return `registry: sync ${files.length} files (${countParts.join(', ')})`;
+}
+
+// ── Batch file collection from folder ────────────────────────────────
+
+function collectBatchFiles(folderAbsPath, registrySubDir) {
+  const relPath = folderAbsPath.startsWith(registrySubDir + '/')
+    ? folderAbsPath.slice(registrySubDir.length + 1)
+    : folderAbsPath;
 
-/**
- * Collect all pushable files under a local .aw_registry folder.
- * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
- */
-function collectBatchFiles(folderAbsPath, workspaceDir) {
-  const relPath = relative(workspaceDir, folderAbsPath);
   const segments = relPath.split('/');
 
-  // Detect if user pointed at or inside a type dir (agents/, skills/, etc.).
-  // e.g. "revex/courses/core/evals" → typeFilter=evals, subPathFilter=null
-  // e.g. "revex/courses/core/evals/agents" → typeFilter=evals, subPathFilter="agents"
-  // e.g. "revex/courses/core/evals/agents/architect" → typeFilter=evals, subPathFilter="agents/architect"
   let typeFilter = null;
   let subPathFilter = null;
   let walkDir = folderAbsPath;
@@ -34,13 +159,10 @@ function collectBatchFiles(folderAbsPath, workspaceDir) {
 
   for (let i = 0; i < segments.length; i++) {
     if (PUSHABLE_TYPES.includes(segments[i])) {
-      // Everything before this segment is the namespace
       const namespaceParts = segments.slice(0, i);
       walkBaseName = namespaceParts.join('/');
-      // Walk from the namespace dir (parent of the type dir)
-      walkDir = join(workspaceDir, ...namespaceParts);
+      walkDir = join(registrySubDir, ...namespaceParts);
       typeFilter = segments[i];
-      // Anything after the type dir is a sub-path filter (e.g., "agents/architect")
       if (i + 1 < segments.length) {
         subPathFilter = segments.slice(i + 1).join('/');
       }
@@ -52,12 +174,10 @@ function collectBatchFiles(folderAbsPath, workspaceDir) {
   return entries
     .filter(entry => {
       if (typeFilter && entry.type !== typeFilter) return false;
-      // For sub-path filtering (e.g., only evals under "agents" or "agents/architect")
       if (subPathFilter && !entry.slug.startsWith(subPathFilter)) return false;
       return true;
     })
     .map(entry => {
-      // Skills and evals both have nested slug subdirs (e.g. skills/slug/file, evals/agents/developer/file)
       const registryTarget = (entry.type === 'skills' || entry.type === 'evals')
         ? `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath || entry.filename}`
         : `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.filename}`;
@@ -68,45 +188,15 @@ function collectBatchFiles(folderAbsPath, workspaceDir) {
         namespace: entry.namespacePath,
         slug: entry.slug,
         isDir: false,
+        deleted: false,
       };
     });
 }
 
-/**
- * Collect all modified files from manifest (for no-args push).
- * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
- */
-function collectModifiedFiles(workspaceDir) {
-  const manifest = loadManifest(workspaceDir);
-  const files = [];
-  for (const [key, entry] of Object.entries(manifest.files || {})) {
-    const filePath = join(workspaceDir, key);
-    if (!existsSync(filePath)) continue;
-    const currentHash = hashFile(filePath);
-    const isModified = currentHash !== entry.sha256;
-    const isNew = !entry.registry_sha256;  // Template-derived, never pushed to remote
-    if (isModified || isNew) {
-      const meta = parseManifestKey(key);
-      if (meta) {
-        files.push({
-          absPath: filePath,
-          registryTarget: `${REGISTRY_DIR}/${key}`,
-          type: meta.type,
-          namespace: meta.namespace,
-          slug: meta.slug,
-          isDir: false,
-        });
-      }
-    }
-  }
-  return files;
-}
+// ── Parse type/namespace/slug from a registry-relative path ──────────
 
-/**
- * Parse a manifest key like "commerce/agents/unit-tester.md" into { type, namespace, slug }.
- */
-function parseManifestKey(key) {
-  const parts = key.split('/');
+function parseRegistryPath(relPath) {
+  const parts = relPath.split('/');
   for (let i = 0; i < parts.length; i++) {
     if (PUSHABLE_TYPES.includes(parts[i]) && i + 1 < parts.length) {
       return {
@@ -119,244 +209,125 @@ function parseManifestKey(key) {
   return null;
 }
 
-// ── PR content generation ────────────────────────────────────────────
+// ── CODEOWNERS helpers ────────────────────────────────────────────────
 
-function generateBranchName(files) {
-  const shortId = Date.now().toString(36).slice(-5);
-  const namespaces = [...new Set(files.map(f => f.namespace))];
-
-  if (files.length === 1) {
-    const f = files[0];
-    const nsSlug = f.namespace.replace(/\//g, '-');
-    return `upload/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
-  }
-
-  if (namespaces.length === 1) {
-    return `sync/${namespaces[0].replace(/\//g, '-')}-${shortId}`;
+function getGitHubUser() {
+  try {
+    return execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    try {
+      return execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch {
+      return null;
+    }
   }
-
-  return `sync/batch-${shortId}`;
 }
 
-function generatePrTitle(files) {
-  if (files.length === 1) {
-    const f = files[0];
-    return `Add ${f.slug} (${f.type}) to ${f.namespace}`;
-  }
-
-  const counts = {};
-  for (const f of files) {
-    counts[f.type] = (counts[f.type] || 0) + 1;
-  }
-  const countParts = Object.entries(counts).map(([type, count]) => `${count} ${type}`);
-  const namespaces = [...new Set(files.map(f => f.namespace))];
-
-  if (namespaces.length === 1) {
-    return `sync: ${countParts.join(', ')} in ${namespaces[0]}`;
-  }
-  return `sync: ${countParts.join(', ')} across ${namespaces.join(', ')}`;
+function isNewNamespaceInCodeowners(codeownersPath, namespace) {
+  if (!existsSync(codeownersPath)) return true;
+  const content = readFileSync(codeownersPath, 'utf8');
+  return !content.includes(`/${REGISTRY_DIR}/${namespace}/`);
 }
 
-function generatePrBody(files, newNamespaces) {
-  if (files.length === 1) {
-    const f = files[0];
-    const bodyParts = [
-      '## Registry Upload',
-      '',
-      `- **Type:** ${f.type}`,
-      `- **Slug:** ${f.slug}`,
-      `- **Namespace:** ${f.namespace}`,
-      `- **Path:** \`${f.registryTarget}\``,
-    ];
-    if (newNamespaces.length > 0) {
-      bodyParts.push('', '> **New namespace** — CODEOWNERS entry auto-added.');
-    }
-    bodyParts.push('', 'Uploaded via `aw push`');
-    return bodyParts.join('\n');
-  }
+// ── Create PR via gh or fallback URL ─────────────────────────────────
 
-  // Batch body — group by type
-  const grouped = {};
-  for (const f of files) {
-    if (!grouped[f.type]) grouped[f.type] = [];
-    grouped[f.type].push(f);
+function createPR(awHome, branch, prTitle, prBody) {
+  try {
+    return execFileSync('gh', [
+      'pr', 'create',
+      '--base', REGISTRY_BASE_BRANCH,
+      '--title', prTitle,
+      '--body', prBody,
+    ], { cwd: awHome, encoding: 'utf8' }).trim();
+  } catch {
+    return `https://github.com/${REGISTRY_REPO}/compare/${REGISTRY_BASE_BRANCH}...${branch}?expand=1`;
   }
+}
 
-  const bodyParts = ['## Registry Sync', ''];
-  for (const [type, items] of Object.entries(grouped)) {
-    bodyParts.push(`### ${type}`);
-    for (const item of items.sort((a, b) => a.slug.localeCompare(b.slug))) {
-      bodyParts.push(`- \`${item.slug}\` (${item.namespace})`);
-    }
-    bodyParts.push('');
-  }
+// ── Main push pipeline ────────────────────────────────────────────────
 
-  if (newNamespaces.length > 0) {
-    bodyParts.push(`> **New namespace${newNamespaces.length > 1 ? 's' : ''}:** ${newNamespaces.join(', ')} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} auto-added.`);
-    bodyParts.push('');
-  }
+function doPush(files, awHome, dryRun) {
+  const added = files.filter(f => !f.deleted);
+  const deleted = files.filter(f => f.deleted);
 
-  bodyParts.push(`---`, `Synced via \`aw push\` (${files.length} files)`);
-  return bodyParts.join('\n');
-}
+  const addedParts = Object.entries(groupBy(added, 'type')).map(([t, items]) => `${items.length} ${t}`);
+  const deletedParts = Object.entries(groupBy(deleted, 'type')).map(([t, items]) => `${items.length} ${t} removed`);
+  const countParts = [...addedParts, ...deletedParts];
 
-// ── Git pipeline (works for single file or batch) ────────────────────
-
-function pushFiles(files, { repo, dryRun, workspaceDir }) {
-  // Summary
-  const counts = {};
-  for (const f of files) {
-    counts[f.type] = (counts[f.type] || 0) + 1;
-  }
-  const countParts = Object.entries(counts).map(([type, count]) => `${count} ${type}`);
   fmt.logInfo(`${chalk.bold(files.length)} file${files.length > 1 ? 's' : ''} to push (${countParts.join(', ')})`);
 
   if (dryRun) {
     for (const f of files) {
       const ns = chalk.dim(` [${f.namespace}]`);
-      fmt.logMessage(`  ${chalk.yellow(f.type)}/${f.slug}${ns}`);
+      const label = f.deleted ? chalk.red('DELETE') : chalk.yellow(f.type);
+      fmt.logMessage(`  ${label}/${f.slug}${ns}`);
     }
     fmt.logWarn('No changes made (--dry-run)');
     fmt.outro(chalk.dim('Remove --dry-run to push'));
     return;
   }
 
-  const s = fmt.spinner();
-  s.start('Cloning registry...');
-
-  const tempDir = mkdtempSync(join(tmpdir(), 'aw-upload-'));
-
+  // Make sure we're on main before branching
   try {
-    const repoUrl = repo.startsWith('http') ? repo : `https://github.com/${repo}.git`;
-    execSync(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${tempDir}"`, { stdio: 'pipe' });
-    execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir, stdio: 'pipe' });
-    s.stop('Repository cloned');
-
-    const branch = generateBranchName(files);
-    execSync(`git checkout -b ${branch}`, { cwd: tempDir, stdio: 'pipe' });
-
-    const s2 = fmt.spinner();
-    s2.start(`Copying ${files.length} file${files.length > 1 ? 's' : ''} to registry...`);
-
-    // Copy each file
-    let copyErrors = [];
-    for (const file of files) {
-      try {
-        const targetFull = join(tempDir, file.registryTarget);
-        mkdirSync(dirname(targetFull), { recursive: true });
-        if (file.isDir) {
-          cpSync(file.absPath, targetFull, { recursive: true });
-        } else {
-          cpSync(file.absPath, targetFull);
-        }
-      } catch (e) {
-        copyErrors.push({ file: file.registryTarget, error: e.message });
-      }
-    }
-
-    if (copyErrors.length > 0) {
-      for (const err of copyErrors) {
-        fmt.logWarn(`Failed to copy ${err.file}: ${err.error}`);
-      }
-    }
-
-    // Check for new namespaces — auto-add CODEOWNERS entries
-    const topNamespaces = [...new Set(files.map(f => f.namespace.split('/')[0]))];
-    const codeownersPath = join(tempDir, 'CODEOWNERS');
-    const newNamespaces = [];
-    const ghUser = getGitHubUser();
-    for (const ns of topNamespaces) {
-      if (ghUser && isNewNamespaceInCodeowners(codeownersPath, ns)) {
-        newNamespaces.push(ns);
-        // Create CODEOWNERS if it doesn't exist yet
-        const line = `/${REGISTRY_DIR}/${ns}/ @${ghUser}\n`;
-        appendFileSync(codeownersPath, line);
-      }
-    }
-    if (newNamespaces.length > 0 && existsSync(codeownersPath)) {
-      execSync('git add CODEOWNERS', { cwd: tempDir, stdio: 'pipe' });
-    }
-
-    // Stage all registry changes
-    execSync(`git add "${REGISTRY_DIR}"`, { cwd: tempDir, stdio: 'pipe' });
+    checkoutMain(awHome);
+  } catch (e) {
+    fmt.cancel(`Could not checkout main: ${e.message}`);
+    return;
+  }
 
-    // Check if there are actual changes to commit (files may already exist in remote)
-    const diffStatus = execSync('git diff --cached --name-only', { cwd: tempDir, encoding: 'utf8' }).trim();
-    if (!diffStatus) {
-      s2.stop('No changes');
-      fmt.cancel('Nothing to push — all files already exist in registry with identical content.');
+  const branch = generateBranchName(files);
+
+  // Handle CODEOWNERS for new namespaces
+  const topNamespaces = [...new Set(files.map(f => f.namespace.split('/')[0]))];
+  const codeownersPath = join(awHome, 'CODEOWNERS');
+  const newNamespaces = [];
+  const ghUser = getGitHubUser();
+  for (const ns of topNamespaces) {
+    if (ghUser && isNewNamespaceInCodeowners(codeownersPath, ns)) {
+      newNamespaces.push(ns);
+      const line = `/${REGISTRY_DIR}/${ns}/ @${ghUser}\n`;
+      appendFileSync(codeownersPath, line);
     }
+  }
 
-    const prTitle = generatePrTitle(files);
-    const commitMsg = files.length === 1
-      ? `registry: add ${files[0].type}/${files[0].slug} to ${files[0].namespace}`
-      : `registry: sync ${files.length} files (${countParts.join(', ')})`;
-    execSync(`git commit -m "${commitMsg}"`, { cwd: tempDir, stdio: 'pipe' });
-
-    s2.stop('Upload prepared');
-
-    const s3 = fmt.spinner();
-    s3.start('Pushing and creating PR...');
-
-    execSync(`git push -u origin ${branch}`, { cwd: tempDir, stdio: 'pipe' });
-
-    const prBody = generatePrBody(files, newNamespaces);
-
-    // Try gh for PR creation, fall back to manual URL
-    let prUrl;
-    try {
-      prUrl = execFileSync('gh', [
-        'pr', 'create',
-        '--base', REGISTRY_BASE_BRANCH,
-        '--title', prTitle,
-        '--body', prBody,
-      ], { cwd: tempDir, encoding: 'utf8' }).trim();
-    } catch {
-      const repoBase = repo.replace(/\.git$/, '');
-      prUrl = `https://github.com/${repoBase}/compare/${REGISTRY_BASE_BRANCH}...${branch}?expand=1`;
-    }
+  // Build list of repo-relative paths to stage
+  const pathsToStage = files.map(f => f.registryTarget);
+  if (newNamespaces.length > 0 && existsSync(codeownersPath)) {
+    pathsToStage.push('CODEOWNERS');
+  }
 
-    s3.stop('Branch pushed');
+  const commitMsg = generateCommitMsg(files);
+  const prTitle = generatePrTitle(files);
+  const prBody = generatePrBody(files, newNamespaces);
 
-    // Print summary
-    if (newNamespaces.length > 0) {
-      fmt.logInfo(`New namespace${newNamespaces.length > 1 ? 's' : ''} ${chalk.cyan(newNamespaces.join(', '))} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} added`);
-    }
-    if (files.length > 1) {
-      for (const [type, items] of Object.entries(groupBy(files, 'type'))) {
-        fmt.logSuccess(`${items.length} ${type} pushed`);
-      }
-    }
-    // Update manifest — mark pushed files as synced (set registry_sha256 = sha256)
-    if (workspaceDir) {
-      const manifest = loadManifest(workspaceDir);
-      for (const file of files) {
-        // Convert registryTarget back to manifest key (strip REGISTRY_DIR/ prefix)
-        const manifestKey = file.registryTarget.replace(`${REGISTRY_DIR}/`, '');
-        if (manifest.files[manifestKey]) {
-          manifest.files[manifestKey].registry_sha256 = manifest.files[manifestKey].sha256;
-        }
-      }
-      saveManifest(workspaceDir, manifest);
-    }
+  const s = fmt.spinner();
+  s.start('Creating branch and pushing...');
 
-    fmt.logSuccess(`PR: ${chalk.cyan(prUrl)}`);
-    fmt.outro('Push complete');
+  let finalBranch;
+  try {
+    finalBranch = createPushBranch(awHome, branch, pathsToStage, commitMsg);
+    s.stop('Branch pushed');
   } catch (e) {
+    s.stop(chalk.red('Push failed'));
     fmt.cancel(`Push failed: ${e.message}`);
-  } finally {
-    execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' });
+    return;
   }
-}
 
-function groupBy(arr, key) {
-  const result = {};
-  for (const item of arr) {
-    const k = item[key];
-    if (!result[k]) result[k] = [];
-    result[k].push(item);
+  const s2 = fmt.spinner();
+  s2.start('Creating PR...');
+  const prUrl = createPR(awHome, finalBranch, prTitle, prBody);
+  s2.stop('PR created');
+
+  // Go back to main
+  try {
+    checkoutMain(awHome);
+  } catch { /* best effort */ }
+
+  if (newNamespaces.length > 0) {
+    fmt.logInfo(`New namespace${newNamespaces.length > 1 ? 's' : ''} ${chalk.cyan(newNamespaces.join(', '))} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} added`);
   }
-  return result;
+  fmt.logSuccess(`PR: ${chalk.cyan(prUrl)}`);
+  fmt.outro('Push complete — branch kept locally for iteration');
 }
 
 // ── Main command ─────────────────────────────────────────────────────
@@ -364,19 +335,57 @@ function groupBy(arr, key) {
 export function pushCommand(args) {
   const input = args._positional?.[0];
   const dryRun = args['--dry-run'] === true;
-  const repo = args['--repo'] || REGISTRY_REPO;
   const cwd = process.cwd();
+
+  const HOME = homedir();
+  const awHome = join(HOME, '.aw');
+  const registrySubDir = join(awHome, REGISTRY_DIR);
+  // workspaceDir for resolveInput: use local .aw_registry if present, otherwise global
   const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw push');
 
-  // No args = push all modified + new (unpushed) files
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  if (!isValidClone(awHome, repoUrl)) {
+    fmt.cancel('Registry not initialized. Run: aw init');
+    return;
+  }
+
+  // No args = detect changed files via git status
   if (!input) {
-    const files = collectModifiedFiles(workspaceDir);
+    const changes = detectChanges(awHome, REGISTRY_DIR);
+    const allEntries = [
+      ...changes.modified.map(e => ({ ...e, deleted: false })),
+      ...changes.untracked.map(e => ({ ...e, deleted: false })),
+      ...changes.deleted.map(e => ({ ...e, deleted: true })),
+    ];
+
+    if (allEntries.length === 0) {
+      fmt.cancel('Nothing to push — no modified, new, or deleted files.\n\n  Use `aw status` to see workspace state.');
+      return;
+    }
+
+    const files = allEntries
+      .map(f => {
+        const meta = parseRegistryPath(f.registryPath);
+        if (!meta) return null;
+        return {
+          absPath: join(awHome, f.path),
+          registryTarget: f.path,
+          type: meta.type,
+          namespace: meta.namespace,
+          slug: meta.slug,
+          deleted: f.deleted,
+        };
+      })
+      .filter(Boolean);
+
     if (files.length === 0) {
-      fmt.cancel('Nothing to push — no modified or new files.\n\n  Use `aw status` to see synced files.');
+      fmt.cancel('Nothing pushable found — changes must be under agents/, skills/, commands/, or evals/.');
+      return;
     }
-    pushFiles(files, { repo, dryRun, workspaceDir });
+
+    doPush(files, awHome, dryRun);
     return;
   }
 
@@ -388,6 +397,7 @@ export function pushCommand(args) {
       ? `\n\n  Tip: Use the .aw_registry/ path instead:\n  aw push .aw_registry/${input.split('/').slice(1).join('/')}`
       : '';
     fmt.cancel(`Could not resolve "${input}" to a registry path.${hint}\n\n  Only files inside .aw_registry/ can be pushed.`);
+    return;
   }
 
   let absPath = resolved.localAbsPath;
@@ -396,20 +406,26 @@ export function pushCommand(args) {
       absPath = absPath + '.md';
     } else {
       fmt.cancel(`Path not found: ${absPath || input}\n\n  Only files inside .aw_registry/ can be pushed.\n  Use ${chalk.dim('aw status')} to see modified files.`);
+      return;
     }
   }
 
-  // Folder/namespace input → batch push
+  // Folder/namespace input → batch push using registry content in awHome
   if (statSync(absPath).isDirectory()) {
-    const files = collectBatchFiles(absPath, workspaceDir);
+    const relFromRegistry = absPath.startsWith(workspaceDir + '/')
+      ? absPath.slice(workspaceDir.length + 1)
+      : resolved.registryPath;
+    const registryAbsPath = join(registrySubDir, relFromRegistry);
+    const files = collectBatchFiles(registryAbsPath, registrySubDir);
     if (files.length === 0) {
       fmt.cancel(`Nothing to push in ${chalk.cyan(input)} — no agents, skills, commands, or evals found.`);
+      return;
     }
-    pushFiles(files, { repo, dryRun, workspaceDir });
+    doPush(files, awHome, dryRun);
     return;
   }
 
-  // Single file input → wrap in array and push
+  // Single file input
   const regParts = resolved.registryPath.split('/');
   let typeIdx = -1;
   for (let i = regParts.length - 1; i >= 0; i--) {
@@ -427,6 +443,7 @@ export function pushCommand(args) {
       `    aw push .aw_registry/platform/services/skills/development`,
       `    aw push .aw_registry/commerce/shared/commands/ship.md`,
     ].join('\n'));
+    return;
   }
 
   const namespaceParts = regParts.slice(0, typeIdx);
@@ -438,32 +455,25 @@ export function pushCommand(args) {
     ? `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}`
     : `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}.md`;
 
-  pushFiles([{
+  doPush([{
     absPath,
     registryTarget,
     type: parentDir,
     namespace: namespacePath,
     slug,
     isDir,
-  }], { repo, dryRun, workspaceDir });
+    deleted: false,
+  }], awHome, dryRun);
 }
 
-// ── Helpers ──────────────────────────────────────────────────────────
+// ── Utilities ─────────────────────────────────────────────────────────
 
-function getGitHubUser() {
-  try {
-    return execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-  } catch {
-    try {
-      return execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    } catch {
-      return null;
-    }
+function groupBy(arr, key) {
+  const result = {};
+  for (const item of arr) {
+    const k = item[key];
+    if (!result[k]) result[k] = [];
+    result[k].push(item);
   }
-}
-
-function isNewNamespaceInCodeowners(codeownersPath, namespace) {
-  if (!existsSync(codeownersPath)) return true;
-  const content = readFileSync(codeownersPath, 'utf8');
-  return !content.includes(`/${REGISTRY_DIR}/${namespace}/`);
+  return result;
 }