agor-live 0.3.7

package/dist/core/dist/feathers-BzHEPnpl.d.ts

@@ -0,0 +1,228 @@
+import { Params, HookContext as HookContext$1, Paginated } from '@feathersjs/feathers';
+
+/**
+ * FeathersJS Type Abstractions
+ *
+ * Centralized type definitions for FeathersJS patterns used across Agor.
+ * These types provide a consistent interface for both client and server.
+ *
+ * Re-exports FeathersJS types so daemon doesn't need direct dependencies.
+ */
+
+/**
+ * Authenticated user from JWT/Local strategy
+ *
+ * Extracted from JWT token or local authentication.
+ * Available in hook context and service params after authentication.
+ */
+interface AuthenticatedUser {
+    /** User ID (UUIDv7) */
+    user_id: string;
+    /** User email address */
+    email: string;
+    /** User role (for authorization) */
+    role?: string;
+}
+/**
+ * Extended params with authentication context
+ *
+ * All authenticated requests include user information in params.
+ */
+interface AuthenticatedParams extends Params {
+    /** Authenticated user (undefined for anonymous requests) */
+    user?: AuthenticatedUser;
+}
+/**
+ * Generic service query parameters with Feathers $ modifiers
+ *
+ * Supports pagination, sorting, field selection, and entity-specific filters.
+ *
+ * @template T - Entity type for type-safe filtering
+ *
+ * @example
+ * ```ts
+ * interface SessionQuery extends QueryParams<Session> {
+ *   query?: {
+ *     status?: Session['status'];
+ *     agentic_tool?: Session['agentic_tool'];
+ *     $limit?: number;
+ *     $skip?: number;
+ *   };
+ * }
+ * ```
+ */
+interface QueryParams<T = unknown> extends Params {
+    query?: {
+        /** Maximum number of results to return */
+        $limit?: number;
+        /** Number of results to skip (for pagination) */
+        $skip?: number;
+        /** Sort order (1 = ascending, -1 = descending) */
+        $sort?: Record<string, 1 | -1>;
+        /** Fields to include in results */
+        $select?: string[];
+    } & Partial<T>;
+}
+/**
+ * Hook context for create operations
+ *
+ * Supports both single objects and arrays for bulk operations.
+ * Data can be the full entity or partial (for creates).
+ *
+ * @template T - Entity type
+ *
+ * @example
+ * ```ts
+ * async function validateMessage(context: CreateHookContext<Message>) {
+ *   // context.data is Message | Message[]
+ *   const messages = Array.isArray(context.data) ? context.data : [context.data];
+ *   for (const msg of messages) {
+ *     if (!msg.content) throw new Error('Message content required');
+ *   }
+ * }
+ * ```
+ */
+interface CreateHookContext<T = unknown> extends HookContext$1 {
+    params: AuthenticatedParams;
+    data: T | T[];
+}
+/**
+ * Hook context for update/patch operations
+ *
+ * Data is optional (may be undefined for get/find/remove operations).
+ * Supports partial updates via Partial<T>.
+ *
+ * @template T - Entity type
+ */
+interface HookContext<T = unknown> extends HookContext$1 {
+    params: AuthenticatedParams;
+    data?: Partial<T> | Partial<T>[];
+}
+/**
+ * Base Feathers service interface with standard CRUD methods
+ *
+ * All Agor services implement this interface for consistency.
+ * Custom methods can be added via interface extension.
+ *
+ * @template T - Entity type (e.g., Session, Task, Message)
+ * @template D - Data type for create/update (defaults to Partial<T>)
+ * @template P - Params type (defaults to Params)
+ *
+ * @example
+ * ```ts
+ * interface SessionsService extends BaseService<Session, Partial<Session>, SessionParams> {
+ *   // Add custom methods
+ *   fork(id: string, data: { prompt: string }, params?: SessionParams): Promise<Session>;
+ * }
+ * ```
+ */
+interface BaseService<T, D = Partial<T>, P extends Params = Params> {
+    /**
+     * Find entities matching query criteria
+     *
+     * Returns paginated results if pagination is enabled, otherwise array.
+     */
+    find(params?: P): Promise<Paginated<T> | T[]>;
+    /**
+     * Get a single entity by ID
+     *
+     * @param id - Entity ID (usually UUIDv7)
+     * @param params - Query parameters
+     * @throws EntityNotFoundError if not found
+     */
+    get(id: string, params?: P): Promise<T>;
+    /**
+     * Create a new entity
+     *
+     * @param data - Entity data (full or partial)
+     * @param params - Request parameters
+     * @returns Created entity with generated fields (ID, timestamps)
+     */
+    create(data: D, params?: P): Promise<T>;
+    /**
+     * Replace an entity entirely (PUT semantics)
+     *
+     * @param id - Entity ID
+     * @param data - Complete entity data
+     * @param params - Request parameters
+     * @returns Updated entity
+     */
+    update(id: string, data: T, params?: P): Promise<T>;
+    /**
+     * Partially update an entity (PATCH semantics)
+     *
+     * Supports both single and multi-patch operations.
+     *
+     * @param id - Entity ID (or null for multi-patch)
+     * @param data - Partial entity data
+     * @param params - Request parameters
+     * @returns Updated entity
+     */
+    patch(id: string | null, data: D, params?: P): Promise<T>;
+    /**
+     * Remove an entity
+     *
+     * @param id - Entity ID
+     * @param params - Request parameters
+     * @returns Removed entity
+     */
+    remove(id: string, params?: P): Promise<T>;
+}
+/**
+ * Service with event emitter capabilities
+ *
+ * Feathers services emit events for real-time updates via Socket.IO.
+ * Clients can listen to these events for live data synchronization.
+ *
+ * @template T - Entity type
+ */
+interface ServiceWithEvents<T> extends BaseService<T> {
+    /**
+     * Subscribe to service events
+     *
+     * Standard events: created, updated, patched, removed
+     *
+     * @param event - Event name
+     * @param handler - Event handler function
+     *
+     * @example
+     * ```ts
+     * service.on('created', (session: Session) => {
+     *   console.log('New session:', session.session_id);
+     * });
+     * ```
+     */
+    on(event: string, handler: (data: T) => void): void;
+    /**
+     * Unsubscribe from service events
+     *
+     * @param event - Event name
+     * @param handler - Event handler to remove
+     */
+    removeListener(event: string, handler: (data: T) => void): void;
+}
+/**
+ * Authentication result from Feathers authentication
+ *
+ * Returned by authenticate() method after successful login.
+ * Contains JWT token and user information.
+ */
+interface AuthenticationResult {
+    /** JWT access token */
+    accessToken: string;
+    /** Authentication metadata */
+    authentication: {
+        /** Strategy used (e.g., 'local', 'jwt', 'anonymous') */
+        strategy: string;
+        /** Token (may be undefined for anonymous) */
+        accessToken?: string;
+        /** Decoded JWT payload */
+        payload?: Record<string, unknown>;
+    };
+    /** Authenticated user (if available) */
+    user?: AuthenticatedUser;
+    /** Additional fields from strategy */
+    [key: string]: unknown;
+}
+
+export type { AuthenticatedUser as A, BaseService as B, CreateHookContext as C, HookContext as H, QueryParams as Q, ServiceWithEvents as S, AuthenticatedParams as a, AuthenticationResult as b };

package/dist/core/dist/git/index.cjs

@@ -0,0 +1,302 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/git/index.ts
+var git_exports = {};
+__export(git_exports, {
+  cloneRepo: () => cloneRepo,
+  createWorktree: () => createWorktree,
+  extractRepoName: () => extractRepoName,
+  getCurrentBranch: () => getCurrentBranch,
+  getCurrentSha: () => getCurrentSha,
+  getDefaultBranch: () => getDefaultBranch,
+  getGitState: () => getGitState,
+  getRemoteBranches: () => getRemoteBranches,
+  getRemoteUrl: () => getRemoteUrl,
+  getReposDir: () => getReposDir,
+  getWorktreePath: () => getWorktreePath,
+  getWorktreesDir: () => getWorktreesDir,
+  hasRemoteBranch: () => hasRemoteBranch,
+  isClean: () => isClean,
+  isGitRepo: () => isGitRepo,
+  listWorktrees: () => listWorktrees,
+  pruneWorktrees: () => pruneWorktrees,
+  removeWorktree: () => removeWorktree
+});
+module.exports = __toCommonJS(git_exports);
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_simple_git = require("simple-git");
+function getGitBinary() {
+  const commonPaths = [
+    "/opt/homebrew/bin/git",
+    // Homebrew on Apple Silicon
+    "/usr/local/bin/git",
+    // Homebrew on Intel
+    "/usr/bin/git"
+    // System git (Docker and Linux)
+  ];
+  for (const path of commonPaths) {
+    if ((0, import_node_fs.existsSync)(path)) {
+      return path;
+    }
+  }
+  return void 0;
+}
+function createGit(baseDir) {
+  const gitBinary = getGitBinary();
+  const config = [
+    "core.sshCommand=ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+  ];
+  return (0, import_simple_git.simpleGit)({
+    baseDir,
+    binary: gitBinary,
+    config
+  });
+}
+function getReposDir() {
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".agor", "repos");
+}
+function extractRepoName(url) {
+  const match = url.match(/\/([^/]+?)(?:\.git)?$/);
+  if (!match) {
+    throw new Error(`Could not extract repo name from URL: ${url}`);
+  }
+  return match[1];
+}
+async function cloneRepo(options) {
+  const repoName = extractRepoName(options.url);
+  const reposDir = getReposDir();
+  const targetPath = options.targetDir || (0, import_node_path.join)(reposDir, repoName);
+  await (0, import_promises.mkdir)(reposDir, { recursive: true });
+  if ((0, import_node_fs.existsSync)(targetPath)) {
+    const isValid = await isGitRepo(targetPath);
+    if (isValid) {
+      console.log(`Repository already exists at ${targetPath}, using existing clone`);
+      const defaultBranch2 = await getDefaultBranch(targetPath);
+      return {
+        path: targetPath,
+        repoName,
+        defaultBranch: defaultBranch2
+      };
+    } else {
+      throw new Error(
+        `Directory exists but is not a valid git repository: ${targetPath}
+Please delete this directory manually and try again.`
+      );
+    }
+  }
+  const git = createGit();
+  if (options.onProgress) {
+    git.outputHandler((_command, _stdout, _stderr) => {
+    });
+  }
+  await git.clone(options.url, targetPath, options.bare ? ["--bare"] : []);
+  const defaultBranch = await getDefaultBranch(targetPath);
+  return {
+    path: targetPath,
+    repoName,
+    defaultBranch
+  };
+}
+async function isGitRepo(path) {
+  try {
+    const git = createGit(path);
+    await git.status();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch(repoPath) {
+  const git = createGit(repoPath);
+  const status = await git.status();
+  return status.current || "";
+}
+async function getDefaultBranch(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  try {
+    const result = await git.raw(["symbolic-ref", `refs/remotes/${remote}/HEAD`]);
+    const match = result.trim().match(/refs\/remotes\/[^/]+\/(.+)/);
+    if (match && match[1]) {
+      return match[1];
+    }
+  } catch {
+  }
+  try {
+    const branches = await git.branch();
+    return branches.current || "main";
+  } catch {
+    return "main";
+  }
+}
+async function getCurrentSha(repoPath) {
+  const git = createGit(repoPath);
+  const log = await git.log({ maxCount: 1 });
+  return log.latest?.hash || "";
+}
+async function isClean(repoPath) {
+  const git = createGit(repoPath);
+  const status = await git.status();
+  return status.isClean();
+}
+async function getRemoteUrl(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  const remotes = await git.getRemotes(true);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  return remoteObj?.refs.fetch || "";
+}
+function getWorktreesDir() {
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".agor", "worktrees");
+}
+function getWorktreePath(repoSlug, worktreeName) {
+  return (0, import_node_path.join)(getWorktreesDir(), repoSlug, worktreeName);
+}
+async function createWorktree(repoPath, worktreePath, ref, createBranch = false, pullLatest = true, sourceBranch) {
+  const git = createGit(repoPath);
+  let fetchSucceeded = false;
+  if (pullLatest) {
+    try {
+      await git.fetch(["origin"]);
+      fetchSucceeded = true;
+      console.log("\u2705 Fetched latest from origin");
+      if (!createBranch) {
+        try {
+          const branches = await git.branch();
+          const localBranchExists = branches.all.includes(ref);
+          if (localBranchExists) {
+            const remoteBranches = await git.branch(["-r"]);
+            const remoteBranchExists = remoteBranches.all.includes(`origin/${ref}`);
+            if (remoteBranchExists) {
+              await git.raw(["branch", "-f", ref, `origin/${ref}`]);
+              console.log(`\u2705 Updated local ${ref} to match origin/${ref}`);
+            }
+          }
+        } catch (error) {
+          console.warn(
+            `\u26A0\uFE0F  Failed to update local ${ref} branch:`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  Failed to fetch from origin (will use local refs):",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const args = [worktreePath];
+  if (createBranch) {
+    args.push("-b", ref);
+    if (sourceBranch) {
+      const baseRef = fetchSucceeded ? `origin/${sourceBranch}` : sourceBranch;
+      args.push(baseRef);
+    }
+  } else {
+    args.push(ref);
+  }
+  await git.raw(["worktree", "add", ...args]);
+}
+async function listWorktrees(repoPath) {
+  const git = createGit(repoPath);
+  const output = await git.raw(["worktree", "list", "--porcelain"]);
+  const worktrees = [];
+  const lines = output.split("\n");
+  let current = {};
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      current.path = line.substring(9);
+      current.name = (0, import_node_path.basename)(current.path);
+    } else if (line.startsWith("HEAD ")) {
+      current.sha = line.substring(5);
+    } else if (line.startsWith("branch ")) {
+      current.ref = line.substring(7).replace("refs/heads/", "");
+      current.detached = false;
+    } else if (line.startsWith("detached")) {
+      current.detached = true;
+    } else if (line === "") {
+      if (current.path && current.sha) {
+        worktrees.push(current);
+      }
+      current = {};
+    }
+  }
+  if (current.path && current.sha) {
+    worktrees.push(current);
+  }
+  return worktrees;
+}
+async function removeWorktree(repoPath, worktreeName) {
+  const git = createGit(repoPath);
+  await git.raw(["worktree", "remove", worktreeName]);
+}
+async function pruneWorktrees(repoPath) {
+  const git = createGit(repoPath);
+  await git.raw(["worktree", "prune"]);
+}
+async function hasRemoteBranch(repoPath, branchName, remote = "origin") {
+  const git = createGit(repoPath);
+  const branches = await git.branch(["-r"]);
+  return branches.all.includes(`${remote}/${branchName}`);
+}
+async function getRemoteBranches(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  const branches = await git.branch(["-r"]);
+  return branches.all.filter((b) => b.startsWith(`${remote}/`)).map((b) => b.replace(`${remote}/`, ""));
+}
+async function getGitState(repoPath) {
+  try {
+    if (!await isGitRepo(repoPath)) {
+      return "unknown";
+    }
+    const sha = await getCurrentSha(repoPath);
+    if (!sha) {
+      return "unknown";
+    }
+    const clean = await isClean(repoPath);
+    return clean ? sha : `${sha}-dirty`;
+  } catch (error) {
+    console.warn(`Failed to get git state for ${repoPath}:`, error);
+    return "unknown";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloneRepo,
+  createWorktree,
+  extractRepoName,
+  getCurrentBranch,
+  getCurrentSha,
+  getDefaultBranch,
+  getGitState,
+  getRemoteBranches,
+  getRemoteUrl,
+  getReposDir,
+  getWorktreePath,
+  getWorktreesDir,
+  hasRemoteBranch,
+  isClean,
+  isGitRepo,
+  listWorktrees,
+  pruneWorktrees,
+  removeWorktree
+});

package/dist/core/dist/git/index.d.cts

@@ -0,0 +1,137 @@
+/**
+ * Git Utils for Agor
+ *
+ * Provides Git operations for repo management and worktree isolation
+ */
+interface CloneOptions {
+    url: string;
+    targetDir?: string;
+    bare?: boolean;
+    onProgress?: (progress: CloneProgress) => void;
+}
+interface CloneProgress {
+    method: string;
+    stage: string;
+    progress: number;
+    processed?: number;
+    total?: number;
+}
+interface CloneResult {
+    path: string;
+    repoName: string;
+    defaultBranch: string;
+}
+/**
+ * Get default Agor repos directory (~/.agor/repos)
+ */
+declare function getReposDir(): string;
+/**
+ * Extract repo name from Git URL
+ *
+ * Examples:
+ * - git@github.com:apache/superset.git -> superset
+ * - https://github.com/facebook/react.git -> react
+ */
+declare function extractRepoName(url: string): string;
+/**
+ * Clone a Git repository to ~/.agor/repos/<name>
+ *
+ * If the repository already exists and is valid, returns existing repo info.
+ * If directory exists but is not a valid repo, throws an error with suggestion to delete.
+ *
+ * @param options - Clone options
+ * @returns Clone result with path and metadata
+ */
+declare function cloneRepo(options: CloneOptions): Promise<CloneResult>;
+/**
+ * Check if a directory is a Git repository
+ */
+declare function isGitRepo(path: string): Promise<boolean>;
+/**
+ * Get current branch name
+ */
+declare function getCurrentBranch(repoPath: string): Promise<string>;
+/**
+ * Get repository's default branch
+ *
+ * This is the branch that the remote HEAD points to (e.g., 'main', 'master', 'develop').
+ * Uses git symbolic-ref to determine the default branch accurately.
+ *
+ * @param repoPath - Path to repository
+ * @param remote - Remote name (default: 'origin')
+ * @returns Default branch name (e.g., 'main')
+ */
+declare function getDefaultBranch(repoPath: string, remote?: string): Promise<string>;
+/**
+ * Get current commit SHA
+ */
+declare function getCurrentSha(repoPath: string): Promise<string>;
+/**
+ * Check if working directory is clean (no uncommitted changes)
+ */
+declare function isClean(repoPath: string): Promise<boolean>;
+/**
+ * Get remote URL
+ */
+declare function getRemoteUrl(repoPath: string, remote?: string): Promise<string>;
+/**
+ * Get worktrees directory (~/.agor/worktrees)
+ */
+declare function getWorktreesDir(): string;
+/**
+ * Get path for a specific worktree
+ */
+declare function getWorktreePath(repoSlug: string, worktreeName: string): string;
+interface WorktreeInfo {
+    name: string;
+    path: string;
+    ref: string;
+    sha: string;
+    detached: boolean;
+}
+/**
+ * Create a git worktree
+ *
+ * @param repoPath - Path to repository
+ * @param worktreePath - Path where worktree should be created
+ * @param ref - Branch/tag/commit to checkout
+ * @param createBranch - Whether to create a new branch
+ * @param pullLatest - Whether to fetch from remote before creating worktree (defaults to true)
+ * @param sourceBranch - Source branch to base new branch on (used with createBranch)
+ */
+declare function createWorktree(repoPath: string, worktreePath: string, ref: string, createBranch?: boolean, pullLatest?: boolean, // Changed default to true - always fetch latest!
+sourceBranch?: string): Promise<void>;
+/**
+ * List all worktrees for a repository
+ */
+declare function listWorktrees(repoPath: string): Promise<WorktreeInfo[]>;
+/**
+ * Remove a git worktree
+ */
+declare function removeWorktree(repoPath: string, worktreeName: string): Promise<void>;
+/**
+ * Prune stale worktree metadata
+ */
+declare function pruneWorktrees(repoPath: string): Promise<void>;
+/**
+ * Check if a remote branch exists
+ */
+declare function hasRemoteBranch(repoPath: string, branchName: string, remote?: string): Promise<boolean>;
+/**
+ * Get list of remote branches
+ */
+declare function getRemoteBranches(repoPath: string, remote?: string): Promise<string[]>;
+/**
+ * Get git state for a repository (SHA + dirty status)
+ *
+ * Returns the current commit SHA with "-dirty" suffix if working directory has uncommitted changes.
+ * If not in a git repo or SHA cannot be determined, returns "unknown".
+ *
+ * Examples:
+ * - "abc123def456" (clean working directory)
+ * - "abc123def456-dirty" (uncommitted changes)
+ * - "unknown" (not a git repo or error)
+ */
+declare function getGitState(repoPath: string): Promise<string>;
+
+export { type CloneOptions, type CloneProgress, type CloneResult, type WorktreeInfo, cloneRepo, createWorktree, extractRepoName, getCurrentBranch, getCurrentSha, getDefaultBranch, getGitState, getRemoteBranches, getRemoteUrl, getReposDir, getWorktreePath, getWorktreesDir, hasRemoteBranch, isClean, isGitRepo, listWorktrees, pruneWorktrees, removeWorktree };