agor-live 0.3.7

package/dist/core/dist/config/browser.d.ts

@@ -0,0 +1,289 @@
+import { R as RepoSlug, W as WorktreeName, a as Repo, c as Worktree } from '../repo-CnvJ0B6-.js';
+import { U as UUID } from '../id-DMqyogFB.js';
+
+/**
+ * Agor Configuration Types
+ */
+/**
+ * Type for user-provided JSON data where structure is unknown or dynamic
+ *
+ * Use this instead of `any` when dealing with user input or dynamic data structures.
+ */
+type UnknownJson = any;
+/**
+ * Active CLI context (stateful)
+ *
+ * Values that change frequently during CLI usage.
+ */
+interface AgorContext {
+    /** Active board (slug, ID, or name) */
+    board?: string;
+    /** Active session (full UUID or short ID) */
+    session?: string;
+    /** Active repo reference (path | slug | slug:worktree) */
+    repo?: string;
+    /** Preferred agent for new sessions */
+    agent?: string;
+}
+/**
+ * Global default values
+ */
+interface AgorDefaults {
+    /** Default board for new sessions */
+    board?: string;
+    /** Default agent for new sessions */
+    agent?: string;
+}
+/**
+ * Display settings
+ */
+interface AgorDisplaySettings {
+    /** Table style: unicode, ascii, or minimal */
+    tableStyle?: 'unicode' | 'ascii' | 'minimal';
+    /** Enable color output */
+    colorOutput?: boolean;
+    /** Short ID length (default: 8) */
+    shortIdLength?: number;
+}
+/**
+ * Daemon settings
+ */
+interface AgorDaemonSettings {
+    /** Daemon port (default: 3030) */
+    port?: number;
+    /** Daemon host (default: localhost) */
+    host?: string;
+    /** Allow anonymous access (default: true for local mode) */
+    allowAnonymous?: boolean;
+    /** Require authentication for all requests (default: false) */
+    requireAuth?: boolean;
+    /** JWT secret (auto-generated if not provided) */
+    jwtSecret?: string;
+}
+/**
+ * UI settings
+ */
+interface AgorUISettings {
+    /** UI dev server port (default: 5173) */
+    port?: number;
+    /** UI host (default: localhost) */
+    host?: string;
+}
+/**
+ * Tool credentials (API keys, tokens, etc.)
+ */
+interface AgorCredentials {
+    /** Anthropic API key for Claude Code */
+    ANTHROPIC_API_KEY?: string;
+    /** Cursor API key (if needed) */
+    CURSOR_API_KEY?: string;
+    /** OpenAI API key for Codex */
+    OPENAI_API_KEY?: string;
+    /** Google Gemini API key */
+    GEMINI_API_KEY?: string;
+}
+/**
+ * Complete Agor configuration
+ */
+interface AgorConfig {
+    /** Active context (stateful CLI) */
+    context?: AgorContext;
+    /** Global defaults */
+    defaults?: AgorDefaults;
+    /** Display settings */
+    display?: AgorDisplaySettings;
+    /** Daemon settings */
+    daemon?: AgorDaemonSettings;
+    /** UI settings */
+    ui?: AgorUISettings;
+    /** Tool credentials (API keys, tokens) */
+    credentials?: AgorCredentials;
+}
+/**
+ * Valid context keys that can be set/get
+ */
+type ContextKey = keyof AgorContext;
+/**
+ * Valid config keys (includes nested keys with dot notation)
+ */
+type ConfigKey = ContextKey | `defaults.${keyof AgorDefaults}` | `display.${keyof AgorDisplaySettings}` | `daemon.${keyof AgorDaemonSettings}` | `ui.${keyof AgorUISettings}` | `credentials.${keyof AgorCredentials}`;
+
+/**
+ * Repo List Utilities
+ *
+ * Generate flattened lists of repo references for UI selection
+ */
+
+/**
+ * Repo reference option for UI selection
+ */
+interface RepoReferenceOption {
+    /** Display label (e.g., "anthropics/agor:main" or "/Users/max/code/agor") */
+    label: string;
+    /** ID value for selection (repo_id or worktree_id) */
+    value: string;
+    /** Reference type */
+    type: 'path' | 'managed' | 'managed-worktree';
+    /** Repository slug (for managed repos) */
+    slug?: RepoSlug;
+    /** Worktree name (for managed worktrees) */
+    worktree?: WorktreeName;
+    /** Display description */
+    description?: string;
+}
+/**
+ * Generate a list of all repo reference options
+ *
+ * Creates options for:
+ * - Each managed repo (bare repo)
+ * - Each worktree of each managed repo
+ * - User paths can be added manually
+ *
+ * @param repos - List of Agor-managed repositories
+ * @param worktrees - List of worktrees (optional, now fetched from worktrees table)
+ * @returns Flattened list of selectable repo references
+ *
+ * @example
+ * const options = getRepoReferenceOptions(repos, worktrees);
+ * // [
+ * //   { label: "anthropics/agor", value: "anthropics/agor", type: "managed", ... },
+ * //   { label: "anthropics/agor:main", value: "anthropics/agor:main", type: "managed-worktree", ... },
+ * //   { label: "anthropics/agor:feat-auth", value: "anthropics/agor:feat-auth", type: "managed-worktree", ... },
+ * //   { label: "apache/superset", value: "apache/superset", type: "managed", ... },
+ * //   { label: "apache/superset:main", value: "apache/superset:main", type: "managed-worktree", ... },
+ * // ]
+ */
+declare function getRepoReferenceOptions(repos: Repo[], worktrees?: Worktree[]): RepoReferenceOption[];
+/**
+ * Group repo reference options by repository
+ *
+ * Useful for hierarchical dropdowns/menus
+ *
+ * @param repos - List of Agor-managed repositories
+ * @param worktrees - List of worktrees (optional, now fetched from worktrees table)
+ * @returns Map of repo slug to options
+ *
+ * @example
+ * const grouped = getGroupedRepoReferenceOptions(repos, worktrees);
+ * // {
+ * //   "anthropics/agor": [
+ * //     { label: "anthropics/agor", ... },
+ * //     { label: "anthropics/agor:main", ... },
+ * //     { label: "anthropics/agor:feat-auth", ... },
+ * //   ],
+ * //   "apache/superset": [...]
+ * // }
+ */
+declare function getGroupedRepoReferenceOptions(repos: Repo[], worktrees?: Worktree[]): Record<RepoSlug, RepoReferenceOption[]>;
+/**
+ * Get default repo reference (first worktree of first repo, or first repo)
+ *
+ * @param repos - List of Agor-managed repositories
+ * @returns Default reference or undefined if no repos
+ */
+declare function getDefaultRepoReference(repos: Repo[]): string | undefined;
+
+/**
+ * Repo Reference Parser
+ *
+ * Handles parsing and resolution of repo references in three formats:
+ * 1. Absolute path: /Users/max/code/agor
+ * 2. Agor-managed slug: anthropics/agor
+ * 3. Slug + worktree: anthropics/agor:feat-auth
+ */
+
+/**
+ * Parsed repo reference
+ */
+interface RepoReference {
+    /** Reference type */
+    type: 'path' | 'managed' | 'managed-worktree';
+    /** Absolute path (for type='path') */
+    path?: string;
+    /** Repository slug (for type='managed' or 'managed-worktree') */
+    slug?: RepoSlug;
+    /** Worktree name (for type='managed-worktree') */
+    worktree?: WorktreeName;
+}
+/**
+ * Parse a repo reference string
+ *
+ * @param ref - Repo reference (path | slug | slug:worktree)
+ * @returns Parsed reference
+ *
+ * @example
+ * parseRepoReference('/Users/max/code/agor')
+ * // => { type: 'path', path: '/Users/max/code/agor' }
+ *
+ * @example
+ * parseRepoReference('anthropics/agor')
+ * // => { type: 'managed', slug: 'anthropics/agor' }
+ *
+ * @example
+ * parseRepoReference('anthropics/agor:main')
+ * // => { type: 'managed-worktree', slug: 'anthropics/agor', worktree: 'main' }
+ */
+declare function parseRepoReference(ref: string): RepoReference;
+/**
+ * Extract slug from git URL
+ *
+ * @param url - Git remote URL
+ * @returns Repository slug (org/name)
+ *
+ * @example
+ * extractSlugFromUrl('https://github.com/anthropics/agor.git')
+ * // => 'anthropics/agor'
+ *
+ * @example
+ * extractSlugFromUrl('git@github.com:apache/superset.git')
+ * // => 'apache/superset'
+ */
+declare function extractSlugFromUrl(url: string): RepoSlug;
+/**
+ * Validate slug format (org/name)
+ *
+ * @param slug - Repository slug to validate
+ * @returns True if valid
+ */
+declare function isValidSlug(slug: string): boolean;
+/**
+ * Resolve repo reference to SessionRepoContext
+ *
+ * Note: This function requires database access and should be called from
+ * CLI commands or services that have access to the database instance.
+ * The actual implementation is in the CLI/daemon layer.
+ *
+ * @param ref - Repo reference string
+ * @returns Promise resolving to SessionRepoContext
+ *
+ * @throws Error if repo not found or path doesn't exist
+ *
+ * @example
+ * // In CLI command with database access:
+ * const context = await resolveRepoReference('anthropics/agor:main', db);
+ */
+declare function resolveRepoReference(ref: string): Promise<{
+    repo_id?: UUID;
+    repo_slug?: RepoSlug;
+    worktree_name?: WorktreeName;
+    cwd: string;
+    managed_worktree: boolean;
+}>;
+/**
+ * Format repo reference for display
+ *
+ * @param slug - Repository slug
+ * @param worktreeName - Optional worktree name
+ * @returns Formatted reference string
+ *
+ * @example
+ * formatRepoReference('anthropics/agor', 'main')
+ * // => 'anthropics/agor:main'
+ *
+ * @example
+ * formatRepoReference('anthropics/agor')
+ * // => 'anthropics/agor'
+ */
+declare function formatRepoReference(slug: RepoSlug, worktreeName?: WorktreeName): string;
+
+export { type AgorConfig, type AgorContext, type AgorCredentials, type AgorDaemonSettings, type AgorDefaults, type AgorDisplaySettings, type AgorUISettings, type ConfigKey, type ContextKey, type RepoReference, type RepoReferenceOption, type UnknownJson, extractSlugFromUrl, formatRepoReference, getDefaultRepoReference, getGroupedRepoReferenceOptions, getRepoReferenceOptions, isValidSlug, parseRepoReference, resolveRepoReference };

package/dist/core/dist/config/browser.js

@@ -0,0 +1,131 @@
+// src/config/repo-list.ts
+function getRepoReferenceOptions(repos, worktrees = []) {
+  const options = [];
+  const repoMap = new Map(repos.map((repo) => [repo.repo_id, repo]));
+  for (const repo of repos) {
+    options.push({
+      label: repo.slug,
+      value: repo.repo_id,
+      // Use repo_id as value
+      type: "managed",
+      slug: repo.slug,
+      description: `${repo.name} (bare repo)`
+    });
+  }
+  for (const worktree of worktrees) {
+    const repo = repoMap.get(worktree.repo_id);
+    if (!repo) continue;
+    const reference = `${repo.slug}:${worktree.name}`;
+    options.push({
+      label: reference,
+      value: worktree.worktree_id,
+      // Use worktree_id as value
+      type: "managed-worktree",
+      slug: repo.slug,
+      worktree: worktree.name,
+      description: `${repo.name} - ${worktree.name} (${worktree.ref})`
+    });
+  }
+  return options;
+}
+function getGroupedRepoReferenceOptions(repos, worktrees = []) {
+  const grouped = {};
+  const repoMap = new Map(repos.map((repo) => [repo.repo_id, repo]));
+  for (const repo of repos) {
+    const options = [];
+    options.push({
+      label: repo.slug,
+      value: repo.repo_id,
+      // Use repo_id as value
+      type: "managed",
+      slug: repo.slug,
+      description: `${repo.name} (bare repo)`
+    });
+    grouped[repo.slug] = options;
+  }
+  for (const worktree of worktrees) {
+    const repo = repoMap.get(worktree.repo_id);
+    if (!repo) continue;
+    const reference = `${repo.slug}:${worktree.name}`;
+    if (!grouped[repo.slug]) {
+      grouped[repo.slug] = [];
+    }
+    grouped[repo.slug].push({
+      label: reference,
+      value: worktree.worktree_id,
+      // Use worktree_id as value
+      type: "managed-worktree",
+      slug: repo.slug,
+      worktree: worktree.name,
+      description: `${repo.name} - ${worktree.name} (${worktree.ref})`
+    });
+  }
+  return grouped;
+}
+function getDefaultRepoReference(repos) {
+  if (repos.length === 0) return void 0;
+  const firstRepo = repos[0];
+  return firstRepo.slug;
+}
+
+// src/config/repo-reference.ts
+function parseRepoReference(ref) {
+  if (ref.startsWith("/") || /^[A-Z]:\\/.test(ref)) {
+    return { type: "path", path: ref };
+  }
+  if (ref.includes(":")) {
+    const [slug, worktree] = ref.split(":", 2);
+    return { type: "managed-worktree", slug, worktree };
+  }
+  return { type: "managed", slug: ref };
+}
+function extractSlugFromUrl(url) {
+  const cleanUrl = url.endsWith(".git") ? url.slice(0, -4) : url;
+  if (cleanUrl.includes("@")) {
+    const match2 = cleanUrl.match(/:([^/]+\/[^/]+)$/);
+    if (match2) {
+      return match2[1];
+    }
+  }
+  const match = cleanUrl.match(/[:/]([^/]+\/[^/]+)$/);
+  if (match) {
+    return match[1];
+  }
+  const segments = cleanUrl.split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    return `${segments[segments.length - 2]}/${segments[segments.length - 1]}`;
+  }
+  throw new Error(`Could not extract slug from URL: ${url}`);
+}
+function isValidSlug(slug) {
+  const slugPattern = /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/;
+  return slugPattern.test(slug);
+}
+async function resolveRepoReference(ref) {
+  const parsed = parseRepoReference(ref);
+  if (parsed.type === "path") {
+    return {
+      cwd: parsed.path,
+      managed_worktree: false
+    };
+  }
+  throw new Error(
+    `Repository lookup not implemented in this context. Parsed reference: ${JSON.stringify(parsed)}`
+  );
+}
+function formatRepoReference(slug, worktreeName) {
+  if (worktreeName) {
+    return `${slug}:${worktreeName}`;
+  }
+  return slug;
+}
+export {
+  extractSlugFromUrl,
+  formatRepoReference,
+  getDefaultRepoReference,
+  getGroupedRepoReferenceOptions,
+  getRepoReferenceOptions,
+  isValidSlug,
+  parseRepoReference,
+  resolveRepoReference
+};