avorelo 0.1.0

package/scripts/lib/workspace-resolver.js

@@ -0,0 +1,480 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const USER_CONFIG_SCHEMA_VERSION = 1;
+const USER_CONFIG_DIRNAME = ".avorelo";
+const USER_CONFIG_FILENAME = "config.json";
+
+function isWindowsAbsolutePath(input) {
+  return typeof input === "string" && /^[A-Za-z]:[\\/]/.test(input.trim());
+}
+
+function normalizePathValue(input) {
+  if (typeof input !== "string") return null;
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (isWindowsAbsolutePath(trimmed)) {
+    return path.win32.normalize(trimmed);
+  }
+  return path.resolve(trimmed);
+}
+
+function comparablePath(input) {
+  const normalized = normalizePathValue(input);
+  if (!normalized) return null;
+  const withoutTrailing = normalized.replace(/[\\/]+$/, "");
+  return process.platform === "win32" ? withoutTrailing.toLowerCase() : withoutTrailing;
+}
+
+function defaultUserHome(env = process.env) {
+  return env.USERPROFILE || env.HOME || os.homedir();
+}
+
+function getUserConfigPath(env = process.env) {
+  return path.join(defaultUserHome(env), USER_CONFIG_DIRNAME, USER_CONFIG_FILENAME);
+}
+
+function fileExists(absPath) {
+  try {
+    return fs.existsSync(absPath);
+  } catch {
+    return false;
+  }
+}
+
+function directoryExists(absPath) {
+  try {
+    return fs.statSync(absPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function readJson(absPath, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    return fallback;
+  }
+}
+
+function safePackageJson(dirPath) {
+  const pkgPath = path.join(dirPath, "package.json");
+  if (!fileExists(pkgPath)) return null;
+  return readJson(pkgPath, null);
+}
+
+function getWorkspaceSignals(dirPath) {
+  const packageJson = safePackageJson(dirPath);
+  const hasPackageJson = Boolean(packageJson);
+  const hasGit = fileExists(path.join(dirPath, ".git"));
+  const hasCco = directoryExists(path.join(dirPath, ".claude", "cco"));
+  const hasClaudeSettings = fileExists(path.join(dirPath, ".claude", "settings.json"))
+    || fileExists(path.join(dirPath, ".claude", "settings.local.json"));
+  const hasRepoBinary = fileExists(path.join(dirPath, "bin", "avorelo"));
+  const hasOrchestrationLib = directoryExists(path.join(dirPath, "scripts", "lib", "orchestration"));
+  const looksLikeAvoreloRepo = hasRepoBinary && hasOrchestrationLib && hasPackageJson;
+  const looksLikeActivatedWorkspace = hasCco && (hasPackageJson || hasGit || hasClaudeSettings || hasRepoBinary || hasOrchestrationLib);
+
+  return {
+    path: dirPath,
+    packageName: packageJson?.name || null,
+    hasPackageJson,
+    hasGit,
+    hasCco,
+    hasClaudeSettings,
+    hasRepoBinary,
+    hasOrchestrationLib,
+    looksLikeAvoreloRepo,
+    looksLikeActivatedWorkspace,
+    isWorkspace: looksLikeAvoreloRepo || looksLikeActivatedWorkspace,
+  };
+}
+
+function findWorkspaceRoot(startDir) {
+  const initial = normalizePathValue(startDir);
+  if (!initial) return null;
+
+  let cursor = initial;
+  while (true) {
+    const signals = getWorkspaceSignals(cursor);
+    if (signals.isWorkspace) {
+      return {
+        workspace: cursor,
+        signals,
+      };
+    }
+    const parent = path.dirname(cursor);
+    if (parent === cursor) return null;
+    cursor = parent;
+  }
+}
+
+function normalizeUserConfig(raw) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const knownWorkspaces = Array.isArray(source.knownWorkspaces) ? source.knownWorkspaces : [];
+  const deduped = [];
+  const seen = new Set();
+  for (const item of knownWorkspaces) {
+    const normalized = normalizePathValue(item);
+    if (!normalized) continue;
+    const key = comparablePath(normalized);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(normalized);
+  }
+
+  return {
+    schemaVersion: USER_CONFIG_SCHEMA_VERSION,
+    lastWorkspace: normalizePathValue(source.lastWorkspace),
+    knownWorkspaces: deduped,
+    updatedAt: typeof source.updatedAt === "string" && source.updatedAt.trim() ? source.updatedAt : null,
+  };
+}
+
+function readUserConfig(options = {}) {
+  const env = options.env || process.env;
+  const configPath = options.configPath || getUserConfigPath(env);
+  try {
+    if (!fileExists(configPath)) {
+      return {
+        configPath,
+        config: normalizeUserConfig({}),
+        exists: false,
+        corrupted: false,
+        error: null,
+      };
+    }
+
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf8").replace(/^\uFEFF/, ""));
+    return {
+      configPath,
+      config: normalizeUserConfig(raw),
+      exists: true,
+      corrupted: false,
+      error: null,
+    };
+  } catch (error) {
+    return {
+      configPath,
+      config: normalizeUserConfig({}),
+      exists: true,
+      corrupted: true,
+      error: error.message,
+    };
+  }
+}
+
+function writeUserConfig(nextConfig, options = {}) {
+  const env = options.env || process.env;
+  const configPath = options.configPath || getUserConfigPath(env);
+  const normalized = normalizeUserConfig(nextConfig);
+  normalized.updatedAt = options.updatedAt || new Date().toISOString();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(normalized, null, 2), "utf8");
+  return {
+    configPath,
+    config: normalized,
+  };
+}
+
+function validateWorkspacePath(candidatePath) {
+  if (process.platform !== "win32" && isWindowsAbsolutePath(candidatePath)) {
+    return {
+      ok: false,
+      workspace: null,
+      message: `Not an Avorelo workspace: ${candidatePath}`,
+    };
+  }
+  const resolved = findWorkspaceRoot(candidatePath);
+  if (!resolved) {
+    return {
+      ok: false,
+      workspace: null,
+      message: `Not an Avorelo workspace: ${candidatePath}`,
+    };
+  }
+  return {
+    ok: true,
+    workspace: resolved.workspace,
+    signals: resolved.signals,
+  };
+}
+
+function registerWorkspace(workspacePath, options = {}) {
+  const validation = validateWorkspacePath(workspacePath);
+  if (!validation.ok) {
+    return {
+      ok: false,
+      message: validation.message,
+    };
+  }
+
+  const current = readUserConfig(options);
+  const config = current.config;
+  const existing = config.knownWorkspaces.slice();
+  existing.push(validation.workspace);
+  const next = normalizeUserConfig({
+    ...config,
+    lastWorkspace: validation.workspace,
+    knownWorkspaces: existing,
+  });
+  const written = writeUserConfig(next, options);
+  return {
+    ok: true,
+    workspace: validation.workspace,
+    configPath: written.configPath,
+    config: written.config,
+  };
+}
+
+function clearLastWorkspace(options = {}) {
+  const current = readUserConfig(options);
+  const next = normalizeUserConfig({
+    ...current.config,
+    lastWorkspace: null,
+  });
+  const written = writeUserConfig(next, options);
+  return {
+    ok: true,
+    configPath: written.configPath,
+    config: written.config,
+  };
+}
+
+function listValidKnownWorkspaces(config) {
+  return (config.knownWorkspaces || [])
+    .map((workspace) => {
+      const validation = validateWorkspacePath(workspace);
+      return {
+        workspace,
+        valid: validation.ok,
+        normalizedWorkspace: validation.ok ? validation.workspace : normalizePathValue(workspace),
+      };
+    });
+}
+
+function resolveWorkspace(options = {}) {
+  const cwd = normalizePathValue(options.cwd || process.cwd());
+  const env = options.env || process.env;
+  const currentMatch = cwd ? findWorkspaceRoot(cwd) : null;
+  const envOverrideRaw = normalizePathValue(env.AVORELO_WORKSPACE);
+  const envOverride = envOverrideRaw ? validateWorkspacePath(envOverrideRaw) : null;
+  const userConfig = readUserConfig(options);
+  const knownEntries = listValidKnownWorkspaces(userConfig.config);
+  const validKnown = knownEntries.filter((entry) => entry.valid);
+  const lastWorkspaceCandidate = userConfig.config.lastWorkspace
+    ? validateWorkspacePath(userConfig.config.lastWorkspace)
+    : null;
+
+  if (currentMatch) {
+    return {
+      ok: true,
+      workspace: currentMatch.workspace,
+      source: "current_workspace",
+      cwd,
+      currentWorkspace: currentMatch.workspace,
+      envOverride: envOverrideRaw,
+      lastWorkspace: userConfig.config.lastWorkspace,
+      knownWorkspaces: userConfig.config.knownWorkspaces,
+      knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+      configPath: userConfig.configPath,
+      configCorrupted: userConfig.corrupted,
+      configError: userConfig.error,
+      message: null,
+    };
+  }
+
+  if (envOverrideRaw) {
+    if (envOverride?.ok) {
+      return {
+        ok: true,
+        workspace: envOverride.workspace,
+        source: "env_override",
+        cwd,
+        currentWorkspace: null,
+        envOverride: envOverrideRaw,
+        lastWorkspace: userConfig.config.lastWorkspace,
+        knownWorkspaces: userConfig.config.knownWorkspaces,
+        knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+        configPath: userConfig.configPath,
+        configCorrupted: userConfig.corrupted,
+        configError: userConfig.error,
+        message: null,
+      };
+    }
+
+    return {
+      ok: false,
+      workspace: null,
+      source: "env_override_invalid",
+      cwd,
+      currentWorkspace: null,
+      envOverride: envOverrideRaw,
+      lastWorkspace: userConfig.config.lastWorkspace,
+      knownWorkspaces: userConfig.config.knownWorkspaces,
+      knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+      configPath: userConfig.configPath,
+      configCorrupted: userConfig.corrupted,
+      configError: userConfig.error,
+      message: `AVORELO_WORKSPACE is set but does not point to a valid Avorelo workspace: ${envOverrideRaw}`,
+    };
+  }
+
+  if (lastWorkspaceCandidate?.ok) {
+    return {
+      ok: true,
+      workspace: lastWorkspaceCandidate.workspace,
+      source: "last_workspace",
+      cwd,
+      currentWorkspace: null,
+      envOverride: null,
+      lastWorkspace: userConfig.config.lastWorkspace,
+      knownWorkspaces: userConfig.config.knownWorkspaces,
+      knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+      configPath: userConfig.configPath,
+      configCorrupted: userConfig.corrupted,
+      configError: userConfig.error,
+      message: null,
+    };
+  }
+
+  if (validKnown.length === 1) {
+    return {
+      ok: true,
+      workspace: validKnown[0].normalizedWorkspace,
+      source: "known_workspace",
+      cwd,
+      currentWorkspace: null,
+      envOverride: null,
+      lastWorkspace: userConfig.config.lastWorkspace,
+      knownWorkspaces: userConfig.config.knownWorkspaces,
+      knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+      configPath: userConfig.configPath,
+      configCorrupted: userConfig.corrupted,
+      configError: userConfig.error,
+      message: null,
+    };
+  }
+
+  const lastWorkspaceInvalid = Boolean(userConfig.config.lastWorkspace) && !lastWorkspaceCandidate?.ok;
+  const multipleKnown = validKnown.length > 1;
+  let message = `No Avorelo workspace found. Run "${options.cliName || "avorelo"} activate" inside your repo or set AVORELO_WORKSPACE.`;
+  if (lastWorkspaceInvalid) {
+    message = `The saved lastWorkspace is no longer valid. Run "${options.cliName || "avorelo"} activate" inside your repo, use "${options.cliName || "avorelo"} workspace set <path>", or set AVORELO_WORKSPACE.`;
+  } else if (multipleKnown) {
+    message = `Multiple Avorelo workspaces are known. Use "${options.cliName || "avorelo"} workspace set <path>" or set AVORELO_WORKSPACE.`;
+  }
+
+  return {
+    ok: false,
+    workspace: null,
+    source: multipleKnown ? "multiple_known_workspaces" : (lastWorkspaceInvalid ? "last_workspace_invalid" : "missing"),
+    cwd,
+    currentWorkspace: null,
+    envOverride: null,
+    lastWorkspace: userConfig.config.lastWorkspace,
+    knownWorkspaces: userConfig.config.knownWorkspaces,
+    knownValidWorkspaces: validKnown.map((entry) => entry.normalizedWorkspace),
+    configPath: userConfig.configPath,
+    configCorrupted: userConfig.corrupted,
+    configError: userConfig.error,
+    message,
+  };
+}
+
+function workspaceDoctor(options = {}) {
+  const resolution = resolveWorkspace(options);
+  const userConfig = readUserConfig(options);
+  const packageJson = readJson(path.join(options.repoRoot || process.cwd(), "package.json"), {});
+  const binMapping = packageJson?.bin?.avorelo || null;
+  const checks = [
+    {
+      id: "user_config",
+      label: "User config readable",
+      status: userConfig.corrupted ? "PARTIAL" : "GOOD",
+      details: userConfig.corrupted ? userConfig.error : userConfig.configPath,
+    },
+    {
+      id: "workspace_resolution",
+      label: "Workspace resolution",
+      status: resolution.ok ? "GOOD" : "BLOCKED",
+      details: resolution.ok ? `${resolution.workspace} (${resolution.source})` : resolution.message,
+    },
+    {
+      id: "package_bin",
+      label: "Package bin mapping",
+      status: binMapping === "bin/avorelo" ? "GOOD" : "PARTIAL",
+      details: binMapping === "bin/avorelo" ? "avorelo -> bin/avorelo" : `Unexpected bin mapping: ${binMapping || "missing"}`,
+    },
+    {
+      id: "bin_launcher",
+      label: "Repo launcher file",
+      status: fileExists(path.join(options.repoRoot || process.cwd(), "bin", "avorelo")) ? "GOOD" : "BLOCKED",
+      details: fileExists(path.join(options.repoRoot || process.cwd(), "bin", "avorelo"))
+        ? path.join(options.repoRoot || process.cwd(), "bin", "avorelo")
+        : "bin/avorelo missing",
+    },
+  ];
+
+  const overall = checks.some((check) => check.status === "BLOCKED")
+    ? "BLOCKED"
+    : checks.some((check) => check.status === "PARTIAL")
+      ? "PARTIAL"
+      : "GOOD";
+
+  return {
+    status: overall,
+    cwd: normalizePathValue(options.cwd || process.cwd()),
+    resolution,
+    configPath: userConfig.configPath,
+    checks,
+    knownWorkspaces: userConfig.config.knownWorkspaces,
+    lastWorkspace: userConfig.config.lastWorkspace,
+  };
+}
+
+function formatWorkspaceShowText(result) {
+  return [
+    "Avorelo Workspace",
+    `Current cwd: ${result.cwd || "unknown"}`,
+    `Resolved workspace: ${result.workspace || "not found"}`,
+    `Resolution source: ${result.source || "unknown"}`,
+    `AVORELO_WORKSPACE: ${result.envOverride || "not set"}`,
+    `lastWorkspace: ${result.lastWorkspace || "not set"}`,
+    `Known workspaces: ${Array.isArray(result.knownWorkspaces) ? result.knownWorkspaces.length : 0}`,
+    `User config: ${result.configPath}`,
+    result.message ? `Note: ${result.message}` : null,
+  ].filter(Boolean).join("\n");
+}
+
+function formatWorkspaceDoctorText(result) {
+  return [
+    "Avorelo Workspace Doctor",
+    `Status: ${result.status}`,
+    `Current cwd: ${result.cwd || "unknown"}`,
+    `Config: ${result.configPath}`,
+    ...result.checks.map((check) => `${check.status} ${check.label}: ${check.details}`),
+    result.resolution?.message ? `Next: ${result.resolution.message}` : null,
+  ].filter(Boolean).join("\n");
+}
+
+module.exports = {
+  USER_CONFIG_SCHEMA_VERSION,
+  getUserConfigPath,
+  getWorkspaceSignals,
+  findWorkspaceRoot,
+  normalizeUserConfig,
+  readUserConfig,
+  writeUserConfig,
+  validateWorkspacePath,
+  registerWorkspace,
+  clearLastWorkspace,
+  resolveWorkspace,
+  workspaceDoctor,
+  formatWorkspaceShowText,
+  formatWorkspaceDoctorText,
+};