ultraclaude-agent 0.0.21 → 0.0.23

package/src/sync.ts

@@ -107,10 +107,11 @@ export async function apiRequestWithDiskCredentials(
 
 type ManifestError = 'NOT_LOGGED_IN' | 'NETWORK_ERROR' | 'MANIFEST_FETCH_FAILED' | 'PROJECT_NOT_FOUND';
 
-export async function fetchManifest(projectId: string, credentials: AgentCredentials): Promise<Result<ManifestEntry[], ManifestError>> {
+export async function fetchManifest(projectId: string, credentials: AgentCredentials, branch?: string): Promise<Result<ManifestEntry[], ManifestError>> {
   const log = logger.child({ projectId, op: 'fetchManifest' });
 
-  const result = await apiRequest('GET', `/api/sync/manifest?projectId=${projectId}`, undefined, credentials);
+  const branchParam = branch ? `&branch=${encodeURIComponent(branch)}` : '';
+  const result = await apiRequest('GET', `/api/sync/manifest?projectId=${projectId}${branchParam}`, undefined, credentials);
   if (!result.success) return result;
 
   if (result.data.status === 404) {
@@ -142,9 +143,9 @@ export async function fetchManifest(projectId: string, credentials: AgentCredent
 /**
  * Load manifest from server and populate local section hash cache.
  */
-export async function loadManifestIntoCache(projectId: string, credentials: AgentCredentials): Promise<void> {
+export async function loadManifestIntoCache(projectId: string, credentials: AgentCredentials, branch?: string): Promise<void> {
   const state = getOrCreateState(projectId);
-  const result = await fetchManifest(projectId, credentials);
+  const result = await fetchManifest(projectId, credentials, branch);
 
   if (!result.success) {
     logger.warn({ projectId, error: result.error, message: result.message }, 'Could not load manifest — will push all sections');
@@ -172,6 +173,7 @@ export async function syncMarkdownFile(
   projectPath: string,
   absoluteFilePath: string,
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<number> {
   const log = logger.child({ projectId, file: absoluteFilePath });
 
@@ -233,6 +235,7 @@ export async function syncMarkdownFile(
 
   const payload = {
     projectId,
+    branch,
     file: relativePath,
     file_hash: fileHash,
     sections: sectionsToSend.map((s) => ({
@@ -279,6 +282,7 @@ export async function syncJsonFile(
   projectPath: string,
   absoluteFilePath: string,
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<boolean> {
   const log = logger.child({ projectId, file: absoluteFilePath });
 
@@ -301,6 +305,7 @@ export async function syncJsonFile(
 
   const payload = {
     projectId,
+    branch,
     files: [
       {
         path: relativePath,
@@ -336,11 +341,12 @@ export async function syncFile(
   projectPath: string,
   absoluteFilePath: string,
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<void> {
   if (absoluteFilePath.endsWith('.md')) {
-    await syncMarkdownFile(projectId, projectPath, absoluteFilePath, credentials);
+    await syncMarkdownFile(projectId, projectPath, absoluteFilePath, credentials, branch);
   } else if (absoluteFilePath.endsWith('.json')) {
-    await syncJsonFile(projectId, projectPath, absoluteFilePath, credentials);
+    await syncJsonFile(projectId, projectPath, absoluteFilePath, credentials, branch);
   }
 }
 
@@ -426,6 +432,7 @@ export async function createProjectOnServer(
 export async function createSnapshot(
   projectId: string,
   name: string,
+  branch: string,
   commitHash?: string,
   trigger: string = 'manual',
   credentials?: AgentCredentials,
@@ -433,11 +440,13 @@ export async function createSnapshot(
   const log = logger.child({ projectId, op: 'snapshot' });
   const idempotencyKey = crypto.randomUUID();
 
+  const body = { projectId, name, branch, commitHash, trigger };
+
   const requestFn = credentials
-    ? apiRequest('POST', '/api/sync/snapshot', { projectId, name, commitHash, trigger }, credentials, {
+    ? apiRequest('POST', '/api/sync/snapshot', body, credentials, {
         'Idempotency-Key': idempotencyKey,
       })
-    : apiRequestWithDiskCredentials('POST', '/api/sync/snapshot', { projectId, name, commitHash, trigger }, {
+    : apiRequestWithDiskCredentials('POST', '/api/sync/snapshot', body, {
         'Idempotency-Key': idempotencyKey,
       });
   const result = await requestFn;
@@ -467,13 +476,14 @@ export async function deleteFiles(
   projectPath: string,
   absoluteFilePaths: string[],
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<boolean> {
   const log = logger.child({ projectId, op: 'deleteFiles' });
   const docDir = join(projectPath, 'documentation');
 
   const relativePaths = absoluteFilePaths.map((p) => relative(docDir, p));
 
-  const payload = { projectId, files: relativePaths };
+  const payload = { projectId, branch, files: relativePaths };
   const idempotencyKey = crypto.randomUUID();
 
   const result = await apiRequest('POST', '/api/sync/delete-files', payload, credentials, {
@@ -513,10 +523,11 @@ async function reconcile(
   projectId: string,
   activePaths: string[],
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<void> {
   const log = logger.child({ projectId, op: 'reconcile' });
 
-  const payload = { projectId, filePaths: activePaths };
+  const payload = { projectId, branch, filePaths: activePaths };
   const idempotencyKey = crypto.randomUUID();
 
   const result = await apiRequest('POST', '/api/sync/reconcile', payload, credentials, {
@@ -541,17 +552,48 @@ async function reconcile(
   }
 }
 
+// --- Branch hide ---
+
+/**
+ * Notify the server that branches have been deleted locally.
+ * Server marks them as hidden (not deleted — they can be revealed in the dashboard).
+ */
+export async function hideBranches(
+  projectId: string,
+  branches: string[],
+  credentials: AgentCredentials,
+): Promise<boolean> {
+  const log = logger.child({ projectId, op: 'hideBranches' });
+
+  const payload = { projectId, branches };
+  const idempotencyKey = crypto.randomUUID();
+
+  const result = await apiRequest('POST', '/api/sync/branch-hide', payload, credentials, {
+    'Idempotency-Key': idempotencyKey,
+  });
+
+  if (!result.success || !result.data.ok) {
+    const reason = !result.success ? result.message : `HTTP ${result.data.status}`;
+    log.warn({ error: reason, branches }, 'Branch hide request failed');
+    return false;
+  }
+
+  log.info({ branches }, 'Branches hidden on server');
+  return true;
+}
+
 // --- Initial sync for a project ---
 
 export async function initialSync(
   projectId: string,
   projectPath: string,
   credentials: AgentCredentials,
+  branch: string,
 ): Promise<void> {
   const log = logger.child({ projectId, op: 'initialSync' });
-  log.info('Starting initial sync');
+  log.info({ branch }, 'Starting initial sync');
 
-  await loadManifestIntoCache(projectId, credentials);
+  await loadManifestIntoCache(projectId, credentials, branch);
 
   // Walk documentation/ and sync all files, collecting relative paths
   const { glob } = await import('node:fs/promises');
@@ -567,11 +609,11 @@ export async function initialSync(
       const relPath = relative(docDir, entry);
       activePaths.push(relPath);
 
-      await syncFile(projectId, projectPath, entry, credentials);
+      await syncFile(projectId, projectPath, entry, credentials, branch);
     }
 
     // Reconcile: prune server-side data for files that no longer exist on disk
-    await reconcile(projectId, activePaths, credentials);
+    await reconcile(projectId, activePaths, credentials, branch);
 
     log.info('Initial sync complete');
   } catch (err) {

package/src/watcher.ts

@@ -2,8 +2,10 @@
 // Watches documentation/ for changes, triggers section-level sync
 
 import chokidar from 'chokidar';
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
-import { syncFile, deleteFiles, initialSync, createSnapshot, pushVersionMetadata } from './sync.js';
+import { syncFile, deleteFiles, initialSync, createSnapshot, pushVersionMetadata, hideBranches } from './sync.js';
 import { logger } from './logger.js';
 import type { AgentCredentials } from '@ultra-claude/shared';
 
@@ -22,6 +24,49 @@ export interface ProjectWatcher {
   close(): Promise<void>;
 }
 
+/**
+ * Read the current branch name from .git/HEAD.
+ * Returns branch name for normal refs, "HEAD-{short-sha}" for detached HEAD,
+ * or "unknown" if .git/HEAD cannot be read.
+ */
+export function getCurrentBranch(projectPath: string): string {
+  const headPath = join(projectPath, '.git', 'HEAD');
+  try {
+    const content = readFileSync(headPath, 'utf8').trim();
+    if (content.startsWith('ref: refs/heads/')) {
+      return content.slice('ref: refs/heads/'.length);
+    }
+    // Detached HEAD — use short SHA
+    if (/^[0-9a-f]{40}$/.test(content)) {
+      return `HEAD-${content.slice(0, 8)}`;
+    }
+    return 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * List local branches using git for-each-ref (handles packed-refs).
+ * Returns a promise resolving to an array of branch names.
+ */
+function getLocalBranches(projectPath: string): Promise<string[]> {
+  return new Promise((resolve) => {
+    execFile(
+      'git',
+      ['for-each-ref', '--format=%(refname:short)', 'refs/heads/'],
+      { cwd: projectPath, encoding: 'utf8' },
+      (error, stdout) => {
+        if (error) {
+          resolve([]);
+          return;
+        }
+        resolve(stdout.trim().split('\n').filter(Boolean));
+      },
+    );
+  });
+}
+
 /**
  * Start watching a project's documentation/ directory for changes.
  * Also watches .git/HEAD for branch switches (triggers full resync).
@@ -36,6 +81,19 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
   // Credentials are always provided by the daemon — no disk fallback needed
   const credentialsPromise = Promise.resolve(credentials);
 
+  // Branch state — read on startup, updated on .git/HEAD change
+  let currentBranch = getCurrentBranch(projectPath);
+  log.info({ branch: currentBranch }, 'Initial branch detected');
+
+  // Track known branches for deletion detection
+  const knownBranches = new Set<string>();
+  knownBranches.add(currentBranch);
+
+  // Populate known branches from git on startup
+  getLocalBranches(projectPath).then((branches) => {
+    for (const b of branches) knownBranches.add(b);
+  }).catch(() => {});
+
   // Documentation watcher
   const docWatcher = chokidar.watch(docDir, {
     ignored: (filePath: string, stats) => {
@@ -61,7 +119,7 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
   const handleChange = (filePath: string) => {
     log.debug({ file: filePath }, 'File changed');
     credentialsPromise
-      .then(creds => syncFile(projectId, projectPath, filePath, creds))
+      .then(creds => syncFile(projectId, projectPath, filePath, creds, currentBranch))
       .then(() => {
         onPushSuccess?.(projectPath);
       })
@@ -77,7 +135,7 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
     .on('unlink', (filePath) => {
       log.info({ file: filePath }, 'File deleted — notifying server');
       credentialsPromise
-        .then(creds => deleteFiles(projectId, projectPath, [filePath], creds))
+        .then(creds => deleteFiles(projectId, projectPath, [filePath], creds, currentBranch))
         .catch((deleteErr) => {
           log.error({ err: deleteErr, file: filePath }, 'Delete notification failed for file');
         });
@@ -93,9 +151,12 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
   });
 
   gitWatcher.on('change', () => {
-    log.info('Git HEAD changed — triggering full resync');
+    const newBranch = getCurrentBranch(projectPath);
+    log.info({ oldBranch: currentBranch, newBranch }, 'Git HEAD changed — triggering full resync');
+    currentBranch = newBranch;
+    knownBranches.add(newBranch);
     credentialsPromise
-      .then(creds => initialSync(projectId, projectPath, creds))
+      .then(creds => initialSync(projectId, projectPath, creds, currentBranch))
       .catch((err) => {
         log.error({ err }, 'Full resync after git HEAD change failed');
       });
@@ -132,11 +193,11 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
       log.info('Git commit detected — creating auto-snapshot');
       credentialsPromise
         .then(async (creds) => {
-          const success = await createSnapshot(projectId, `auto: commit`, undefined, 'git_commit', creds);
+          const success = await createSnapshot(projectId, `auto: commit`, currentBranch, undefined, 'git_commit', creds);
           if (!success) {
             log.warn('Auto-snapshot failed — retrying in 2s');
             await new Promise(resolve => setTimeout(resolve, 2000));
-            await createSnapshot(projectId, `auto: commit`, undefined, 'git_commit', creds);
+            await createSnapshot(projectId, `auto: commit`, currentBranch, undefined, 'git_commit', creds);
           }
         })
         .catch((err) => {
@@ -145,11 +206,44 @@ export function startProjectWatcher(options: ProjectWatcherOptions): ProjectWatc
     }
   });
 
+  // Periodic branch deletion detection (every 5 minutes)
+  const branchCheckInterval = setInterval(() => {
+    credentialsPromise
+      .then(async (creds) => {
+        const localBranches = await getLocalBranches(projectPath);
+        const localSet = new Set(localBranches);
+        const deletedBranches: string[] = [];
+
+        for (const branch of knownBranches) {
+          // Skip detached HEAD entries and "unknown" — they aren't real branches
+          if (branch.startsWith('HEAD-') || branch === 'unknown') continue;
+          if (!localSet.has(branch)) {
+            deletedBranches.push(branch);
+          }
+        }
+
+        if (deletedBranches.length > 0) {
+          log.info({ deletedBranches }, 'Detected deleted branches — notifying server');
+          const success = await hideBranches(projectId, deletedBranches, creds);
+          if (success) {
+            for (const b of deletedBranches) knownBranches.delete(b);
+          }
+        }
+
+        // Update known branches from current local state
+        for (const b of localBranches) knownBranches.add(b);
+      })
+      .catch((checkErr) => {
+        log.error({ err: checkErr }, 'Branch deletion check failed');
+      });
+  }, 5 * 60 * 1000);
+
   return {
     projectId,
     projectPath,
     credentials,
     async close() {
+      clearInterval(branchCheckInterval);
       await Promise.all([docWatcher.close(), gitWatcher.close(), gitRefsWatcher.close(), versionWatcher.close()]);
       log.info('Watchers closed');
     },