agent-relay 1.3.1 → 1.3.3

package/dist/trajectory/config.d.ts

@@ -1,21 +1,26 @@
 /**
  * Trajectory Configuration
  *
- * Handles repo-level opt-in/opt-out for trajectory storage.
- * When trajectories are opt-out (not in source control), they're stored
- * in the user's home directory instead of the repo.
+ * Manages centralized relay configuration for trajectory storage settings.
+ * Config is stored in a central location (not per-repo) and applies to all projects.
  *
- * DECISIONS:
- * 1. Default behavior: trajectories are OPT-OUT (stored outside repo)
- *    - Reasoning: Most repos won't want trajectory files in source control
- *    - Users must explicitly opt-in to store in repo
+ * ARCHITECTURE:
+ * 1. Config location: Centralized, not repo-specific
+ *    - Primary: AGENT_RELAY_CONFIG_DIR/relay.json (if env var set)
+ *    - Default: ~/.config/agent-relay/relay.json
+ *    - Reasoning: Single config applies to all projects; survives repo deletion
  *
- * 2. Setting location: .relay/config.json in repo root
- *    - Reasoning: Keeps relay config separate from .claude/ which may have other uses
- *    - Alternative considered: .claude/settings.json - rejected to avoid conflicts
+ * 2. Default behavior: trajectories are OPT-OUT (stored in user home)
+ *    - Location: ~/.config/agent-relay/trajectories/<project-hash>/
+ *    - Users can opt-in via central config: storeInRepo: true
  *
- * 3. User-level storage: ~/.config/agent-relay/trajectories/<project-hash>/
- *    - Reasoning: XDG-compliant, project-isolated, survives repo deletion
+ * 3. Opt-in storage: .trajectories/ directory in repo root
+ *    - Applied when: User sets storeInRepo: true in central relay.json
+ *    - Users should add .trajectories/ to .gitignore if private
+ *
+ * 4. Initialization: When users initialize relay in a repo, prompt to opt-in
+ *    - Creates entry in ~/.config/agent-relay/relay.json
+ *    - Does NOT create repo-specific config
  */
 /**
  * Relay config structure
@@ -26,16 +31,29 @@ export interface RelayConfig {
         /**
          * Whether to store trajectories in the repo (.trajectories/)
          * Default: false (stored in ~/.config/agent-relay/trajectories/)
+         *
+         * NOTE: When true, this project will track trajectories in git.
+         * Users should add .trajectories/ to .gitignore if they prefer
+         * not to track trajectories for privacy reasons.
          */
         storeInRepo?: boolean;
     };
 }
 /**
  * Get the relay config file path
+ *
+ * Returns the central relay configuration file, not repo-specific.
+ * This config is shared across all projects and stored in:
+ * - AGENT_RELAY_CONFIG_DIR/relay.json (if AGENT_RELAY_CONFIG_DIR is set)
+ * - ~/.config/agent-relay/relay.json (default)
+ *
+ * NOTE: projectRoot parameter is kept for backwards compatibility but ignored.
+ * Config is always loaded from the central location.
  */
-export declare function getRelayConfigPath(projectRoot?: string): string;
+export declare function getRelayConfigPath(_projectRoot?: string): string;
 /**
- * Read the relay config from the repo
+ * Read the relay config from the central location
+ * Config is shared across all projects
  */
 export declare function readRelayConfig(projectRoot?: string): RelayConfig;
 /**

package/dist/trajectory/config.js

@@ -1,40 +1,62 @@
 /**
  * Trajectory Configuration
  *
- * Handles repo-level opt-in/opt-out for trajectory storage.
- * When trajectories are opt-out (not in source control), they're stored
- * in the user's home directory instead of the repo.
+ * Manages centralized relay configuration for trajectory storage settings.
+ * Config is stored in a central location (not per-repo) and applies to all projects.
  *
- * DECISIONS:
- * 1. Default behavior: trajectories are OPT-OUT (stored outside repo)
- *    - Reasoning: Most repos won't want trajectory files in source control
- *    - Users must explicitly opt-in to store in repo
+ * ARCHITECTURE:
+ * 1. Config location: Centralized, not repo-specific
+ *    - Primary: AGENT_RELAY_CONFIG_DIR/relay.json (if env var set)
+ *    - Default: ~/.config/agent-relay/relay.json
+ *    - Reasoning: Single config applies to all projects; survives repo deletion
  *
- * 2. Setting location: .relay/config.json in repo root
- *    - Reasoning: Keeps relay config separate from .claude/ which may have other uses
- *    - Alternative considered: .claude/settings.json - rejected to avoid conflicts
+ * 2. Default behavior: trajectories are OPT-OUT (stored in user home)
+ *    - Location: ~/.config/agent-relay/trajectories/<project-hash>/
+ *    - Users can opt-in via central config: storeInRepo: true
  *
- * 3. User-level storage: ~/.config/agent-relay/trajectories/<project-hash>/
- *    - Reasoning: XDG-compliant, project-isolated, survives repo deletion
+ * 3. Opt-in storage: .trajectories/ directory in repo root
+ *    - Applied when: User sets storeInRepo: true in central relay.json
+ *    - Users should add .trajectories/ to .gitignore if private
+ *
+ * 4. Initialization: When users initialize relay in a repo, prompt to opt-in
+ *    - Creates entry in ~/.config/agent-relay/relay.json
+ *    - Does NOT create repo-specific config
  */
 import { existsSync, readFileSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { getProjectPaths } from '../utils/project-namespace.js';
+/**
+ * Get the central agent-relay config directory
+ * Uses AGENT_RELAY_CONFIG_DIR environment variable if set,
+ * otherwise defaults to ~/.config/agent-relay
+ */
+function getAgentRelayConfigDir() {
+    return process.env.AGENT_RELAY_CONFIG_DIR ??
+        join(homedir(), '.config', 'agent-relay');
+}
 /**
  * Cache for config to avoid repeated file reads
  */
 let configCache = null;
 /**
  * Get the relay config file path
+ *
+ * Returns the central relay configuration file, not repo-specific.
+ * This config is shared across all projects and stored in:
+ * - AGENT_RELAY_CONFIG_DIR/relay.json (if AGENT_RELAY_CONFIG_DIR is set)
+ * - ~/.config/agent-relay/relay.json (default)
+ *
+ * NOTE: projectRoot parameter is kept for backwards compatibility but ignored.
+ * Config is always loaded from the central location.
  */
-export function getRelayConfigPath(projectRoot) {
-    const root = projectRoot ?? getProjectPaths().projectRoot;
-    return join(root, '.relay', 'config.json');
+export function getRelayConfigPath(_projectRoot) {
+    return join(getAgentRelayConfigDir(), 'relay.json');
 }
 /**
- * Read the relay config from the repo
+ * Read the relay config from the central location
+ * Config is shared across all projects
  */
 export function readRelayConfig(projectRoot) {
     const configPath = getRelayConfigPath(projectRoot);

package/dist/trajectory/integration.js

@@ -14,13 +14,40 @@
  * - Provides hooks for key agent lifecycle events
  */
 import { spawn, execSync } from 'node:child_process';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectPaths } from '../utils/project-namespace.js';
 import { getPrimaryTrajectoriesDir, getAllTrajectoriesDirs, getTrajectoryEnvVars, } from './config.js';
 /**
  * Read a single trajectory index file from a directory
  */
+function resolveIndexEntryPath(trajectoriesDir, entryPath) {
+    if (!entryPath) {
+        return entryPath;
+    }
+    if (existsSync(entryPath)) {
+        return entryPath;
+    }
+    const normalized = entryPath.replace(/\\/g, '/');
+    const marker = '/.trajectories/';
+    const markerIndex = normalized.indexOf(marker);
+    if (markerIndex >= 0) {
+        const relative = normalized.slice(markerIndex + marker.length);
+        const candidate = join(trajectoriesDir, relative);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    const subdirMatch = normalized.match(/\/(active|completed)\/.+$/);
+    if (subdirMatch) {
+        const relative = subdirMatch[0].slice(1);
+        const candidate = join(trajectoriesDir, relative);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return entryPath;
+}
 function readSingleTrajectoryIndex(trajectoriesDir) {
     try {
         const indexPath = join(trajectoriesDir, 'index.json');
@@ -28,7 +55,15 @@ function readSingleTrajectoryIndex(trajectoriesDir) {
             return null;
         }
         const content = readFileSync(indexPath, 'utf-8');
-        return JSON.parse(content);
+        const index = JSON.parse(content);
+        const trajectories = index.trajectories ?? {};
+        for (const [id, entry] of Object.entries(trajectories)) {
+            trajectories[id] = {
+                ...entry,
+                path: resolveIndexEntryPath(trajectoriesDir, entry.path),
+            };
+        }
+        return { ...index, trajectories };
     }
     catch {
         return null;
@@ -91,6 +126,39 @@ function readTrajectoryFile(trajectoryPath) {
         return null;
     }
 }
+function getCurrentPhaseFromTrajectory(trajectory) {
+    if (!trajectory?.chapters?.length) {
+        return undefined;
+    }
+    const lastChapter = trajectory.chapters[trajectory.chapters.length - 1];
+    for (const event of [...(lastChapter.events || [])].reverse()) {
+        if (event.type === 'phase_transition' || event.type === 'phase') {
+            const phaseMatch = event.content?.match(/phase[:\s]+(\w+)/i);
+            if (phaseMatch) {
+                return phaseMatch[1].toLowerCase();
+            }
+        }
+    }
+    return undefined;
+}
+function listActiveTrajectoryFiles(trajectoriesDir) {
+    const activeDir = join(trajectoriesDir, 'active');
+    if (!existsSync(activeDir)) {
+        return [];
+    }
+    return readdirSync(activeDir, { withFileTypes: true })
+        .filter(entry => entry.isFile() && entry.name.endsWith('.json'))
+        .map(entry => join(activeDir, entry.name));
+}
+function findActiveTrajectoryPathById(trajectoryDirs, trajectoryId) {
+    for (const dir of trajectoryDirs) {
+        const candidate = join(dir, 'active', `${trajectoryId}.json`);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
 /**
  * Run a trail CLI command
  * Uses config-based environment to control trajectory storage location
@@ -163,33 +231,37 @@ export async function startTrajectory(options) {
  */
 export async function getTrajectoryStatus() {
     const index = readTrajectoryIndex();
-    if (!index) {
+    const trajectoryDirs = getAllTrajectoriesDirs();
+    if (!index && trajectoryDirs.length === 0) {
         return { active: false };
     }
     // Find an active trajectory
-    for (const [id, entry] of Object.entries(index.trajectories)) {
-        if (entry.status === 'active') {
-            // Read the full trajectory file to get phase info
-            const trajectory = readTrajectoryFile(entry.path);
-            let currentPhase;
-            if (trajectory?.chapters?.length) {
-                const lastChapter = trajectory.chapters[trajectory.chapters.length - 1];
-                // Check events for phase transitions
-                for (const event of [...(lastChapter.events || [])].reverse()) {
-                    if (event.type === 'phase_transition' || event.type === 'phase') {
-                        const phaseMatch = event.content?.match(/phase[:\s]+(\w+)/i);
-                        if (phaseMatch) {
-                            currentPhase = phaseMatch[1].toLowerCase();
-                            break;
-                        }
-                    }
-                }
+    if (index) {
+        for (const [id, entry] of Object.entries(index.trajectories)) {
+            if (entry.status === 'active') {
+                // Read the full trajectory file to get phase info
+                const trajectory = readTrajectoryFile(entry.path);
+                const currentPhase = getCurrentPhaseFromTrajectory(trajectory);
+                return {
+                    active: true,
+                    trajectoryId: id,
+                    phase: currentPhase,
+                    task: entry.title,
+                };
+            }
+        }
+    }
+    for (const dir of trajectoryDirs) {
+        for (const activePath of listActiveTrajectoryFiles(dir)) {
+            const trajectory = readTrajectoryFile(activePath);
+            if (!trajectory) {
+                continue;
             }
             return {
                 active: true,
-                trajectoryId: id,
-                phase: currentPhase,
-                task: entry.title,
+                trajectoryId: trajectory.id,
+                phase: getCurrentPhaseFromTrajectory(trajectory),
+                task: trajectory.task?.title,
             };
         }
     }
@@ -284,51 +356,98 @@ export async function abandonTrajectory(reason) {
  * Reads directly from filesystem instead of using CLI
  */
 export async function listTrajectorySteps(trajectoryId) {
+    const trajectoryDirs = getAllTrajectoriesDirs();
     const index = readTrajectoryIndex();
-    if (!index) {
+    if (!index && trajectoryDirs.length === 0) {
         return { success: true, steps: [] };
     }
-    // Find the trajectory to load
-    let trajectoryPath;
+    // Collect all trajectory paths to load
+    const trajectoryPaths = new Set();
     if (trajectoryId) {
-        // Use specified trajectory
-        const entry = index.trajectories[trajectoryId];
+        // Use specified trajectory - try multiple lookup strategies
+        let foundPath = null;
+        // Strategy 1: Look up by index key
+        const entry = index?.trajectories[trajectoryId];
         if (entry) {
-            trajectoryPath = entry.path;
+            foundPath = entry.path;
+            console.log('[trajectory] Found by index key:', trajectoryId, '->', foundPath);
+        }
+        // Strategy 2: If not found by key, search index entries by file's internal ID
+        // This handles cases where the index key differs from the file's internal ID
+        if (!foundPath && index) {
+            for (const [_key, indexEntry] of Object.entries(index.trajectories)) {
+                const trajectory = readTrajectoryFile(indexEntry.path);
+                if (trajectory && trajectory.id === trajectoryId) {
+                    foundPath = indexEntry.path;
+                    console.log('[trajectory] Found by file ID scan:', trajectoryId, '->', foundPath);
+                    break;
+                }
+            }
+        }
+        // Strategy 3: Fall back to active directory filename match
+        if (!foundPath) {
+            foundPath = findActiveTrajectoryPathById(trajectoryDirs, trajectoryId);
+            if (foundPath) {
+                console.log('[trajectory] Found by active dir fallback:', trajectoryId, '->', foundPath);
+            }
+        }
+        if (foundPath) {
+            trajectoryPaths.add(foundPath);
+        }
+        else {
+            console.log('[trajectory] Not found:', trajectoryId);
         }
     }
     else {
-        // Find active trajectory
-        for (const [_id, entry] of Object.entries(index.trajectories)) {
-            if (entry.status === 'active') {
-                trajectoryPath = entry.path;
-                break;
+        // Collect ALL active trajectories (not just the first one)
+        if (index) {
+            for (const [_id, entry] of Object.entries(index.trajectories)) {
+                if (entry.status === 'active') {
+                    trajectoryPaths.add(entry.path);
+                }
+            }
+        }
+        for (const dir of trajectoryDirs) {
+            for (const activePath of listActiveTrajectoryFiles(dir)) {
+                trajectoryPaths.add(activePath);
             }
         }
     }
-    if (!trajectoryPath) {
-        return { success: true, steps: [] };
-    }
-    const trajectory = readTrajectoryFile(trajectoryPath);
-    if (!trajectory) {
+    if (trajectoryPaths.size === 0) {
         return { success: true, steps: [] };
     }
-    // Extract events from all chapters
+    // Load all trajectories and merge their steps
     const steps = [];
     let stepIndex = 0;
-    for (const chapter of trajectory.chapters || []) {
-        for (const event of chapter.events || []) {
-            steps.push({
-                id: `step-${stepIndex++}`,
-                timestamp: event.ts || Date.now(),
-                type: mapEventType(event.type),
-                title: event.content?.slice(0, 50) || event.type || 'Event',
-                description: event.content,
-                metadata: event.raw,
-                status: mapEventStatus(trajectory.status),
-            });
+    for (const trajectoryPath of trajectoryPaths) {
+        const trajectory = readTrajectoryFile(trajectoryPath);
+        if (!trajectory) {
+            continue;
+        }
+        // Extract events from all chapters
+        // Include trajectory ID in step IDs to ensure uniqueness across trajectories
+        // This prevents React key collisions when switching between trajectories
+        const trajId = trajectory.id || 'unknown';
+        for (const chapter of trajectory.chapters || []) {
+            for (const event of chapter.events || []) {
+                steps.push({
+                    id: `${trajId}-step-${stepIndex++}`,
+                    timestamp: event.ts || Date.now(),
+                    type: mapEventType(event.type),
+                    title: event.content?.slice(0, 50) || event.type || 'Event',
+                    description: event.content,
+                    metadata: event.raw,
+                    status: mapEventStatus(trajectory.status),
+                });
+            }
         }
     }
+    // Sort steps by timestamp to maintain chronological order across all trajectories
+    steps.sort((a, b) => {
+        const timeA = typeof a.timestamp === 'number' ? a.timestamp : new Date(a.timestamp).getTime();
+        const timeB = typeof b.timestamp === 'number' ? b.timestamp : new Date(b.timestamp).getTime();
+        return timeA - timeB;
+    });
     return { success: true, steps };
 }
 /**
@@ -336,22 +455,33 @@ export async function listTrajectorySteps(trajectoryId) {
  * Reads directly from filesystem
  */
 export async function getTrajectoryHistory() {
+    const trajectoryDirs = getAllTrajectoriesDirs();
     const index = readTrajectoryIndex();
-    if (!index) {
+    if (!index && trajectoryDirs.length === 0) {
         return { success: true, trajectories: [] };
     }
     const trajectories = [];
-    for (const [id, entry] of Object.entries(index.trajectories)) {
-        const historyEntry = {
-            id,
-            title: entry.title,
-            status: entry.status,
-            startedAt: entry.startedAt,
-            completedAt: entry.completedAt,
-        };
-        // Try to read full trajectory for additional details
-        if (entry.path) {
-            const trajectory = readTrajectoryFile(entry.path);
+    const seenIds = new Set();
+    if (index) {
+        for (const [indexKey, entry] of Object.entries(index.trajectories)) {
+            // Read the trajectory file to get the actual internal ID
+            // This ensures consistency between history list IDs and file content
+            const trajectory = entry.path ? readTrajectoryFile(entry.path) : null;
+            // Use the file's internal ID if available, otherwise fall back to index key
+            // This fixes the mismatch where index key differs from file's internal ID
+            const actualId = trajectory?.id || indexKey;
+            // Skip if we've already seen this ID (from a previous directory's index)
+            if (seenIds.has(actualId)) {
+                continue;
+            }
+            const historyEntry = {
+                id: actualId,
+                title: trajectory?.task?.title || entry.title,
+                status: entry.status,
+                startedAt: trajectory?.startedAt || entry.startedAt,
+                completedAt: trajectory?.completedAt || entry.completedAt,
+            };
+            // Add additional details from trajectory file
             if (trajectory) {
                 historyEntry.agents = trajectory.agents?.map(a => a.name);
                 if (trajectory.retrospective) {
@@ -359,8 +489,31 @@ export async function getTrajectoryHistory() {
                     historyEntry.confidence = trajectory.retrospective.confidence;
                 }
             }
+            trajectories.push(historyEntry);
+            seenIds.add(actualId);
+        }
+    }
+    for (const dir of trajectoryDirs) {
+        for (const activePath of listActiveTrajectoryFiles(dir)) {
+            const trajectory = readTrajectoryFile(activePath);
+            if (!trajectory || seenIds.has(trajectory.id)) {
+                continue;
+            }
+            const historyEntry = {
+                id: trajectory.id,
+                title: trajectory.task?.title || 'Untitled trajectory',
+                status: trajectory.status ?? 'active',
+                startedAt: trajectory.startedAt,
+                completedAt: trajectory.completedAt,
+                agents: trajectory.agents?.map(a => a.name),
+            };
+            if (trajectory.retrospective) {
+                historyEntry.summary = trajectory.retrospective.summary;
+                historyEntry.confidence = trajectory.retrospective.confidence;
+            }
+            trajectories.push(historyEntry);
+            seenIds.add(trajectory.id);
         }
-        trajectories.push(historyEntry);
     }
     // Sort by startedAt descending (most recent first)
     trajectories.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());

package/dist/utils/git-remote.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Git Remote Detection Utility
+ *
+ * Detects the git remote URL from a working directory and parses it
+ * to extract the repository full name (owner/repo).
+ */
+/**
+ * Parse a git remote URL to extract owner/repo format.
+ *
+ * Supports:
+ * - git@github.com:owner/repo.git
+ * - https://github.com/owner/repo.git
+ * - https://github.com/owner/repo
+ * - git://github.com/owner/repo.git
+ */
+export declare function parseGitRemoteUrl(url: string): string | null;
+/**
+ * Get the git remote URL from a directory.
+ *
+ * @param workingDirectory The directory to check for git remote
+ * @param remoteName The remote name to use (default: 'origin')
+ * @returns The remote URL or null if not found
+ */
+export declare function getGitRemoteUrl(workingDirectory: string, remoteName?: string): string | null;
+/**
+ * Get the repository full name (owner/repo) from a working directory.
+ *
+ * @param workingDirectory The directory to check
+ * @returns The repo full name (e.g., "AgentWorkforce/relay") or null
+ */
+export declare function getRepoFullName(workingDirectory: string): string | null;
+/**
+ * Find the git root directory from a given path.
+ * Walks up the directory tree looking for .git folder.
+ *
+ * @param startPath The path to start searching from
+ * @returns The git root directory or null if not in a git repo
+ */
+export declare function findGitRoot(startPath: string): string | null;
+/**
+ * Get repository full name, walking up to find git root if needed.
+ *
+ * @param workingDirectory The directory to start from
+ * @returns The repo full name or null
+ */
+export declare function getRepoFullNameFromPath(workingDirectory: string): string | null;
+//# sourceMappingURL=git-remote.d.ts.map