agor-live 0.3.7

package/dist/core/dist/config/index.js

@@ -0,0 +1,451 @@
+// src/config/config-manager.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import yaml from "js-yaml";
+function getAgorHome() {
+  return path.join(os.homedir(), ".agor");
+}
+function getConfigPath() {
+  return path.join(getAgorHome(), "config.yaml");
+}
+async function ensureAgorHome() {
+  const agorHome = getAgorHome();
+  try {
+    await fs.access(agorHome);
+  } catch {
+    await fs.mkdir(agorHome, { recursive: true });
+  }
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config = yaml.load(content);
+    return config || {};
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return getDefaultConfig();
+    }
+    throw new Error(
+      `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function saveConfig(config) {
+  await ensureAgorHome();
+  const configPath = getConfigPath();
+  const content = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true
+  });
+  await fs.writeFile(configPath, content, "utf-8");
+}
+function getDefaultConfig() {
+  return {
+    context: {},
+    defaults: {
+      board: "main",
+      agent: "claude-code"
+    },
+    display: {
+      tableStyle: "unicode",
+      colorOutput: true,
+      shortIdLength: 8
+    },
+    daemon: {
+      port: 3030,
+      host: "localhost",
+      allowAnonymous: true,
+      // Default: Allow anonymous access (local mode)
+      requireAuth: false
+      // Default: Do not require authentication
+    },
+    ui: {
+      port: 5173,
+      host: "localhost"
+    }
+  };
+}
+async function getContext(key) {
+  const config = await loadConfig();
+  return config.context?.[key];
+}
+async function setContext(key, value) {
+  const config = await loadConfig();
+  if (!config.context) {
+    config.context = {};
+  }
+  config.context[key] = value;
+  await saveConfig(config);
+}
+async function unsetContext(key) {
+  const config = await loadConfig();
+  if (config.context && key in config.context) {
+    delete config.context[key];
+    await saveConfig(config);
+  }
+}
+async function clearContext() {
+  const config = await loadConfig();
+  config.context = {};
+  await saveConfig(config);
+}
+async function getAllContext() {
+  const config = await loadConfig();
+  return config.context || {};
+}
+async function initConfig() {
+  const configPath = getConfigPath();
+  try {
+    await fs.access(configPath);
+  } catch {
+    await saveConfig(getDefaultConfig());
+  }
+}
+async function getConfigValue(key) {
+  const config = await loadConfig();
+  const defaults = getDefaultConfig();
+  const merged = {
+    ...defaults,
+    ...config,
+    defaults: { ...defaults.defaults, ...config.defaults },
+    display: { ...defaults.display, ...config.display },
+    daemon: { ...defaults.daemon, ...config.daemon },
+    ui: { ...defaults.ui, ...config.ui }
+  };
+  const parts = key.split(".");
+  let value = merged;
+  for (const part of parts) {
+    if (value && typeof value === "object" && part in value) {
+      value = value[part];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
+async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    if (!config.context) {
+      config.context = {};
+    }
+    config.context[parts[0]] = value;
+  } else {
+    const section = parts[0];
+    const _subKey = parts.slice(1).join(".");
+    if (!config[section]) {
+      config[section] = {};
+    }
+    if (parts.length === 2) {
+      config[section][parts[1]] = value;
+    } else {
+      throw new Error(`Nested keys beyond one level not supported: ${key}`);
+    }
+  }
+  await saveConfig(config);
+}
+async function unsetConfigValue(key) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    if (config.context && parts[0] in config.context) {
+      delete config.context[parts[0]];
+    }
+  } else if (parts.length === 2) {
+    const section = parts[0];
+    const subKey = parts[1];
+    if (config[section] && subKey in config[section]) {
+      delete config[section][subKey];
+    }
+  }
+  await saveConfig(config);
+}
+async function getDaemonUrl() {
+  const config = await loadConfig();
+  const defaults = getDefaultConfig();
+  const envPort = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : void 0;
+  const port = envPort || config.daemon?.port || defaults.daemon?.port || 3030;
+  const host = config.daemon?.host || defaults.daemon?.host || "localhost";
+  return `http://${host}:${port}`;
+}
+
+// src/config/constants.ts
+var ENVIRONMENT = {
+  /**
+   * Health check interval in milliseconds
+   * How often to poll environment health when status is 'running'
+   */
+  HEALTH_CHECK_INTERVAL_MS: 5e3,
+  // 5 seconds
+  /**
+   * Health check timeout in milliseconds
+   * How long to wait for health check response before considering it failed
+   */
+  HEALTH_CHECK_TIMEOUT_MS: 1e3,
+  // 1 second
+  /**
+   * Maximum number of log lines to store per worktree
+   * (Not stored in DB - reference for future log file implementation)
+   */
+  MAX_LOG_LINES: 100,
+  /**
+   * Process startup grace period in milliseconds
+   * How long to wait after starting before running health checks
+   */
+  STARTUP_GRACE_PERIOD_MS: 3e3,
+  // 3 seconds
+  /**
+   * Maximum consecutive health check failures before marking as 'error'
+   */
+  MAX_HEALTH_CHECK_FAILURES: 3
+};
+var WEBSOCKET = {
+  /**
+   * Cursor position broadcast throttle in milliseconds
+   */
+  CURSOR_THROTTLE_MS: 100,
+  /**
+   * Presence timeout in milliseconds (when to mark user as stale)
+   */
+  PRESENCE_TIMEOUT_MS: 1e4
+  // 10 seconds
+};
+var DATABASE = {
+  /**
+   * Batch size for bulk message inserts
+   */
+  MESSAGE_BATCH_SIZE: 100,
+  /**
+   * Batch size for bulk task inserts
+   */
+  TASK_BATCH_SIZE: 100,
+  /**
+   * Default pagination limit
+   */
+  DEFAULT_PAGE_SIZE: 50,
+  /**
+   * Maximum pagination limit
+   */
+  MAX_PAGE_SIZE: 100
+};
+var GIT = {
+  /**
+   * Default worktree base path (relative to ~/.agor)
+   */
+  WORKTREE_BASE_PATH: "worktrees",
+  /**
+   * Default repo clone path (relative to ~/.agor)
+   */
+  REPO_BASE_PATH: "repos"
+};
+var SESSION = {
+  /**
+   * Maximum number of messages to load initially
+   */
+  INITIAL_MESSAGE_LOAD: 100,
+  /**
+   * Message streaming chunk size
+   */
+  STREAMING_CHUNK_SIZE: 1
+};
+
+// src/config/context-resolver.ts
+async function resolveValue(key, flagValue, config) {
+  if (flagValue !== void 0 && flagValue !== null && flagValue !== "") {
+    return flagValue;
+  }
+  const cfg = config || await loadConfig();
+  const contextValue = cfg.context?.[key];
+  if (contextValue !== void 0 && contextValue !== null && contextValue !== "") {
+    return contextValue;
+  }
+  const defaultValue = cfg.defaults?.[key];
+  if (defaultValue !== void 0 && defaultValue !== null && defaultValue !== "") {
+    return defaultValue;
+  }
+  return void 0;
+}
+async function resolveValues(keys, flagValues, config) {
+  const cfg = config || await loadConfig();
+  const resolved = {};
+  for (const key of keys) {
+    const value = await resolveValue(key, flagValues?.[key], cfg);
+    if (value !== void 0) {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+async function getEffectiveConfig(config) {
+  const cfg = config || await loadConfig();
+  return {
+    // Context values
+    board: await resolveValue("board", void 0, cfg),
+    session: await resolveValue("session", void 0, cfg),
+    repo: await resolveValue("repo", void 0, cfg),
+    agent: await resolveValue("agent", void 0, cfg),
+    // Display settings
+    tableStyle: cfg.display?.tableStyle,
+    colorOutput: cfg.display?.colorOutput !== void 0 ? String(cfg.display.colorOutput) : void 0,
+    shortIdLength: cfg.display?.shortIdLength !== void 0 ? String(cfg.display.shortIdLength) : void 0
+  };
+}
+
+// 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 {
+  DATABASE,
+  ENVIRONMENT,
+  GIT,
+  SESSION,
+  WEBSOCKET,
+  clearContext,
+  extractSlugFromUrl,
+  formatRepoReference,
+  getAgorHome,
+  getAllContext,
+  getConfigPath,
+  getConfigValue,
+  getContext,
+  getDaemonUrl,
+  getDefaultConfig,
+  getDefaultRepoReference,
+  getEffectiveConfig,
+  getGroupedRepoReferenceOptions,
+  getRepoReferenceOptions,
+  initConfig,
+  isValidSlug,
+  loadConfig,
+  parseRepoReference,
+  resolveRepoReference,
+  resolveValue,
+  resolveValues,
+  saveConfig,
+  setConfigValue,
+  setContext,
+  unsetConfigValue,
+  unsetContext
+};