repowisestage 0.0.1-staging.0

package/dist/bin/repowise.js

@@ -0,0 +1,4070 @@
+#!/usr/bin/env node
+
+// bin/repowise.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname7, join as join21 } from "path";
+import { Command } from "commander";
+
+// ../listener/dist/main.js
+import { writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { join as join10 } from "path";
+import lockfile2 from "proper-lockfile";
+
+// ../../packages/shared/src/config-dir.ts
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  const isStaging = true ? false : false;
+  return join(homedir(), isStaging ? ".repowise-staging" : ".repowise");
+}
+
+// ../../packages/shared/src/constants/tiers.ts
+var SUBSCRIPTION_TIERS = {
+  STARTER: "starter",
+  PRO: "pro",
+  TEAM: "team"
+};
+var TIER_LIMITS = {
+  [SUBSCRIPTION_TIERS.STARTER]: {
+    maxRepos: 1,
+    maxSeats: 1,
+    maxSyncsPerMonth: 10,
+    maxConcurrentSyncs: 1,
+    bedrockEndpoint: "public"
+  },
+  [SUBSCRIPTION_TIERS.PRO]: {
+    maxRepos: 3,
+    maxSeats: 1,
+    maxSyncsPerMonth: 30,
+    maxConcurrentSyncs: 2,
+    bedrockEndpoint: "public"
+  },
+  [SUBSCRIPTION_TIERS.TEAM]: {
+    maxRepos: 5,
+    // per seat
+    maxSeats: 25,
+    maxSyncsPerMonth: 50,
+    maxConcurrentSyncs: 10,
+    bedrockEndpoint: "privatelink"
+  }
+};
+
+// ../../packages/shared/src/constants/roles.ts
+var ROLES = {
+  OWNER: "owner",
+  ADMIN: "admin",
+  REPO_MANAGER: "repo_manager",
+  MEMBER: "member"
+};
+var PERMISSIONS = {
+  [ROLES.OWNER]: {
+    connectRepos: true,
+    viewSync: true,
+    triggerRetry: true,
+    configWatcher: true,
+    inviteMembers: true,
+    manageBilling: true,
+    configAiTools: true,
+    manageTeam: true
+  },
+  [ROLES.ADMIN]: {
+    connectRepos: true,
+    viewSync: true,
+    triggerRetry: true,
+    configWatcher: true,
+    inviteMembers: true,
+    manageBilling: false,
+    configAiTools: true,
+    manageTeam: true
+  },
+  [ROLES.REPO_MANAGER]: {
+    connectRepos: true,
+    viewSync: true,
+    triggerRetry: true,
+    configWatcher: true,
+    inviteMembers: false,
+    manageBilling: false,
+    configAiTools: true,
+    manageTeam: false
+  },
+  [ROLES.MEMBER]: {
+    connectRepos: false,
+    viewSync: true,
+    triggerRetry: true,
+    configWatcher: false,
+    inviteMembers: false,
+    manageBilling: false,
+    configAiTools: true,
+    manageTeam: false
+  }
+};
+var ROLE_PRIORITY = [
+  ROLES.OWNER,
+  ROLES.ADMIN,
+  ROLES.REPO_MANAGER,
+  ROLES.MEMBER
+];
+
+// ../listener/dist/lib/config.js
+import { readFile, writeFile, rename, unlink, mkdir, chmod } from "fs/promises";
+import { join as join2 } from "path";
+import lockfile from "proper-lockfile";
+var DEFAULT_API_URL = false ? "https://staging-api.repowise.ai" : "https://api.repowise.ai";
+async function getListenerConfig() {
+  const configDir = getConfigDir();
+  const configPath = join2(configDir, "config.json");
+  const apiUrl = process.env["REPOWISE_API_URL"] ?? DEFAULT_API_URL;
+  try {
+    const data = await readFile(configPath, "utf-8");
+    const raw = JSON.parse(data);
+    const validRepos = (raw.repos ?? []).filter((r) => typeof r === "object" && r !== null && typeof r.repoId === "string" && typeof r.localPath === "string");
+    return {
+      defaultApiUrl: raw.apiUrl ?? apiUrl,
+      repos: validRepos,
+      autoDiscoverRepos: raw.autoDiscoverRepos ?? false,
+      noAutoUpdate: raw.noAutoUpdate ?? false
+    };
+  } catch {
+    return { defaultApiUrl: apiUrl, repos: [], autoDiscoverRepos: false, noAutoUpdate: false };
+  }
+}
+async function saveListenerConfig(config2) {
+  const configDir = getConfigDir();
+  const configPath = join2(configDir, "config.json");
+  await mkdir(configDir, { recursive: true, mode: 448 });
+  try {
+    await writeFile(configPath, "", { flag: "a" });
+  } catch {
+  }
+  let release = null;
+  try {
+    release = await lockfile.lock(configPath, { stale: 1e4, retries: 3, realpath: false });
+    let raw = {};
+    try {
+      const data = await readFile(configPath, "utf-8");
+      raw = JSON.parse(data);
+    } catch {
+    }
+    const output = {
+      ...raw,
+      apiUrl: config2.defaultApiUrl,
+      repos: config2.repos
+    };
+    const tmpPath = configPath + ".tmp";
+    try {
+      await writeFile(tmpPath, JSON.stringify(output, null, 2));
+      await chmod(tmpPath, 384);
+      await rename(tmpPath, configPath);
+    } catch (err) {
+      try {
+        await unlink(tmpPath);
+      } catch {
+      }
+      throw err;
+    }
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  }
+}
+
+// ../listener/dist/lib/state.js
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2, rename as rename2, unlink as unlink2 } from "fs/promises";
+import { join as join3 } from "path";
+function emptyState() {
+  return { repos: {} };
+}
+async function loadState() {
+  const statePath = join3(getConfigDir(), "listener-state.json");
+  try {
+    const data = await readFile2(statePath, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return emptyState();
+    }
+    throw err;
+  }
+}
+async function saveState(state) {
+  const configDir = getConfigDir();
+  const statePath = join3(configDir, "listener-state.json");
+  await mkdir2(configDir, { recursive: true, mode: 448 });
+  const tmpPath = statePath + ".tmp";
+  try {
+    await writeFile2(tmpPath, JSON.stringify(state, null, 2));
+    await chmod2(tmpPath, 384);
+    await rename2(tmpPath, statePath);
+  } catch (err) {
+    try {
+      await unlink2(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// ../listener/dist/lib/reconcile.js
+import { statSync, readdirSync } from "fs";
+import { basename, dirname, join as join4 } from "path";
+function reconcileRepos(configRepos, activeRepos, state, apiUrl, options) {
+  if (activeRepos.length === 0) {
+    return { updated: false, repos: configRepos, changes: [], addedRepos: [] };
+  }
+  const changes = [];
+  let updated = false;
+  const addedRepos = [];
+  const usedPaths = new Set(configRepos.map((r) => r.localPath));
+  const updatedRepos = configRepos.map((repo) => {
+    if (repo.apiUrl && repo.apiUrl !== apiUrl) {
+      return repo;
+    }
+    if (activeRepos.some((ar) => ar.repoId === repo.repoId)) {
+      if (!repo.platform || !repo.externalId) {
+        const match = activeRepos.find((ar) => ar.repoId === repo.repoId);
+        if (match) {
+          changes.push(`Backfilled platform+externalId for ${match.fullName} (${repo.repoId})`);
+          updated = true;
+          return {
+            ...repo,
+            platform: match.platform,
+            externalId: match.externalId
+          };
+        }
+      }
+      return repo;
+    }
+    if (repo.platform && repo.externalId) {
+      const match = activeRepos.find((ar) => ar.platform === repo.platform && ar.externalId === repo.externalId);
+      if (match) {
+        const oldId = repo.repoId;
+        changes.push(`Updated repoId for ${match.fullName}: ${oldId} \u2192 ${match.repoId}`);
+        migrateState(state, oldId, match.repoId);
+        updated = true;
+        return {
+          ...repo,
+          repoId: match.repoId,
+          platform: match.platform,
+          externalId: match.externalId
+        };
+      }
+    }
+    const dirName = basename(repo.localPath);
+    const parentDir = basename(dirname(repo.localPath));
+    const fullPathName = `${parentDir}/${dirName}`;
+    let matches = activeRepos.filter((ar) => ar.fullName === fullPathName);
+    if (matches.length === 0) {
+      matches = activeRepos.filter((ar) => ar.name === dirName);
+    }
+    if (matches.length === 1) {
+      const match = matches[0];
+      if (match.repoId !== repo.repoId) {
+        const oldId = repo.repoId;
+        changes.push(`Updated repoId for ${match.fullName} (name match): ${oldId} \u2192 ${match.repoId}`);
+        migrateState(state, oldId, match.repoId);
+        updated = true;
+        return {
+          ...repo,
+          repoId: match.repoId,
+          platform: match.platform,
+          externalId: match.externalId
+        };
+      }
+      if (!repo.platform || !repo.externalId) {
+        changes.push(`Backfilled platform+externalId for ${match.fullName} (name match)`);
+        updated = true;
+        return {
+          ...repo,
+          platform: match.platform,
+          externalId: match.externalId
+        };
+      }
+    } else if (matches.length > 1) {
+      console.warn(`Ambiguous name match for ${repo.localPath} \u2014 ${matches.length} repos match "${dirName}". Skipping auto-update. Add platform+externalId to config or re-run \`repowise create\`.`);
+    }
+    return repo;
+  });
+  if (options?.autoDiscover) {
+    const configuredRepoIds = new Set(updatedRepos.map((r) => r.repoId));
+    const unmatchedActiveRepos = activeRepos.filter((ar) => !configuredRepoIds.has(ar.repoId));
+    if (unmatchedActiveRepos.length > 0) {
+      const parentDirs = /* @__PURE__ */ new Set();
+      for (const repo of updatedRepos) {
+        parentDirs.add(dirname(repo.localPath));
+      }
+      for (const activeRepo of unmatchedActiveRepos) {
+        const found = findLocalRepo(activeRepo, parentDirs, usedPaths);
+        if (found) {
+          const newRepo = {
+            repoId: activeRepo.repoId,
+            localPath: found,
+            apiUrl,
+            platform: activeRepo.platform,
+            externalId: activeRepo.externalId
+          };
+          updatedRepos.push(newRepo);
+          addedRepos.push(newRepo);
+          usedPaths.add(found);
+          configuredRepoIds.add(activeRepo.repoId);
+          const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+          state.repos[activeRepo.repoId] = {
+            ...state.repos[activeRepo.repoId],
+            lastSyncTimestamp: twentyFourHoursAgo,
+            lastSyncCommitSha: null
+          };
+          changes.push(`[self-heal] Auto-added ${activeRepo.fullName} from ${found}`);
+          updated = true;
+        }
+      }
+    }
+  }
+  return { updated, repos: updatedRepos, changes, addedRepos };
+}
+function findLocalRepo(activeRepo, parentDirs, usedPaths) {
+  const nameParts = activeRepo.fullName.split("/");
+  const repoName = nameParts[nameParts.length - 1];
+  for (const parentDir of parentDirs) {
+    const candidate = join4(parentDir, repoName);
+    if (!usedPaths.has(candidate) && hasContextFolder(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function hasContextFolder(dirPath) {
+  try {
+    const contextPath = join4(dirPath, "repowise-context");
+    const s = statSync(contextPath);
+    if (!s.isDirectory())
+      return false;
+    const entries = readdirSync(contextPath);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+function migrateState(state, oldId, newId) {
+  const oldState = state.repos[oldId];
+  if (oldState) {
+    const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+    state.repos[newId] = {
+      ...state.repos[newId],
+      lastSyncTimestamp: twentyFourHoursAgo,
+      lastSyncCommitSha: null
+    };
+    delete state.repos[oldId];
+  } else {
+    state.repos[newId] = {
+      ...state.repos[newId],
+      lastSyncTimestamp: new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString(),
+      lastSyncCommitSha: null
+    };
+  }
+}
+
+// ../listener/dist/lib/auth.js
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod3 } from "fs/promises";
+import { join as join5 } from "path";
+function getTokenUrl(creds) {
+  const cognito = creds?.cognito;
+  const domain = process.env["REPOWISE_COGNITO_DOMAIN"] ?? cognito?.domain ?? "auth-repowise-dev";
+  const region = process.env["REPOWISE_COGNITO_REGION"] ?? cognito?.region ?? "us-east-1";
+  const customDomain = cognito?.customDomain ?? false;
+  return customDomain ? `https://${domain}/oauth2/token` : `https://${domain}.auth.${region}.amazoncognito.com/oauth2/token`;
+}
+function getClientId(creds) {
+  return process.env["REPOWISE_COGNITO_CLIENT_ID"] ?? creds?.cognito?.clientId ?? "";
+}
+async function refreshTokens(refreshToken, creds) {
+  const clientId = getClientId(creds);
+  if (!clientId) {
+    throw new Error("No Cognito client ID available. Run `repowise login` first.");
+  }
+  const response = await fetch(getTokenUrl(creds), {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: clientId,
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Token refresh failed: ${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken,
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3,
+    cognito: creds.cognito
+  };
+}
+async function getStoredCredentials() {
+  try {
+    const credPath = join5(getConfigDir(), "credentials.json");
+    const data = await readFile3(credPath, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function storeCredentials(credentials) {
+  const dir = getConfigDir();
+  const credPath = join5(dir, "credentials.json");
+  await mkdir3(dir, { recursive: true, mode: 448 });
+  await writeFile3(credPath, JSON.stringify(credentials, null, 2));
+  await chmod3(credPath, 384);
+}
+async function getValidCredentials(options) {
+  const creds = await getStoredCredentials();
+  if (!creds)
+    return null;
+  const now = Date.now();
+  const needsRefresh = options?.forceRefresh || now > creds.expiresAt - 5 * 60 * 1e3;
+  if (needsRefresh) {
+    try {
+      const refreshed = await refreshTokens(creds.refreshToken, creds);
+      await storeCredentials(refreshed);
+      return refreshed;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`Token refresh failed: ${message}`);
+      if (now < creds.expiresAt) {
+        return creds;
+      }
+      return null;
+    }
+  }
+  return creds;
+}
+
+// ../listener/dist/poll-client.js
+var POLL_TIMEOUT_MS = 3e4;
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var PollClient = class {
+  apiUrl;
+  constructor(apiUrl) {
+    this.apiUrl = apiUrl;
+  }
+  async poll(repoIds, since, options) {
+    const credentials = await getValidCredentials();
+    if (!credentials) {
+      throw new AuthError("Not logged in. Run `repowise login` first.");
+    }
+    const params = new URLSearchParams({
+      repoIds: repoIds.join(","),
+      since
+    });
+    if (options?.includeActiveRepos) {
+      params.set("includeActiveRepos", "true");
+    }
+    const url = `${this.apiUrl}/v1/listeners/poll?${params.toString()}`;
+    const result = await this.fetchWithAuth(url, credentials.accessToken);
+    if (result.status === 401 || result.status === 403) {
+      const refreshed = await getValidCredentials({ forceRefresh: true });
+      if (!refreshed) {
+        throw new AuthError("Session expired. Run `repowise login` again.");
+      }
+      const retry = await this.fetchWithAuth(url, refreshed.accessToken);
+      if (retry.status === 401 || retry.status === 403) {
+        throw new AuthError("Session expired. Run `repowise login` again.");
+      }
+      if (!retry.ok) {
+        throw new Error(`Poll request failed: ${retry.status}`);
+      }
+      const json2 = await retry.json();
+      return json2.data;
+    }
+    if (!result.ok) {
+      throw new Error(`Poll request failed: ${result.status}`);
+    }
+    const json = await result.json();
+    return json.data;
+  }
+  async fetchWithAuth(url, accessToken) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), POLL_TIMEOUT_MS);
+    try {
+      return await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// ../listener/dist/reconnection.js
+var DEFAULT_CONFIG = {
+  initialDelay: 1e3,
+  maxDelay: 6e4,
+  jitterMax: 1e3
+};
+var BackoffCalculator = class {
+  config;
+  attempt = 0;
+  constructor(config2 = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+  }
+  nextDelay() {
+    const baseDelay = Math.min(this.config.initialDelay * Math.pow(2, this.attempt), this.config.maxDelay);
+    const jitter = Math.random() * this.config.jitterMax;
+    this.attempt++;
+    return baseDelay + jitter;
+  }
+  reset() {
+    this.attempt = 0;
+  }
+  getAttempt() {
+    return this.attempt;
+  }
+};
+
+// ../listener/dist/notification.js
+import notifier from "node-notifier";
+var TITLE = "RepoWise";
+var notify = notifier.notify.bind(notifier);
+function notifyConnectionLost() {
+  try {
+    notify({
+      title: TITLE,
+      message: "Connection lost \u2014 will sync when back online"
+    });
+  } catch {
+  }
+}
+function notifyBackOnline(updateCount) {
+  try {
+    notify({
+      title: TITLE,
+      message: `Back online \u2014 ${updateCount} updates synced`
+    });
+  } catch {
+  }
+}
+function notifyContextUpdated(repoId, fileCount) {
+  try {
+    notify({
+      title: TITLE,
+      message: `Context updated for ${repoId} \u2014 ${fileCount} files`
+    });
+  } catch {
+  }
+}
+
+// ../listener/dist/context-fetcher.js
+import { execFile } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname2, join as join7 } from "path";
+import { promisify } from "util";
+
+// ../listener/dist/file-writer.js
+import { access } from "fs/promises";
+import { join as join6 } from "path";
+async function verifyContextFolder(localPath) {
+  try {
+    await access(join6(localPath, "repowise-context"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/context-fetcher.js
+var execFileAsync = promisify(execFile);
+async function fetchContextUpdates(localPath) {
+  try {
+    const { stdout: beforeSha } = await execFileAsync("git", [
+      "-C",
+      localPath,
+      "rev-parse",
+      "HEAD"
+    ]);
+    const before = beforeSha.trim();
+    await execFileAsync("git", ["-C", localPath, "pull", "--ff-only"]);
+    const { stdout: afterSha } = await execFileAsync("git", ["-C", localPath, "rev-parse", "HEAD"]);
+    const after = afterSha.trim();
+    if (before === after) {
+      return { success: true, updatedFiles: [] };
+    }
+    const { stdout } = await execFileAsync("git", [
+      "-C",
+      localPath,
+      "diff",
+      "--name-only",
+      before,
+      after,
+      "--",
+      "repowise-context/"
+    ]);
+    const updatedFiles = stdout.trim().split("\n").filter(Boolean);
+    const contextExists = await verifyContextFolder(localPath);
+    if (!contextExists && updatedFiles.length > 0) {
+      console.warn(`Warning: repowise-context/ folder not found in ${localPath} after pull`);
+    }
+    return { success: true, updatedFiles };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error(`Git pull failed for ${localPath}: ${message}`);
+    return { success: false, updatedFiles: [] };
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchContextFromServer(repoId, localPath, apiUrl) {
+  try {
+    const credentials = await getValidCredentials();
+    if (!credentials) {
+      console.error(`Context fetch for ${repoId}: no valid credentials`);
+      return { success: false, updatedFiles: [] };
+    }
+    const headers = {
+      Authorization: `Bearer ${credentials.accessToken}`,
+      "Content-Type": "application/json"
+    };
+    let listRes;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        listRes = await fetch(`${apiUrl}/v1/repos/${repoId}/context`, { headers });
+        if (listRes.status === 401 || listRes.status === 403) {
+          console.error(`Context list auth error (${listRes.status}) for repo ${repoId}`);
+          return { success: false, updatedFiles: [] };
+        }
+        if (listRes.ok)
+          break;
+        console.error(`Context list failed (${listRes.status}) for repo ${repoId}, attempt ${attempt}/3`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Context list network error for repo ${repoId}, attempt ${attempt}/3: ${msg}`);
+      }
+      if (attempt < 3)
+        await delay(2e3);
+    }
+    if (!listRes || !listRes.ok) {
+      console.error(`Context list failed after 3 attempts for repo ${repoId}`);
+      return { success: false, updatedFiles: [] };
+    }
+    const listData = await listRes.json();
+    const files = listData.data?.files ?? [];
+    console.log(`Context fetch for ${repoId}: ${files.length} file(s) available`);
+    if (files.length === 0) {
+      return { success: true, updatedFiles: [] };
+    }
+    const contextDir = join7(localPath, "repowise-context");
+    await mkdir4(contextDir, { recursive: true });
+    const updatedFiles = [];
+    for (const file of files) {
+      if (file.fileName.includes(".."))
+        continue;
+      const urlRes = await fetch(`${apiUrl}/v1/repos/${repoId}/context/files/${file.fileName}`, {
+        headers
+      });
+      if (!urlRes.ok) {
+        console.error(`Context fetch for ${repoId}: failed to get URL for ${file.fileName} (${urlRes.status})`);
+        continue;
+      }
+      const urlData = await urlRes.json();
+      const presignedUrl = urlData.data?.url;
+      if (!presignedUrl) {
+        console.error(`Context fetch for ${repoId}: no presigned URL returned for ${file.fileName}`);
+        continue;
+      }
+      const contentRes = await fetch(presignedUrl);
+      if (!contentRes.ok) {
+        console.error(`Context fetch for ${repoId}: download failed for ${file.fileName} (${contentRes.status})`);
+        continue;
+      }
+      const content = await contentRes.text();
+      const filePath = join7(contextDir, file.fileName);
+      await mkdir4(dirname2(filePath), { recursive: true });
+      await writeFile4(filePath, content, "utf-8");
+      updatedFiles.push(file.fileName);
+    }
+    console.log(`Context fetch for ${repoId}: downloaded ${updatedFiles.length}/${files.length} file(s)`);
+    return { success: true, updatedFiles };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error(`Server context fetch failed for ${repoId}: ${message}`);
+    return { success: false, updatedFiles: [] };
+  }
+}
+
+// ../listener/dist/process-manager.js
+import { spawn } from "child_process";
+import { openSync, closeSync } from "fs";
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir5, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+function repowiseDir() {
+  return getConfigDir();
+}
+function pidPath() {
+  return join8(repowiseDir(), "listener.pid");
+}
+function logDirPath() {
+  return join8(repowiseDir(), "logs");
+}
+function resolveListenerCommand() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mainPath = require2.resolve("@repowise/listener/main");
+    return { script: mainPath, args: [] };
+  } catch {
+    const bundlePath = fileURLToPath(import.meta.url);
+    return { script: bundlePath, args: ["__listener"] };
+  }
+}
+async function readPid() {
+  try {
+    const content = await readFile4(pidPath(), "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startBackground() {
+  if (await isRunning()) {
+    const pid2 = await readPid();
+    if (pid2)
+      return pid2;
+  }
+  const logDir2 = logDirPath();
+  await mkdir5(logDir2, { recursive: true });
+  const cmd = resolveListenerCommand();
+  const stdoutFd = openSync(join8(logDir2, "listener-stdout.log"), "a");
+  const stderrFd = openSync(join8(logDir2, "listener-stderr.log"), "a");
+  const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
+    detached: true,
+    stdio: ["ignore", stdoutFd, stderrFd],
+    cwd: homedir2(),
+    env: { ...process.env }
+  });
+  child.unref();
+  closeSync(stdoutFd);
+  closeSync(stderrFd);
+  const pid = child.pid;
+  if (!pid)
+    throw new Error("Failed to spawn listener process");
+  await writeFile5(pidPath(), String(pid));
+  return pid;
+}
+async function stopProcess() {
+  const pid = await readPid();
+  if (pid === null)
+    return;
+  if (!isAlive(pid)) {
+    await removePidFile();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline && isAlive(pid)) {
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (isAlive(pid)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  await removePidFile();
+}
+async function isRunning() {
+  const pid = await readPid();
+  if (pid === null)
+    return false;
+  return isAlive(pid);
+}
+async function getStatus() {
+  const pid = await readPid();
+  if (pid === null)
+    return { running: false, pid: null };
+  const alive = isAlive(pid);
+  return { running: alive, pid: alive ? pid : null };
+}
+async function removePidFile() {
+  try {
+    await unlink3(pidPath());
+  } catch {
+  }
+}
+
+// ../listener/dist/lib/auto-updater.js
+import { execFile as execFile2 } from "child_process";
+import { access as access2, constants } from "fs/promises";
+import { join as join9 } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function getPackageName() {
+  return true ? "repowise" : "repowise";
+}
+function getNpmDistTag() {
+  return true ? "latest" : "latest";
+}
+async function checkForUpdate(state) {
+  if (process.env["CI"] === "true")
+    return false;
+  const packageName = getPackageName();
+  const distTag = getNpmDistTag();
+  try {
+    const { stdout: prefix } = await execFileAsync2("npm", ["prefix", "-g"], { timeout: 1e4 });
+    const npmDir = join9(prefix.trim(), "lib", "node_modules");
+    const checkDir = process.platform === "win32" ? prefix.trim() : npmDir;
+    await access2(checkDir, constants.W_OK);
+  } catch {
+    console.log("[auto-update] npm global prefix not writable \u2014 skipping update check");
+    return false;
+  }
+  let distTags;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) {
+      console.warn(`[auto-update] npm registry returned ${res.status}`);
+      return false;
+    }
+    distTags = await res.json();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`[auto-update] Failed to fetch dist-tags: ${msg}`);
+    return false;
+  }
+  const latestVersion = distTags[distTag];
+  if (!latestVersion) {
+    console.warn(`[auto-update] No version found for dist-tag "${distTag}"`);
+    return false;
+  }
+  let currentVersion;
+  try {
+    const { stdout } = await execFileAsync2(packageName, ["--version"], { timeout: 1e4 });
+    currentVersion = stdout.trim();
+  } catch {
+    console.warn("[auto-update] Could not determine current version");
+    return false;
+  }
+  if (!isNewer(latestVersion, currentVersion)) {
+    console.log(`[auto-update] Current version ${currentVersion} is up to date`);
+    state.lastUpdateCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    return false;
+  }
+  console.log(`[auto-update] Updating ${packageName} from ${currentVersion} to ${latestVersion}...`);
+  try {
+    await execFileAsync2("npm", ["install", "-g", `${packageName}@${latestVersion}`], {
+      timeout: 6e4
+    });
+    console.log(`[auto-update] Successfully updated to ${latestVersion}`);
+    state.lastUpdateCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[auto-update] Installation failed: ${msg}`);
+    state.lastUpdateCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    return false;
+  }
+}
+function isNewer(a, b) {
+  const parseVer = (v) => {
+    const [main, pre] = v.split("-", 2);
+    const parts = main.split(".").map(Number);
+    return { parts, pre: pre ?? "" };
+  };
+  const va = parseVer(a);
+  const vb = parseVer(b);
+  for (let i = 0; i < Math.max(va.parts.length, vb.parts.length); i++) {
+    const na = va.parts[i] ?? 0;
+    const nb = vb.parts[i] ?? 0;
+    if (na > nb)
+      return true;
+    if (na < nb)
+      return false;
+  }
+  if (vb.pre && !va.pre)
+    return true;
+  if (va.pre && vb.pre)
+    return va.pre > vb.pre;
+  return false;
+}
+
+// ../listener/dist/main.js
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var STALE_CHECK_COOLDOWN_MS = 60 * 60 * 1e3;
+var AUTO_UPDATE_EVERY_N_CYCLES = 4320;
+var CRASH_LOOP_WINDOW_MS = 3e4;
+var CRASH_LOOP_THRESHOLD = 3;
+var running = false;
+var sleepResolve = null;
+var releaseLock = null;
+function stop() {
+  running = false;
+  if (sleepResolve) {
+    sleepResolve();
+    sleepResolve = null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    sleepResolve = resolve;
+    setTimeout(() => {
+      sleepResolve = null;
+      resolve();
+    }, ms);
+  });
+}
+function decodeEmailFromIdToken(idToken) {
+  try {
+    const payload = JSON.parse(Buffer.from(idToken.split(".")[1], "base64url").toString());
+    return typeof payload.email === "string" ? payload.email : null;
+  } catch {
+    return null;
+  }
+}
+async function processNotifications(notifications, state, repoLocalPaths, apiUrl) {
+  let updateCount = 0;
+  for (const notif of notifications) {
+    const repoState = state.repos[notif.repoId];
+    if (repoState && notif.createdAt <= repoState.lastSyncTimestamp) {
+      continue;
+    }
+    if (notif.type === "sync.completed") {
+      if (!notif.commitSha) {
+        console.warn(`sync.completed for ${notif.repoId} has no commitSha`);
+      }
+      const localPath = repoLocalPaths.get(notif.repoId);
+      if (localPath) {
+        let result;
+        if (apiUrl) {
+          result = await fetchContextFromServer(notif.repoId, localPath, apiUrl);
+        } else {
+          result = await fetchContextUpdates(localPath);
+        }
+        if (result.success) {
+          updateCount++;
+          notifyContextUpdated(notif.repoId, result.updatedFiles.length);
+          state.repos[notif.repoId] = {
+            ...state.repos[notif.repoId],
+            lastSyncTimestamp: notif.createdAt,
+            lastSyncCommitSha: notif.commitSha
+          };
+        } else {
+          console.error(`Download failed for repo ${notif.repoId} \u2014 will retry on next poll`);
+        }
+      } else {
+        state.repos[notif.repoId] = {
+          ...state.repos[notif.repoId],
+          lastSyncTimestamp: notif.createdAt,
+          lastSyncCommitSha: notif.commitSha
+        };
+      }
+    } else {
+      state.repos[notif.repoId] = {
+        ...state.repos[notif.repoId],
+        lastSyncTimestamp: notif.createdAt,
+        lastSyncCommitSha: notif.commitSha
+      };
+    }
+  }
+  return updateCount;
+}
+async function handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, apiUrl) {
+  if (!offlineState.offlineSince)
+    return;
+  const offlineDuration = Date.now() - new Date(offlineState.offlineSince).getTime();
+  if (offlineDuration >= TWENTY_FOUR_HOURS_MS) {
+    let syncCount = 0;
+    for (const [repoId, localPath] of repoLocalPaths) {
+      let result;
+      if (apiUrl) {
+        result = await fetchContextFromServer(repoId, localPath, apiUrl);
+      } else {
+        result = await fetchContextUpdates(localPath);
+      }
+      if (result.success) {
+        syncCount++;
+        state.repos[repoId] = {
+          ...state.repos[repoId],
+          lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          lastSyncCommitSha: null
+          // unknown from catch-up, but timestamp prevents re-download
+        };
+      }
+    }
+    await saveState(state);
+    notifyBackOnline(syncCount);
+  } else {
+    const sinceTimestamp = offlineState.offlineSince;
+    const response = await pollClient.poll(repoIds, sinceTimestamp);
+    const updateCount = await processNotifications(response.notifications, state, repoLocalPaths, apiUrl);
+    await saveState(state);
+    notifyBackOnline(updateCount);
+  }
+}
+async function checkStaleContext(repos, state, groups) {
+  const now = Date.now();
+  let dirty = false;
+  for (const repo of repos) {
+    const repoState = state.repos[repo.repoId];
+    if (!repoState)
+      continue;
+    if (repoState.lastContextCheckAt) {
+      const lastCheck = new Date(repoState.lastContextCheckAt).getTime();
+      if (now - lastCheck < STALE_CHECK_COOLDOWN_MS)
+        continue;
+    }
+    const apiUrl = repo.apiUrl;
+    const group = groups.find((g) => g.apiUrl === apiUrl);
+    if (group?.offline.isOffline)
+      continue;
+    const { statSync: statSync2, readdirSync: readdirSync2 } = await import("fs");
+    const contextPath = join10(repo.localPath, "repowise-context");
+    let isMissingOrEmpty = false;
+    try {
+      const s = statSync2(contextPath);
+      if (!s.isDirectory()) {
+        isMissingOrEmpty = true;
+      } else {
+        const entries = readdirSync2(contextPath);
+        isMissingOrEmpty = entries.length === 0;
+      }
+    } catch {
+      isMissingOrEmpty = true;
+    }
+    state.repos[repo.repoId] = {
+      ...state.repos[repo.repoId],
+      lastContextCheckAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    dirty = true;
+    if (isMissingOrEmpty && apiUrl) {
+      console.log(`[self-heal] Context missing/empty for ${repo.repoId}, re-downloading...`);
+      const result = await fetchContextFromServer(repo.repoId, repo.localPath, apiUrl);
+      if (result.success && result.updatedFiles.length > 0) {
+        console.log(`[self-heal] Re-downloaded ${result.updatedFiles.length} files for ${repo.repoId}`);
+        notifyContextUpdated(repo.repoId, result.updatedFiles.length);
+      }
+    }
+  }
+  return dirty;
+}
+async function startListener() {
+  running = true;
+  const configDir = getConfigDir();
+  await mkdir6(configDir, { recursive: true });
+  const lockPath = join10(configDir, "listener.lock");
+  await writeFile6(lockPath, "", { flag: "a" });
+  let lockIsHeld = false;
+  try {
+    lockIsHeld = await lockfile2.check(lockPath, { stale: 3e4, realpath: false });
+  } catch {
+  }
+  if (!lockIsHeld) {
+    const existingPid = await readPid();
+    if (existingPid && existingPid !== process.pid && isAlive(existingPid)) {
+      try {
+        process.kill(existingPid, "SIGTERM");
+        await new Promise((r) => setTimeout(r, 1e3));
+      } catch {
+      }
+    }
+  }
+  try {
+    releaseLock = await lockfile2.lock(lockPath, { stale: 3e4, realpath: false });
+  } catch {
+    console.error(`Listener already running. Stop it first with \`${true ? "repowise" : "repowise"} stop\`.`);
+    process.exitCode = 1;
+    return;
+  }
+  const releaseLockAndExit = async () => {
+    if (releaseLock) {
+      try {
+        await releaseLock();
+      } catch {
+      }
+      releaseLock = null;
+    }
+  };
+  let config2;
+  try {
+    config2 = await getListenerConfig();
+  } catch (err) {
+    console.error("Failed to load config:", err);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  if (config2.repos.length === 0 && !config2.autoDiscoverRepos) {
+    console.error(`No repos configured. Add repos to ${join10(configDir, "config.json")}`);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  const credentials = await getValidCredentials();
+  if (!credentials) {
+    console.error("Not logged in. Run `repowise login` first.");
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  let state;
+  try {
+    state = await loadState();
+  } catch (err) {
+    console.error("Failed to load state:", err);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = Date.now();
+  if (state.lastBootAt) {
+    const lastBootMs = new Date(state.lastBootAt).getTime();
+    if (nowMs - lastBootMs < CRASH_LOOP_WINDOW_MS) {
+      state.crashCount = (state.crashCount ?? 0) + 1;
+    } else {
+      state.crashCount = 0;
+    }
+  }
+  state.lastBootAt = nowIso;
+  const crashLoopDetected = (state.crashCount ?? 0) >= CRASH_LOOP_THRESHOLD;
+  if (crashLoopDetected) {
+    console.warn(`[self-heal] Crash-loop detected (${state.crashCount} rapid restarts). Auto-update disabled until stable.`);
+  }
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const repo of config2.repos) {
+    const apiUrl = repo.apiUrl ?? config2.defaultApiUrl;
+    let group = groupMap.get(apiUrl);
+    if (!group) {
+      group = {
+        apiUrl,
+        pollClient: new PollClient(apiUrl),
+        backoff: new BackoffCalculator(),
+        repoIds: [],
+        repoLocalPaths: /* @__PURE__ */ new Map(),
+        offline: { isOffline: false, offlineSince: null, attemptCount: 0, nextRetryAt: 0 }
+      };
+      groupMap.set(apiUrl, group);
+    }
+    group.repoIds.push(repo.repoId);
+    group.repoLocalPaths.set(repo.repoId, repo.localPath);
+  }
+  const groups = Array.from(groupMap.values());
+  const allRepoIds = config2.repos.map((r) => r.repoId);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const repoId of allRepoIds) {
+    if (!state.repos[repoId]) {
+      state.repos[repoId] = { lastSyncTimestamp: now, lastSyncCommitSha: null };
+    }
+  }
+  await saveState(state);
+  let pollIntervalMs = 5e3;
+  let pollCycleCount = 0;
+  const RECONCILE_EVERY_N_CYCLES = 60;
+  const origLog = console.log.bind(console);
+  const origError = console.error.bind(console);
+  const origWarn = console.warn.bind(console);
+  const ts = () => {
+    const d = /* @__PURE__ */ new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+  };
+  console.log = (...args) => origLog(`[${ts()}]`, ...args);
+  console.error = (...args) => origError(`[${ts()}]`, ...args);
+  console.warn = (...args) => origWarn(`[${ts()}]`, ...args);
+  console.log(`RepoWise Listener started \u2014 watching ${allRepoIds.length} repo(s)`);
+  const shutdown = async () => {
+    console.log("Shutting down...");
+    stop();
+    await saveState(state);
+    if (releaseLock) {
+      try {
+        await releaseLock();
+      } catch {
+      }
+      releaseLock = null;
+    }
+  };
+  process.on("SIGTERM", () => {
+    shutdown().catch((err) => {
+      console.error("Shutdown error:", err);
+    }).finally(() => process.exit(0));
+  });
+  process.on("SIGINT", () => {
+    shutdown().catch((err) => {
+      console.error("Shutdown error:", err);
+    }).finally(() => process.exit(0));
+  });
+  while (running) {
+    let anyAuthError = null;
+    let authErrorGroup = null;
+    let minPollInterval = pollIntervalMs;
+    let connectionLostNotified = false;
+    pollCycleCount++;
+    const shouldReconcile = pollCycleCount % RECONCILE_EVERY_N_CYCLES === 0;
+    if (!crashLoopDetected && !config2.noAutoUpdate && pollCycleCount % AUTO_UPDATE_EVERY_N_CYCLES === 0) {
+      try {
+        const updated = await checkForUpdate(state);
+        if (updated) {
+          await saveState(state);
+          if (releaseLock) {
+            try {
+              await releaseLock();
+            } catch {
+            }
+            releaseLock = null;
+          }
+          console.log("Auto-update complete \u2014 exiting for restart");
+          process.exit(0);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Auto-update check failed: ${msg}`);
+      }
+    }
+    for (const group of groups) {
+      if (!running)
+        break;
+      if (group.offline.isOffline && Date.now() < group.offline.nextRetryAt) {
+        continue;
+      }
+      try {
+        const sinceTimestamp = group.repoIds.reduce((earliest, id) => {
+          const ts2 = state.repos[id]?.lastSyncTimestamp ?? now;
+          return ts2 < earliest ? ts2 : earliest;
+        }, now);
+        const response = await group.pollClient.poll(group.repoIds, sinceTimestamp, {
+          includeActiveRepos: shouldReconcile
+        });
+        if (response.activeRepos && response.activeRepos.length > 0) {
+          try {
+            const result = reconcileRepos(config2.repos, response.activeRepos, state, group.apiUrl, {
+              autoDiscover: config2.autoDiscoverRepos
+            });
+            if (result.updated) {
+              config2.repos = result.repos;
+              await saveListenerConfig(config2);
+              await saveState(state);
+              group.repoIds = result.repos.filter((r) => (r.apiUrl ?? config2.defaultApiUrl) === group.apiUrl).map((r) => r.repoId);
+              group.repoLocalPaths.clear();
+              for (const r of result.repos) {
+                if ((r.apiUrl ?? config2.defaultApiUrl) === group.apiUrl) {
+                  group.repoLocalPaths.set(r.repoId, r.localPath);
+                }
+              }
+              for (const change of result.changes) {
+                console.log(`[reconcile] ${change}`);
+              }
+              if (result.addedRepos.length > 0) {
+                for (const addedRepo of result.addedRepos) {
+                  const apiUrl = addedRepo.apiUrl ?? config2.defaultApiUrl;
+                  try {
+                    const fetchResult = await fetchContextFromServer(addedRepo.repoId, addedRepo.localPath, apiUrl);
+                    if (fetchResult.success) {
+                      console.log(`[self-heal] Downloaded ${fetchResult.updatedFiles.length} context files for ${addedRepo.repoId}`);
+                    }
+                  } catch (fetchErr) {
+                    console.warn(`[self-heal] Context download failed for ${addedRepo.repoId}:`, fetchErr instanceof Error ? fetchErr.message : String(fetchErr));
+                  }
+                }
+              }
+            }
+          } catch (reconcileErr) {
+            console.warn("Repo reconciliation failed \u2014 will retry next cycle", reconcileErr instanceof Error ? reconcileErr.message : String(reconcileErr));
+          }
+        }
+        if (group.offline.isOffline) {
+          await handleCatchUp(group.offline, group.pollClient, group.repoIds, state, group.repoLocalPaths, group.apiUrl);
+          group.offline.isOffline = false;
+          group.offline.offlineSince = null;
+          group.offline.attemptCount = 0;
+          group.offline.nextRetryAt = 0;
+          group.backoff.reset();
+        } else if (response.notifications.length > 0) {
+          await processNotifications(response.notifications, state, group.repoLocalPaths, group.apiUrl);
+          await saveState(state);
+        }
+        minPollInterval = Math.min(minPollInterval, response.pollIntervalMs);
+      } catch (err) {
+        if (!running)
+          break;
+        if (err instanceof AuthError) {
+          anyAuthError = err;
+          authErrorGroup = group;
+          break;
+        }
+        if (!group.offline.isOffline) {
+          group.offline.isOffline = true;
+          group.offline.offlineSince = (/* @__PURE__ */ new Date()).toISOString();
+          group.offline.attemptCount = 0;
+          if (!connectionLostNotified) {
+            notifyConnectionLost();
+            connectionLostNotified = true;
+          }
+        }
+        group.offline.attemptCount++;
+        const delay2 = group.backoff.nextDelay();
+        group.offline.nextRetryAt = Date.now() + delay2;
+        const message = err instanceof Error ? err.message : "Unknown error";
+        console.error(`Poll failed for ${group.apiUrl} (attempt ${group.offline.attemptCount}): ${message}. Retrying in ${Math.round(delay2 / 1e3)}s`);
+      }
+    }
+    if (shouldReconcile) {
+      try {
+        const staleDirty = await checkStaleContext(config2.repos, state, groups);
+        if (staleDirty) {
+          await saveState(state);
+        }
+      } catch (err) {
+        console.warn("[self-heal] Stale context check failed:", err instanceof Error ? err.message : String(err));
+      }
+    }
+    if (anyAuthError) {
+      let recovered = false;
+      for (let attempt = 1; attempt <= 3; attempt++) {
+        console.warn(`Auth error \u2014 retrying credentials (attempt ${attempt}/3)...`);
+        await sleep(5e3);
+        if (!running)
+          break;
+        const fresh = await getValidCredentials({ forceRefresh: true });
+        if (fresh) {
+          console.log("Credentials recovered \u2014 resuming listener");
+          recovered = true;
+          break;
+        }
+      }
+      if (recovered)
+        continue;
+      console.error("Session expired after 3 retries. Sending notification email and waiting for re-authentication...");
+      const creds = await getStoredCredentials();
+      const email = creds?.idToken ? decodeEmailFromIdToken(creds.idToken) : null;
+      if (email && authErrorGroup) {
+        try {
+          await fetch(`${authErrorGroup.apiUrl}/v1/public/notify-auth-expired`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ email })
+          });
+        } catch {
+        }
+      }
+      while (running) {
+        await sleep(5 * 60 * 1e3);
+        if (!running)
+          break;
+        const fresh = await getValidCredentials({ forceRefresh: true });
+        if (fresh) {
+          console.log("Re-authenticated \u2014 resuming listener");
+          break;
+        }
+      }
+      continue;
+    }
+    pollIntervalMs = minPollInterval;
+    await sleep(pollIntervalMs);
+  }
+  if (releaseLock) {
+    try {
+      await releaseLock();
+    } catch {
+    }
+    releaseLock = null;
+  }
+}
+var isDirectRun = process.argv[1]?.endsWith("main.js") || process.argv[1]?.endsWith("main.ts");
+if (isDirectRun) {
+  startListener().catch((err) => {
+    console.error("Listener fatal error:", err);
+    process.exitCode = 1;
+  });
+}
+
+// src/lib/env.ts
+import { homedir as homedir3 } from "os";
+import { join as join11 } from "path";
+var IS_STAGING = true ? false : false;
+var PRODUCTION = {
+  apiUrl: "https://api.repowise.ai",
+  cognitoDomain: "auth.repowise.ai",
+  cognitoClientId: "50so1fkmjbqt1ufnsmbhsjbtst",
+  cognitoRegion: "us-east-1",
+  customDomain: true
+};
+var STAGING = {
+  apiUrl: "https://staging-api.repowise.ai",
+  cognitoDomain: "auth-staging.repowise.ai",
+  cognitoClientId: "7h0l0dhjcb1v5erer0gaclv0q6",
+  cognitoRegion: "us-east-1",
+  customDomain: true
+};
+function getEnvConfig() {
+  return IS_STAGING ? STAGING : PRODUCTION;
+}
+function getConfigDir2() {
+  return join11(homedir3(), IS_STAGING ? ".repowise-staging" : ".repowise");
+}
+function getPackageName2() {
+  return true ? "repowise" : "repowise";
+}
+function getNpmDistTag2() {
+  return true ? "latest" : "latest";
+}
+
+// src/lib/welcome.ts
+import chalk2 from "chalk";
+
+// src/lib/config.ts
+import { readFile as readFile5, writeFile as writeFile7, mkdir as mkdir7, rename as rename3, unlink as unlink4 } from "fs/promises";
+import { join as join12 } from "path";
+import lockfile3 from "proper-lockfile";
+async function getConfig() {
+  try {
+    const data = await readFile5(join12(getConfigDir2(), "config.json"), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config2) {
+  const dir = getConfigDir2();
+  const path = join12(dir, "config.json");
+  await mkdir7(dir, { recursive: true });
+  const tmpPath = path + ".tmp";
+  try {
+    await writeFile7(tmpPath, JSON.stringify(config2, null, 2));
+    await rename3(tmpPath, path);
+  } catch (err) {
+    try {
+      await unlink4(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function mergeAndSaveConfig(updates) {
+  const dir = getConfigDir2();
+  const path = join12(dir, "config.json");
+  await mkdir7(dir, { recursive: true });
+  try {
+    await writeFile7(path, "", { flag: "a" });
+  } catch {
+  }
+  let release = null;
+  try {
+    release = await lockfile3.lock(path, { stale: 1e4, retries: 3, realpath: false });
+    let raw = {};
+    try {
+      raw = JSON.parse(await readFile5(path, "utf-8"));
+    } catch {
+    }
+    const merged = { ...raw, ...updates };
+    if (updates.repos) {
+      const existingRepos = Array.isArray(raw["repos"]) ? raw["repos"] : [];
+      const updatedRepoIds = new Set(updates.repos.map((r) => r.repoId));
+      merged.repos = [
+        ...existingRepos.filter((r) => !updatedRepoIds.has(r.repoId)),
+        ...updates.repos
+      ];
+    }
+    await saveConfig(merged);
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/lib/update-check.ts
+import chalk from "chalk";
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+async function checkForCliUpdate(currentVersion) {
+  try {
+    if (process.env["CI"] === "true" || process.env["REPOWISE_NO_UPDATE_CHECK"] === "1") {
+      return false;
+    }
+    const config2 = await getConfig();
+    if (config2.noUpdateCheck) return false;
+    if (config2.lastUpdateCheck) {
+      const lastCheck = new Date(config2.lastUpdateCheck).getTime();
+      if (Date.now() - lastCheck < ONE_DAY_MS) return false;
+    }
+    const packageName = getPackageName2();
+    const distTag = getNpmDistTag2();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    let distTags;
+    try {
+      const res = await fetch(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!res.ok) return false;
+      distTags = await res.json();
+    } catch {
+      clearTimeout(timeout);
+      return false;
+    }
+    const latestVersion = distTags[distTag];
+    if (!latestVersion) return false;
+    await mergeAndSaveConfig({ lastUpdateCheck: (/* @__PURE__ */ new Date()).toISOString() });
+    if (!isNewer2(latestVersion, currentVersion)) return false;
+    console.log("");
+    console.log(
+      chalk.yellow(
+        `  Update available: ${chalk.dim(currentVersion)} ${chalk.yellow("\u2192")} ${chalk.green(latestVersion)}`
+      )
+    );
+    console.log(chalk.yellow(`  Run: ${chalk.bold(`npm install -g ${packageName}`)}`));
+    console.log("");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNewer2(a, b) {
+  const parseVer = (v) => {
+    const [main, pre] = v.split("-", 2);
+    const parts = main.split(".").map(Number);
+    return { parts, pre: pre ?? "" };
+  };
+  const va = parseVer(a);
+  const vb = parseVer(b);
+  for (let i = 0; i < Math.max(va.parts.length, vb.parts.length); i++) {
+    const na = va.parts[i] ?? 0;
+    const nb = vb.parts[i] ?? 0;
+    if (na > nb) return true;
+    if (na < nb) return false;
+  }
+  if (vb.pre && !va.pre) return true;
+  if (va.pre && vb.pre) return va.pre > vb.pre;
+  return false;
+}
+
+// src/lib/welcome.ts
+var W = 41;
+function row(styled, visible) {
+  return chalk2.cyan("  \u2502") + styled + " ".repeat(W - visible) + chalk2.cyan("\u2502");
+}
+async function showWelcome(currentVersion) {
+  try {
+    const config2 = await getConfig();
+    if (config2.lastSeenVersion === currentVersion) {
+      await checkForCliUpdate(currentVersion);
+      return;
+    }
+    const isUpgrade = !!config2.lastSeenVersion;
+    const tag = isUpgrade ? "updated" : "installed";
+    const titleText = `RepoWise v${currentVersion}`;
+    const titleStyled = "   " + chalk2.bold(titleText) + chalk2.green(` \u2713 ${tag}`);
+    const titleVisible = 3 + titleText.length + 3 + tag.length;
+    const border = "\u2500".repeat(W);
+    console.log("");
+    console.log(chalk2.cyan(`  \u256D${border}\u256E`));
+    console.log(row("", 0));
+    console.log(row(titleStyled, titleVisible));
+    console.log(row("", 0));
+    console.log(row("   " + chalk2.dim("Get started:"), 15));
+    console.log(row("     $ " + chalk2.bold("repowise create"), 22));
+    console.log(row("", 0));
+    console.log(row("   " + chalk2.dim("Thank you for using RepoWise!"), 32));
+    console.log(row("   " + chalk2.dim("https://repowise.ai"), 22));
+    console.log(row("", 0));
+    console.log(chalk2.cyan(`  \u2570${border}\u256F`));
+    console.log("");
+    await mergeAndSaveConfig({ lastSeenVersion: currentVersion });
+  } catch {
+  }
+}
+
+// src/commands/create.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join17 } from "path";
+
+// ../listener/dist/service-installer.js
+import { execFile as execFile3 } from "child_process";
+import { writeFile as writeFile8, mkdir as mkdir8, unlink as unlink5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join13 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var IS_STAGING2 = true ? false : false;
+function resolveListenerCommand2() {
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const mainPath = require2.resolve("@repowise/listener/main");
+    return { script: mainPath, args: [] };
+  } catch {
+    const bundlePath = fileURLToPath2(import.meta.url);
+    return { script: bundlePath, args: ["__listener"] };
+  }
+}
+function exec(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile3(cmd, args, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(String(stdout ?? ""));
+    });
+  });
+}
+var PLIST_LABEL = IS_STAGING2 ? "com.repowise-staging.listener" : "com.repowise.listener";
+function plistPath() {
+  return join13(homedir4(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function logDir() {
+  return join13(getConfigDir(), "logs");
+}
+function buildPlist() {
+  const cmd = resolveListenerCommand2();
+  const logs = logDir();
+  const programArgs = [process.execPath, cmd.script, ...cmd.args].map((a) => `        <string>${a}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${join13(logs, "listener-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join13(logs, "listener-stderr.log")}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>`;
+}
+async function darwinInstall() {
+  await mkdir8(logDir(), { recursive: true });
+  await mkdir8(join13(homedir4(), "Library", "LaunchAgents"), { recursive: true });
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  await writeFile8(plistPath(), buildPlist());
+  await exec("launchctl", ["load", plistPath()]);
+}
+async function darwinUninstall() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  try {
+    await unlink5(plistPath());
+  } catch {
+  }
+}
+async function darwinIsInstalled() {
+  try {
+    const stdout = await exec("launchctl", ["list"]);
+    return stdout.includes(PLIST_LABEL);
+  } catch {
+    return false;
+  }
+}
+var SYSTEMD_SERVICE = IS_STAGING2 ? "repowise-staging-listener" : "repowise-listener";
+function unitPath() {
+  return join13(homedir4(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+}
+function buildUnit() {
+  const cmd = resolveListenerCommand2();
+  const execStart = [process.execPath, cmd.script, ...cmd.args].join(" ");
+  const logs = logDir();
+  return `[Unit]
+Description=RepoWise Listener
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join13(logs, "listener-stdout.log")}
+StandardError=append:${join13(logs, "listener-stderr.log")}
+
+[Install]
+WantedBy=default.target`;
+}
+async function linuxInstall() {
+  await mkdir8(logDir(), { recursive: true });
+  await mkdir8(join13(homedir4(), ".config", "systemd", "user"), { recursive: true });
+  await writeFile8(unitPath(), buildUnit());
+  await exec("systemctl", ["--user", "daemon-reload"]);
+  await exec("systemctl", ["--user", "enable", SYSTEMD_SERVICE]);
+  await exec("systemctl", ["--user", "start", SYSTEMD_SERVICE]);
+}
+async function linuxUninstall() {
+  try {
+    await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "disable", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await unlink5(unitPath());
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
+  } catch {
+  }
+}
+async function linuxIsInstalled() {
+  try {
+    const stdout = await exec("systemctl", ["--user", "is-enabled", SYSTEMD_SERVICE]);
+    return stdout.trim() === "enabled";
+  } catch {
+    return false;
+  }
+}
+var TASK_NAME = IS_STAGING2 ? "RepoWise Staging Listener" : "RepoWise Listener";
+async function win32Install() {
+  await mkdir8(logDir(), { recursive: true });
+  const cmd = resolveListenerCommand2();
+  const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
+  await exec("schtasks", [
+    "/create",
+    "/tn",
+    TASK_NAME,
+    "/tr",
+    taskCmd,
+    "/sc",
+    "onlogon",
+    "/ru",
+    process.env.USERNAME ?? "",
+    "/f"
+  ]);
+  await exec("schtasks", ["/run", "/tn", TASK_NAME]);
+}
+async function win32Uninstall() {
+  try {
+    await exec("schtasks", ["/end", "/tn", TASK_NAME]);
+  } catch {
+  }
+  try {
+    await exec("schtasks", ["/delete", "/tn", TASK_NAME, "/f"]);
+  } catch {
+  }
+}
+async function win32IsInstalled() {
+  try {
+    await exec("schtasks", ["/query", "/tn", TASK_NAME]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function darwinStop() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+}
+async function linuxStop() {
+  await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
+}
+async function win32Stop() {
+  await exec("schtasks", ["/end", "/tn", TASK_NAME]);
+}
+async function stopService() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinStop();
+      break;
+    case "linux":
+      await linuxStop();
+      break;
+    case "win32":
+      await win32Stop();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function install() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinInstall();
+      break;
+    case "linux":
+      await linuxInstall();
+      break;
+    case "win32":
+      await win32Install();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function uninstall() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinUninstall();
+      break;
+    case "linux":
+      await linuxUninstall();
+      break;
+    case "win32":
+      await win32Uninstall();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function isInstalled() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinIsInstalled();
+    case "linux":
+      return linuxIsInstalled();
+    case "win32":
+      return win32IsInstalled();
+    default:
+      return false;
+  }
+}
+
+// src/commands/create.ts
+import chalk6 from "chalk";
+import ora from "ora";
+
+// src/lib/auth.ts
+import { createHash, randomBytes } from "crypto";
+import { readFile as readFile6, writeFile as writeFile9, mkdir as mkdir9, chmod as chmod4, unlink as unlink6 } from "fs/promises";
+import http from "http";
+import { join as join14 } from "path";
+var CLI_CALLBACK_PORT = 19876;
+var CALLBACK_TIMEOUT_MS = 12e4;
+function getCognitoConfigForStorage() {
+  const { domain, clientId, region, customDomain } = getCognitoConfig();
+  return { domain, clientId, region, customDomain };
+}
+function getCognitoConfig() {
+  const env = getEnvConfig();
+  return {
+    domain: process.env["REPOWISE_COGNITO_DOMAIN"] ?? env.cognitoDomain,
+    clientId: process.env["REPOWISE_COGNITO_CLIENT_ID"] ?? env.cognitoClientId,
+    region: process.env["REPOWISE_COGNITO_REGION"] ?? env.cognitoRegion,
+    customDomain: env.customDomain
+  };
+}
+function getCognitoBaseUrl() {
+  const { domain, region, customDomain } = getCognitoConfig();
+  return customDomain ? `https://${domain}` : `https://${domain}.auth.${region}.amazoncognito.com`;
+}
+function generateCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function generateState() {
+  return randomBytes(32).toString("hex");
+}
+function getAuthorizeUrl(codeChallenge, state) {
+  const { clientId } = getCognitoConfig();
+  if (!clientId) {
+    throw new Error(
+      "Missing REPOWISE_COGNITO_CLIENT_ID environment variable. Configure it before running login."
+    );
+  }
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: clientId,
+    redirect_uri: `http://localhost:${CLI_CALLBACK_PORT}/callback`,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    scope: "openid email profile",
+    state
+  });
+  return `${getCognitoBaseUrl()}/oauth2/authorize?${params.toString()}`;
+}
+function getTokenUrl2() {
+  return `${getCognitoBaseUrl()}/oauth2/token`;
+}
+function startCallbackServer() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${CLI_CALLBACK_PORT}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          callbackPage(
+            "Authentication Failed",
+            "Something went wrong. Please close this tab and try again.",
+            true
+          )
+        );
+        server.close();
+        reject(new Error(`Authentication error: ${error}`));
+        return;
+      }
+      if (!code || !state) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          callbackPage(
+            "Missing Parameters",
+            "The callback was missing required data. Please close this tab and try again.",
+            true
+          )
+        );
+        server.close();
+        reject(new Error("Missing code or state in callback"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        callbackPage(
+          "Authentication Successful",
+          "You can close this tab and return to the terminal.",
+          false
+        )
+      );
+      server.close();
+      resolve({ code, state });
+    });
+    server.listen(CLI_CALLBACK_PORT, "127.0.0.1");
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${CLI_CALLBACK_PORT} is already in use. Close the conflicting process and try again.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out. Please try again."));
+    }, CALLBACK_TIMEOUT_MS);
+    server.on("close", () => clearTimeout(timeout));
+  });
+}
+async function exchangeCodeForTokens(code, codeVerifier) {
+  const response = await fetch(getTokenUrl2(), {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: getCognitoConfig().clientId,
+      redirect_uri: `http://localhost:${CLI_CALLBACK_PORT}/callback`,
+      code,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function refreshTokens2(refreshToken) {
+  const response = await fetch(getTokenUrl2(), {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: getCognitoConfig().clientId,
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Token refresh failed: ${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken,
+    // Cognito does not return a new refresh token
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function getStoredCredentials2() {
+  try {
+    const credPath = join14(getConfigDir2(), "credentials.json");
+    const data = await readFile6(credPath, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function storeCredentials2(credentials) {
+  const dir = getConfigDir2();
+  const credPath = join14(dir, "credentials.json");
+  await mkdir9(dir, { recursive: true, mode: 448 });
+  await writeFile9(credPath, JSON.stringify(credentials, null, 2));
+  await chmod4(credPath, 384);
+}
+async function clearCredentials() {
+  try {
+    await unlink6(join14(getConfigDir2(), "credentials.json"));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+async function getValidCredentials2(opts) {
+  const creds = await getStoredCredentials2();
+  if (!creds) return null;
+  const needsRefresh = opts?.forceRefresh || Date.now() > creds.expiresAt - 5 * 60 * 1e3;
+  if (needsRefresh) {
+    try {
+      const refreshed = await refreshTokens2(creds.refreshToken);
+      refreshed.cognito = creds.cognito;
+      await storeCredentials2(refreshed);
+      return refreshed;
+    } catch {
+      if (Date.now() < creds.expiresAt) {
+        return creds;
+      }
+      await clearCredentials();
+      return null;
+    }
+  }
+  return creds;
+}
+async function performLogin() {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = generateState();
+  const authorizeUrl = getAuthorizeUrl(codeChallenge, state);
+  const callbackPromise = startCallbackServer();
+  try {
+    const open = (await import("open")).default;
+    await open(authorizeUrl);
+  } catch {
+    console.log(`
+Open this URL in your browser to authenticate:
+`);
+    console.log(authorizeUrl);
+  }
+  const { code, state: returnedState } = await callbackPromise;
+  if (returnedState !== state) {
+    throw new Error("State mismatch \u2014 possible CSRF attack. Please try again.");
+  }
+  const credentials = await exchangeCodeForTokens(code, codeVerifier);
+  const { domain, clientId, region, customDomain } = getCognitoConfig();
+  credentials.cognito = { domain, clientId, region, customDomain };
+  await storeCredentials2(credentials);
+  return credentials;
+}
+function callbackPage(title, message, isError) {
+  const icon = isError ? '<svg width="48" height="48" fill="none" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10" stroke="#ef4444" stroke-width="2"/><path stroke="#ef4444" stroke-width="2" stroke-linecap="round" d="M15 9l-6 6M9 9l6 6"/></svg>' : '<svg width="48" height="48" fill="none" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10" stroke="#10b981" stroke-width="2"/><path stroke="#10b981" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M8 12l3 3 5-5"/></svg>';
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title} \u2014 RepoWise</title>
+  <link rel="icon" href="https://staging.repowise.ai/favicon.svg" type="image/svg+xml">
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: 'Inter', system-ui, sans-serif; background: #0a0b14; color: #e4e4e7; min-height: 100vh; display: flex; align-items: center; justify-content: center; }
+    .card { text-align: center; max-width: 440px; padding: 48px 40px; }
+    .logo { margin-bottom: 32px; }
+    .logo svg { height: 48px; width: auto; }
+    .icon { margin-bottom: 20px; }
+    h1 { font-size: 24px; font-weight: 700; margin-bottom: 8px; color: ${isError ? "#ef4444" : "#e4e4e7"}; }
+    p { font-size: 15px; color: #a1a1aa; line-height: 1.5; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="logo">
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 50" height="48">
+        <text x="0" y="38" font-family="Inter, system-ui, sans-serif" font-weight="700" font-size="36" fill="#e4e4e7">Repo<tspan fill="#6c5ce7">Wise</tspan></text>
+      </svg>
+    </div>
+    <div class="icon">${icon}</div>
+    <h1>${title}</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+}
+function decodeIdToken(idToken) {
+  try {
+    const parts = idToken.split(".");
+    if (parts.length < 2) return { email: "unknown" };
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    return { email: payload.email ?? "unknown", tenantId: payload["custom:tenant_id"] };
+  } catch {
+    return { email: "unknown" };
+  }
+}
+
+// src/lib/api.ts
+function getApiUrl() {
+  return process.env["REPOWISE_API_URL"] ?? getEnvConfig().apiUrl;
+}
+var BILLING_URL = "https://app.repowise.ai/billing";
+async function apiRequest(path, options) {
+  const credentials = await getValidCredentials2();
+  if (!credentials) {
+    throw new Error("Not logged in. Run `repowise login` first.");
+  }
+  let response = await fetch(`${getApiUrl()}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${credentials.accessToken}`,
+      ...options?.headers
+    }
+  });
+  if (response.status === 401) {
+    const refreshed = await getValidCredentials2({ forceRefresh: true });
+    if (refreshed) {
+      response = await fetch(`${getApiUrl()}${path}`, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${refreshed.accessToken}`,
+          ...options?.headers
+        }
+      });
+    }
+    if (!refreshed || response.status === 401) {
+      await clearCredentials();
+      throw new Error("Session expired. Run `repowise login` again.");
+    }
+  }
+  if (response.status === 402) {
+    let message = "Your subscription is inactive.";
+    try {
+      const body = await response.json();
+      if (body.error?.message) message = body.error.message;
+    } catch {
+    }
+    throw new Error(`${message} Visit ${BILLING_URL} to update your subscription.`);
+  }
+  if (!response.ok) {
+    let message = `Request failed with status ${response.status}`;
+    let code = "";
+    try {
+      const body = await response.json();
+      if (body.error?.message) message = body.error.message;
+      if (body.error?.code) code = body.error.code;
+    } catch {
+    }
+    if (code === "BILLING_LIMIT_EXCEEDED" || code === "SYNC_LIMIT_EXCEEDED" || code === "BILLING_SUBSCRIPTION_INACTIVE") {
+      throw new Error(`${message} Visit ${BILLING_URL} to manage your plan.`);
+    }
+    throw new Error(message);
+  }
+  const json = await response.json();
+  return json.data;
+}
+
+// src/lib/prompts.ts
+import { checkbox, confirm } from "@inquirer/prompts";
+import chalk3 from "chalk";
+async function selectAiTools() {
+  const choices = [
+    { name: "Cursor", value: "cursor" },
+    { name: "Claude Code", value: "claude-code" },
+    { name: "GitHub Copilot", value: "copilot" },
+    { name: "Windsurf", value: "windsurf" },
+    { name: "Cline", value: "cline" },
+    { name: "Codex", value: "codex" },
+    { name: "Roo Code", value: "roo-code" },
+    { name: "Other (manual setup)", value: "other" }
+  ];
+  while (true) {
+    const selected = await checkbox({
+      message: chalk3.bold("Which AI tools do you use?") + chalk3.dim("  (Space to select, Enter to continue)"),
+      choices
+    });
+    if (selected.length === 0) {
+      const goBack = await confirm({
+        message: "No tools selected. Go back and choose?",
+        default: true
+      });
+      if (goBack) continue;
+    }
+    const hasOther = selected.includes("other");
+    const tools = selected.filter((s) => s !== "other");
+    return { tools, hasOther };
+  }
+}
+
+// src/lib/ai-tools.ts
+import { readFile as readFile7, writeFile as writeFile10, mkdir as mkdir10, readdir } from "fs/promises";
+import { join as join15, dirname as dirname3 } from "path";
+var AI_TOOL_CONFIG = {
+  cursor: {
+    label: "Cursor",
+    fileName: ".cursorrules",
+    filePath: ".cursorrules",
+    markerStart: "# --- repowise-start ---",
+    markerEnd: "# --- repowise-end ---",
+    format: "plain-text"
+  },
+  "claude-code": {
+    label: "Claude Code",
+    fileName: "CLAUDE.md",
+    filePath: "CLAUDE.md",
+    markerStart: "<!-- repowise-start -->",
+    markerEnd: "<!-- repowise-end -->",
+    format: "markdown"
+  },
+  copilot: {
+    label: "GitHub Copilot",
+    fileName: "copilot-instructions.md",
+    filePath: ".github/copilot-instructions.md",
+    markerStart: "<!-- repowise-start -->",
+    markerEnd: "<!-- repowise-end -->",
+    format: "markdown"
+  },
+  windsurf: {
+    label: "Windsurf",
+    fileName: ".windsurfrules",
+    filePath: ".windsurfrules",
+    markerStart: "# --- repowise-start ---",
+    markerEnd: "# --- repowise-end ---",
+    format: "plain-text"
+  },
+  cline: {
+    label: "Cline",
+    fileName: ".clinerules",
+    filePath: ".clinerules",
+    markerStart: "# --- repowise-start ---",
+    markerEnd: "# --- repowise-end ---",
+    format: "plain-text"
+  },
+  codex: {
+    label: "Codex",
+    fileName: "AGENTS.md",
+    filePath: "AGENTS.md",
+    markerStart: "<!-- repowise-start -->",
+    markerEnd: "<!-- repowise-end -->",
+    format: "markdown"
+  },
+  "roo-code": {
+    label: "Roo Code",
+    fileName: "rules.md",
+    filePath: ".roo/rules.md",
+    markerStart: "<!-- repowise-start -->",
+    markerEnd: "<!-- repowise-end -->",
+    format: "markdown"
+  }
+};
+var SUPPORTED_TOOLS = Object.keys(AI_TOOL_CONFIG);
+function sanitizeRepoName(name) {
+  return name.replace(/[<>[\]`()|\\]/g, "");
+}
+function fileDescriptionFromName(fileName) {
+  return fileName.replace(/\.md$/, "").split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function generateReference(tool, repoName, contextFolder, contextFiles) {
+  const config2 = AI_TOOL_CONFIG[tool];
+  const safeName = sanitizeRepoName(repoName);
+  const fileLines = contextFiles.map((f) => {
+    const baseName = f.fileName.split("/").pop() ?? f.fileName;
+    const desc = fileDescriptionFromName(baseName);
+    const isOverview = baseName === "project-overview.md";
+    return { path: f.relativePath, desc: isOverview ? `${desc} (full index of all files)` : desc };
+  });
+  const hasFiles = fileLines.length > 0;
+  if (config2.format === "markdown") {
+    const lines2 = [
+      config2.markerStart,
+      "",
+      `## Project Context \u2014 ${safeName}`,
+      "",
+      `This repository has AI-optimized context files generated by RepoWise.`,
+      `**IMPORTANT: Before answering questions about the codebase or making any changes, ALWAYS check the \`${contextFolder}/\` folder first.** These files contain pre-analyzed architecture, patterns, API contracts, and domain knowledge that will answer most questions without needing to search the codebase.`,
+      "",
+      `**Start here:** \`${contextFolder}/project-overview.md\` \u2014 the routing document that maps every context file to its domain. Read it first to find which context file has the answer you need.`,
+      ""
+    ];
+    if (hasFiles) {
+      lines2.push(
+        `**Core context files:**`,
+        "",
+        ...fileLines.map((f) => `- \`${f.path}\` \u2014 ${f.desc}`),
+        "",
+        `> Additional context files may exist beyond this list. Check \`project-overview.md\` for the complete index.`
+      );
+    }
+    lines2.push("", config2.markerEnd);
+    return lines2.join("\n");
+  }
+  const lines = [
+    config2.markerStart,
+    `# Project Context \u2014 ${safeName}`,
+    "#",
+    `# This repository has AI-optimized context files generated by RepoWise.`,
+    `# IMPORTANT: Before answering questions about the codebase or making any changes,`,
+    `# ALWAYS check the ${contextFolder}/ folder first. These files contain pre-analyzed`,
+    `# architecture, patterns, API contracts, and domain knowledge that will answer`,
+    `# most questions without needing to search the codebase.`,
+    "#",
+    `# Start here: ${contextFolder}/project-overview.md`,
+    `#   The routing document that maps every context file to its domain.`,
+    `#   Read it first to find which context file has the answer you need.`
+  ];
+  if (hasFiles) {
+    lines.push(
+      "#",
+      `# Core context files:`,
+      ...fileLines.map((f) => `#   ${f.path} \u2014 ${f.desc}`),
+      "#",
+      "# Additional context files may exist beyond this list.",
+      "# Check project-overview.md for the complete index."
+    );
+  }
+  lines.push(config2.markerEnd);
+  return lines.join("\n");
+}
+async function updateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles) {
+  const config2 = AI_TOOL_CONFIG[tool];
+  const fullPath = join15(repoRoot, config2.filePath);
+  const dir = dirname3(fullPath);
+  if (dir !== repoRoot) {
+    await mkdir10(dir, { recursive: true });
+  }
+  const referenceBlock = generateReference(tool, repoName, contextFolder, contextFiles);
+  let existing = "";
+  let created = true;
+  try {
+    existing = await readFile7(fullPath, "utf-8");
+    created = false;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const startIdx = existing.indexOf(config2.markerStart);
+  const endIdx = existing.indexOf(config2.markerEnd);
+  let content;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + config2.markerEnd.length);
+    content = before + referenceBlock + after;
+  } else {
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n\n" : existing.length > 0 ? "\n" : "";
+    content = existing + separator + referenceBlock + "\n";
+  }
+  await writeFile10(fullPath, content, "utf-8");
+  return { created };
+}
+async function scanLocalContextFiles(repoRoot, contextFolder) {
+  const folderPath = join15(repoRoot, contextFolder);
+  try {
+    const entries = await readdir(folderPath, { withFileTypes: true, recursive: true });
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const parentDir = entry.parentPath ?? folderPath;
+      const fullPath = join15(parentDir, entry.name);
+      const relFromContext = fullPath.slice(folderPath.length + 1);
+      results.push({
+        fileName: relFromContext,
+        relativePath: `${contextFolder}/${relFromContext}`
+      });
+    }
+    return results.sort((a, b) => a.fileName.localeCompare(b.fileName));
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/lib/gitignore.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join as join16 } from "path";
+function ensureGitignore(repoRoot, entry) {
+  const gitignorePath = join16(repoRoot, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    const lines = content.split("\n").map((l) => l.trim());
+    if (lines.includes(entry) || lines.includes(entry + "/")) {
+      return;
+    }
+    const separator = content.endsWith("\n") ? "" : "\n";
+    writeFileSync(gitignorePath, content + separator + entry + "\n", "utf-8");
+  } else {
+    writeFileSync(gitignorePath, entry + "\n", "utf-8");
+  }
+}
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function detectRepoRoot() {
+  return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+}
+function detectRepoName(repoRoot) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      cwd: repoRoot
+    }).trim();
+    const match = remoteUrl.match(/\/([^/]+?)(?:\.git)?$/);
+    if (match?.[1]) return match[1];
+  } catch {
+  }
+  return repoRoot.split("/").pop() ?? "unknown";
+}
+
+// src/lib/interview-handler.ts
+import chalk4 from "chalk";
+import { input } from "@inquirer/prompts";
+var INTERVIEW_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_QUESTIONS = 10;
+var questionCounter = 0;
+async function handleInterview(syncId, questionId, questionText, questionContext, estimatedQuestions) {
+  questionCounter++;
+  if (questionCounter === 1) {
+    console.log("");
+    console.log(chalk4.cyan.bold("  \u2500\u2500 Interview \u2500\u2500"));
+    console.log(chalk4.dim("  Help us understand your project better. Answer a few short"));
+    console.log(
+      chalk4.dim(
+        `  questions so we can generate more relevant context files (up to ${MAX_QUESTIONS}).`
+      )
+    );
+  }
+  const total = Math.min(estimatedQuestions ?? MAX_QUESTIONS, MAX_QUESTIONS);
+  console.log("");
+  console.log(chalk4.cyan.bold(`  Question ${questionCounter}/${total}`));
+  if (questionContext) {
+    console.log(chalk4.dim(`  ${questionContext}`));
+  }
+  console.log(`  ${questionText}`);
+  console.log(chalk4.dim('  (Enter to skip \xB7 "done" to finish early)'));
+  let answer;
+  try {
+    answer = await Promise.race([
+      input({
+        message: chalk4.cyan(">"),
+        theme: { prefix: "  " }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("INTERVIEW_TIMEOUT")), INTERVIEW_TIMEOUT_MS)
+      )
+    ]);
+  } catch (err) {
+    if (err instanceof Error && err.message === "INTERVIEW_TIMEOUT") {
+      console.log(chalk4.yellow("  Timed out \u2014 auto-skipping this question."));
+      answer = "skip";
+    } else {
+      throw err;
+    }
+  }
+  const trimmed = answer.trim();
+  let action;
+  let answerText = "";
+  if (trimmed.toLowerCase() === "done") {
+    action = "done";
+  } else if (trimmed === "" || trimmed.toLowerCase() === "skip") {
+    action = "skip";
+  } else {
+    action = "answer";
+    answerText = trimmed;
+  }
+  if (questionCounter >= MAX_QUESTIONS && action !== "done") {
+    action = "done";
+    console.log(chalk4.green("  Thanks for your answers! Wrapping up the interview."));
+  }
+  try {
+    await apiRequest(`/v1/sync/${syncId}/answer`, {
+      method: "POST",
+      body: JSON.stringify({ questionId, answerText, action })
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("not awaiting input") || message.includes("expired")) {
+      console.log(chalk4.dim("  Pipeline has already moved on \u2014 continuing."));
+      return;
+    }
+    try {
+      await new Promise((r) => setTimeout(r, 1e3));
+      await apiRequest(`/v1/sync/${syncId}/answer`, {
+        method: "POST",
+        body: JSON.stringify({ questionId, answerText, action })
+      });
+    } catch {
+      console.log(chalk4.yellow("  Could not submit answer \u2014 pipeline will continue."));
+      return;
+    }
+  }
+  if (action === "done") {
+    console.log(chalk4.dim("  Interview ended early."));
+  } else if (action === "skip") {
+    console.log(chalk4.dim("  Skipped."));
+  } else {
+    console.log(chalk4.dim("  Answer recorded."));
+  }
+  console.log("");
+}
+
+// src/lib/progress-renderer.ts
+import chalk5 from "chalk";
+var CORE_FILES = /* @__PURE__ */ new Set([
+  "project-overview.md",
+  "architecture.md",
+  "data-models.md",
+  "api-contracts.md",
+  "coding-patterns.md"
+]);
+var ALL_PERSONAS = ["pm", "architect", "dev", "analyst", "tea", "ux", "sm", "techWriter"];
+var PERSONA_LABELS = {
+  pm: "Product Manager",
+  architect: "Architect",
+  dev: "Developer",
+  analyst: "Business Analyst",
+  tea: "Test Architect",
+  ux: "UX Designer",
+  sm: "Scrum Master",
+  techWriter: "Tech Writer"
+};
+function computeOverallProgress(syncResult) {
+  const stepNumber = syncResult.stepNumber ?? 1;
+  const totalSteps = syncResult.totalSteps ?? 7;
+  const stepPct = syncResult.progressPercentage ?? 0;
+  return Math.min(100, Math.round(((stepNumber - 1) * 100 + stepPct) / totalSteps));
+}
+var ProgressRenderer = class {
+  privacyShieldShown = false;
+  discoveryShown = false;
+  scanHeaderShown = false;
+  scanSummaryShown = false;
+  generationHeaderShown = false;
+  coreSubtitleShown = false;
+  coreCompleteShown = false;
+  tailoredSubtitleShown = false;
+  tailoredCompleteShown = false;
+  validationHeaderShown = false;
+  validationShown = false;
+  pushShown = false;
+  renderPrivacyShield(enabled, spinner) {
+    if (this.privacyShieldShown) return;
+    this.privacyShieldShown = true;
+    spinner.stop();
+    console.log("");
+    console.log(chalk5.cyan.bold("  \u2500\u2500 Privacy Shield \u2500\u2500"));
+    if (enabled) {
+      console.log(`  ${chalk5.green("\u2713")} Privacy Shield active`);
+      console.log(`  ${chalk5.green("\u2713")} Private connection established`);
+    } else {
+      console.log(`  ${chalk5.yellow("\u2139")} Privacy Shield not in current plan`);
+      console.log(chalk5.dim("    Shield your data from the open internet."));
+    }
+    console.log("");
+    spinner.start();
+  }
+  renderDiscovery(result, spinner) {
+    if (this.discoveryShown) return;
+    this.discoveryShown = true;
+    spinner.stop();
+    console.log("");
+    console.log(chalk5.cyan.bold("  \u2500\u2500 Repository Discovery \u2500\u2500"));
+    if (result.languages.length > 0) {
+      const langs = result.languages.slice(0, 5).map((l) => `${l.name} (${Math.round(l.percentage)}%)`).join(", ");
+      console.log(`  ${chalk5.dim("Languages:")} ${langs}`);
+    }
+    if (result.frameworks.length > 0) {
+      console.log(
+        `  ${chalk5.dim("Frameworks:")} ${result.frameworks.map((f) => f.name).join(", ")}`
+      );
+    }
+    console.log(
+      `  ${chalk5.dim("Structure:")} ${result.structureType} ${chalk5.dim(`(${result.fileCount} files)`)}`
+    );
+    if (result.existingDocs.length > 0) {
+      console.log(`  ${chalk5.dim("Existing docs:")} ${result.existingDocs.join(", ")}`);
+    }
+    if (result.fileTree && result.fileTree.length > 0) {
+      this.renderTree(result.fileTree);
+    }
+    console.log("");
+    spinner.start();
+  }
+  renderTree(entries) {
+    console.log("");
+    console.log(chalk5.cyan.bold("  \u2500\u2500 Project Structure \u2500\u2500"));
+    const root = { name: "", type: "tree", children: /* @__PURE__ */ new Map() };
+    for (const entry of entries) {
+      const parts = entry.path.split("/");
+      let current = root;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!current.children.has(part)) {
+          const isLast = i === parts.length - 1;
+          current.children.set(part, {
+            name: part,
+            type: isLast ? entry.type : "tree",
+            children: /* @__PURE__ */ new Map()
+          });
+        }
+        current = current.children.get(part);
+      }
+    }
+    const printNode = (node, prefix, isLast) => {
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const display = node.type === "tree" ? chalk5.bold.dim(`${node.name}/`) : node.name;
+      console.log(`  ${prefix}${connector}${display}`);
+      const sorted = [...node.children.values()].sort((a, b) => {
+        if (a.type === "tree" && b.type !== "tree") return -1;
+        if (a.type !== "tree" && b.type === "tree") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      sorted.forEach((child, idx) => {
+        printNode(child, childPrefix, idx === sorted.length - 1);
+      });
+    };
+    const topLevel = [...root.children.values()].sort((a, b) => {
+      if (a.type === "tree" && b.type !== "tree") return -1;
+      if (a.type !== "tree" && b.type === "tree") return 1;
+      return a.name.localeCompare(b.name);
+    });
+    topLevel.forEach((child, idx) => {
+      printNode(child, "", idx === topLevel.length - 1);
+    });
+  }
+  renderScanProgress(progress, spinner) {
+    if (!this.scanHeaderShown) {
+      this.scanHeaderShown = true;
+      spinner.stop();
+      console.log("");
+      console.log(chalk5.cyan.bold("  \u2500\u2500 Code Analysis \u2500\u2500"));
+      console.log(chalk5.dim("  Analyzing your codebase structure, functions, and relationships."));
+      spinner.start();
+    }
+    if (progress.summary && !this.scanSummaryShown) {
+      this.scanSummaryShown = true;
+      const s = progress.summary;
+      spinner.stop();
+      console.log(
+        `  ${chalk5.green("\u2713")} ${s.totalFiles} files, ${s.totalFunctions} functions, ${s.totalClasses} classes, ${s.totalEndpoints} entry points`
+      );
+      console.log("");
+      spinner.start();
+    }
+  }
+  renderFileStatuses(fileStatuses, spinner) {
+    if (!this.generationHeaderShown) {
+      this.generationHeaderShown = true;
+      spinner.stop();
+      console.log(chalk5.cyan.bold("  \u2500\u2500 Context Generation \u2500\u2500"));
+      console.log(
+        chalk5.cyan(
+          "  \u2615 This takes a few minutes \u2014 grab a coffee, we'll handle the rest!"
+        )
+      );
+      console.log("");
+      spinner.start();
+    }
+    const coreFiles = [];
+    const tailoredFiles = [];
+    for (const file of fileStatuses) {
+      const baseName = file.fileName.split("/").pop() ?? file.fileName;
+      if (CORE_FILES.has(baseName)) {
+        coreFiles.push(file);
+      } else {
+        tailoredFiles.push(file);
+      }
+    }
+    const coreCompleted = coreFiles.filter((f) => f.status === "completed").length;
+    const coreTotal = coreFiles.length;
+    const coreAllDone = coreCompleted === coreTotal && coreTotal > 0;
+    if (coreTotal > 0 && !this.coreSubtitleShown) {
+      this.coreSubtitleShown = true;
+      spinner.stop();
+      console.log(chalk5.dim("  Generating core context files:"));
+      spinner.start();
+    }
+    if (coreAllDone && !this.coreCompleteShown) {
+      this.coreCompleteShown = true;
+      spinner.stop();
+      console.log(`  Core ${chalk5.green("\u2713")} ${coreCompleted}/${coreTotal} completed`);
+      console.log("");
+      spinner.start();
+    }
+    const tailoredCompleted = tailoredFiles.filter((f) => f.status === "completed").length;
+    const tailoredTotal = tailoredFiles.length;
+    const tailoredAllDone = tailoredCompleted === tailoredTotal && tailoredTotal > 0;
+    if (tailoredTotal > 0 && coreAllDone && !this.tailoredSubtitleShown) {
+      this.tailoredSubtitleShown = true;
+      spinner.stop();
+      console.log(chalk5.dim("  Generating tailored context files:"));
+      spinner.start();
+    }
+    if (tailoredAllDone && !this.tailoredCompleteShown) {
+      this.tailoredCompleteShown = true;
+      spinner.stop();
+      console.log(
+        `  Tailored ${chalk5.green("\u2713")} ${tailoredCompleted}/${tailoredTotal} completed`
+      );
+      console.log("");
+      spinner.start();
+    }
+  }
+  renderValidation(progress, spinner) {
+    const isComplete = progress.status === "complete";
+    if (isComplete && this.validationShown) return;
+    if (!this.validationHeaderShown) {
+      this.validationHeaderShown = true;
+      spinner.stop();
+      console.log(chalk5.cyan.bold("  \u2500\u2500 Context Validation \u2500\u2500"));
+      console.log(
+        chalk5.dim(
+          `  ${ALL_PERSONAS.length} AI reviewers checking context quality \u2014 issues are auto-fixed.`
+        )
+      );
+      spinner.start();
+    }
+    if (isComplete) {
+      this.validationShown = true;
+      spinner.stop();
+      const passCount = progress.personaResults.filter((r) => r.score === "PASS").length;
+      const roundInfo = progress.round > 1 ? ` (${progress.round} rounds)` : "";
+      console.log(
+        `  ${chalk5.green("\u2713")} ${passCount}/${ALL_PERSONAS.length} PASS${roundInfo}`
+      );
+      const resultMap = new Map(progress.personaResults.map((r) => [r.persona, r.score]));
+      for (const persona of ALL_PERSONAS) {
+        const label = PERSONA_LABELS[persona] ?? persona;
+        const score = resultMap.get(persona);
+        if (score) {
+          const icon = score === "PASS" ? chalk5.green("\u2713") : chalk5.red("\u2717");
+          const scoreColor = score === "PASS" ? chalk5.green : score === "PARTIAL" ? chalk5.yellow : chalk5.red;
+          console.log(`  ${icon} ${label}: ${scoreColor(score)}`);
+        }
+      }
+      if (passCount < ALL_PERSONAS.length) {
+        console.log(chalk5.yellow("  \u26A0 Continuing with best-effort context"));
+      }
+      console.log("");
+      spinner.start();
+    }
+  }
+  renderPush(spinner) {
+    if (this.pushShown) return;
+    this.pushShown = true;
+    spinner.stop();
+    console.log(chalk5.cyan.bold("  \u2500\u2500 Saving Context \u2500\u2500"));
+    console.log(`  ${chalk5.dim("Encrypting and saving context files to RepoWise servers...")}`);
+    console.log("");
+    spinner.start();
+  }
+  /** No-op kept for backward compat with create.ts/sync.ts finalize() calls */
+  finalize() {
+  }
+  getSpinnerText(syncResult) {
+    const overallPct = computeOverallProgress(syncResult);
+    const stepLabel = syncResult.stepLabel ?? syncResult.currentStep ?? "Processing";
+    if (syncResult.scanProgress && !syncResult.scanProgress.summary) {
+      const sp = syncResult.scanProgress;
+      const pct = sp.totalBatches > 0 ? Math.round(sp.currentBatch / sp.totalBatches * 100) : 0;
+      return `Scanning batch ${sp.currentBatch}/${sp.totalBatches} ${chalk5.dim(`(${pct}%)`)}`;
+    }
+    if (syncResult.validationProgress && syncResult.validationProgress.status !== "complete") {
+      const vp = syncResult.validationProgress;
+      const passCount = vp.personaResults.filter((r) => r.score === "PASS").length;
+      if (vp.status === "regenerating") {
+        return `Improving files based on feedback (round ${vp.round}) ${chalk5.dim(`(${overallPct}%)`)}`;
+      }
+      if (vp.personaResults.length > 0) {
+        return `Round ${vp.round}/${vp.maxRounds}: ${passCount}/${ALL_PERSONAS.length} passed ${chalk5.dim(`(${overallPct}%)`)}`;
+      }
+      return `Round ${vp.round}/${vp.maxRounds}: validating... ${chalk5.dim(`(${overallPct}%)`)}`;
+    }
+    if (syncResult.generationProgress) {
+      const gp = syncResult.generationProgress;
+      if (gp.fileStatuses && gp.fileStatuses.length > 0) {
+        const generating = gp.fileStatuses.find((f) => f.status === "generating");
+        if (generating) {
+          const genBaseName = generating.fileName.split("/").pop() ?? generating.fileName;
+          const isCore = CORE_FILES.has(genBaseName);
+          const sectionFiles = gp.fileStatuses.filter((f) => {
+            const bn = f.fileName.split("/").pop() ?? f.fileName;
+            return isCore ? CORE_FILES.has(bn) : !CORE_FILES.has(bn);
+          });
+          const sectionCompleted = sectionFiles.filter((f) => f.status === "completed").length;
+          return `${generating.fileName} (${sectionCompleted}/${sectionFiles.length}) ${chalk5.dim(`(${overallPct}%)`)}`;
+        }
+        const allDone = gp.fileStatuses.every((f) => f.status === "completed");
+        if (allDone) {
+          return `${stepLabel}... ${chalk5.dim(`(${overallPct}%)`)}`;
+        }
+      }
+    }
+    return `${stepLabel}... ${chalk5.dim(`(${overallPct}%)`)}`;
+  }
+  update(syncResult, spinner) {
+    if (syncResult.privacyShieldEnabled !== void 0) {
+      this.renderPrivacyShield(syncResult.privacyShieldEnabled, spinner);
+    }
+    if (syncResult.discoveryResult) {
+      this.renderDiscovery(syncResult.discoveryResult, spinner);
+    }
+    if (syncResult.scanProgress) {
+      this.renderScanProgress(syncResult.scanProgress, spinner);
+    }
+    if (syncResult.generationProgress?.fileStatuses && syncResult.generationProgress.fileStatuses.length > 0) {
+      this.renderFileStatuses(syncResult.generationProgress.fileStatuses, spinner);
+    }
+    if (syncResult.validationProgress) {
+      this.renderValidation(syncResult.validationProgress, spinner);
+    }
+    if (syncResult.currentStep === "push-context") {
+      this.renderPush(spinner);
+    }
+    spinner.text = this.getSpinnerText(syncResult);
+  }
+};
+
+// src/commands/create.ts
+function formatElapsed(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) return `${seconds}s`;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+var POLL_INTERVAL_MS = 3e3;
+var MAX_POLL_ATTEMPTS = 7200;
+var DEFAULT_CONTEXT_FOLDER = "repowise-context";
+async function create() {
+  const startTime = Date.now();
+  const spinner = ora("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk6.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk6.green(`Authenticated as ${chalk6.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoId;
+    let repoName;
+    let repoRoot;
+    let repoPlatform;
+    let repoExternalId;
+    spinner.start("Checking for pending repository...");
+    try {
+      const pending = await apiRequest("/v1/onboarding/pending");
+      if (pending?.repoId) {
+        repoId = pending.repoId;
+        repoName = pending.repoName;
+        spinner.succeed(`Found pending repository: ${chalk6.bold(repoName)}`);
+        apiRequest("/v1/onboarding/pending", { method: "DELETE" }).catch(() => {
+        });
+      }
+    } catch {
+    }
+    if (!repoId) {
+      spinner.text = "Detecting repository...";
+      try {
+        repoRoot = detectRepoRoot();
+        repoName = detectRepoName(repoRoot);
+        spinner.succeed(`Repository: ${chalk6.bold(repoName)}`);
+      } catch {
+        spinner.fail(
+          chalk6.red(
+            "Not in a git repository. Run this command from your repo directory, or select a repo on the dashboard first."
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        const repos = await apiRequest("/v1/repos");
+        const match = repos.find((r) => r.name === repoName || r.fullName.endsWith(`/${repoName}`));
+        if (match) {
+          repoId = match.repoId;
+          repoPlatform = match.platform;
+          repoExternalId = match.externalId;
+        }
+      } catch {
+      }
+    } else {
+      try {
+        repoRoot = detectRepoRoot();
+      } catch {
+      }
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk6.red(
+          "Could not find this repository in your RepoWise account. Connect it on the dashboard first."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let useFreeRescan = false;
+    try {
+      const pricing = await apiRequest(`/v1/repos/${repoId}/rescan-pricing`);
+      if (pricing.lastFullScanAt) {
+        if (pricing.allowed && pricing.isFree) {
+          spinner.succeed(chalk6.cyan("Free rescan available. Will trigger a full rescan."));
+          useFreeRescan = true;
+        } else {
+          spinner.fail(chalk6.red("This repository already has context generated."));
+          console.log(
+            chalk6.cyan(
+              `
+  If you're a team member, run: ${chalk6.bold("repowise member")}
+  This will download context and configure your AI tools.
+`
+            )
+          );
+          console.log(
+            chalk6.dim(
+              `  To trigger a new full scan, visit: https://app.repowise.ai/repos/${repoId}
+  To sync recent changes, use: repowise sync
+`
+            )
+          );
+          process.exitCode = 1;
+          return;
+        }
+      }
+    } catch {
+    }
+    const { tools, hasOther } = await selectAiTools();
+    if (hasOther) {
+      console.log(
+        chalk6.cyan(
+          "\nFor AI tools not listed, context files still work with any tool that reads the filesystem.\nRequest support for your tool at: https://dashboard.repowise.ai/support/ai-tools"
+        )
+      );
+    }
+    if (tools.length === 0 && !hasOther) {
+      console.log(
+        chalk6.yellow(
+          "\nNo AI tools selected. You can configure them later with `repowise config`."
+        )
+      );
+    }
+    const contextStorage = "server";
+    spinner.start("Starting context generation pipeline...");
+    let syncId;
+    try {
+      const endpoint = useFreeRescan ? `/v1/repos/${repoId}/full-rescan` : `/v1/repos/${repoId}/sync`;
+      const triggerResult = await apiRequest(endpoint, {
+        method: "POST",
+        body: useFreeRescan ? void 0 : JSON.stringify({ scanType: "full", contextStorage })
+      });
+      syncId = triggerResult.syncId;
+    } catch (triggerErr) {
+      const msg = triggerErr instanceof Error ? triggerErr.message : "";
+      if (!msg.toLowerCase().includes("already running") && !msg.toLowerCase().includes("already in progress")) {
+        throw triggerErr;
+      }
+      spinner.text = "Resuming existing pipeline...";
+      const syncs = await apiRequest(
+        `/v1/repos/${repoId}/syncs?limit=10`
+      );
+      const active = syncs.items.find(
+        (s) => s.status === "in_progress" || s.status === "awaiting_input"
+      );
+      if (!active) {
+        spinner.text = "Retrying...";
+        const endpoint = useFreeRescan ? `/v1/repos/${repoId}/full-rescan` : `/v1/repos/${repoId}/sync`;
+        const retryResult = await apiRequest(endpoint, {
+          method: "POST",
+          body: useFreeRescan ? void 0 : JSON.stringify({ scanType: "full", contextStorage })
+        });
+        syncId = retryResult.syncId;
+      } else {
+        syncId = active.syncId;
+        spinner.info(chalk6.cyan("Resuming existing pipeline..."));
+        spinner.start();
+      }
+    }
+    let pollAttempts = 0;
+    let pollErrors = 0;
+    const MAX_POLL_ERRORS = 5;
+    const progressRenderer = new ProgressRenderer();
+    while (true) {
+      if (++pollAttempts > MAX_POLL_ATTEMPTS) {
+        spinner.fail(chalk6.red("Pipeline timed out. Check dashboard for status."));
+        process.exitCode = 1;
+        return;
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      let syncResult;
+      try {
+        syncResult = await apiRequest(`/v1/sync/${syncId}/status`);
+        pollErrors = 0;
+      } catch (pollErr) {
+        pollErrors++;
+        if (pollErrors >= MAX_POLL_ERRORS) {
+          throw pollErr;
+        }
+        continue;
+      }
+      progressRenderer.update(syncResult, spinner);
+      if (syncResult.status === "awaiting_input" && syncResult.questionId && syncResult.questionText) {
+        spinner.stop();
+        await handleInterview(
+          syncId,
+          syncResult.questionId,
+          syncResult.questionText,
+          syncResult.questionContext ?? void 0,
+          syncResult.discoveryResult?.estimatedInterviewQuestions
+        );
+        spinner.start("Resuming pipeline...");
+        continue;
+      }
+      if (syncResult.status === "completed") {
+        progressRenderer.finalize();
+        const generatedFiles = syncResult.filesGenerated ?? [];
+        const fileCount = generatedFiles.length;
+        if (fileCount > 0) {
+          const coreCount = generatedFiles.filter(
+            (f) => CORE_FILES.has(f.split("/").pop() ?? f)
+          ).length;
+          const tailoredCount = fileCount - coreCount;
+          spinner.succeed(
+            `Context generation complete \u2014 ${coreCount} core + ${tailoredCount} tailored files`
+          );
+        } else {
+          spinner.warn(chalk6.yellow("Pipeline completed but no context files were generated."));
+          console.log(
+            chalk6.yellow(
+              "  This may be due to AI throttling or a parsing issue. Try running `repowise create` again."
+            )
+          );
+        }
+        break;
+      }
+      if (syncResult.status === "failed") {
+        progressRenderer.finalize();
+        spinner.fail(chalk6.red(`Pipeline failed: ${syncResult.error ?? "Unknown error"}`));
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (repoRoot) {
+      spinner.start("Downloading context files from server...");
+      try {
+        const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
+        const files = listResult.data?.files ?? listResult.files ?? [];
+        if (files.length > 0) {
+          const contextDir = join17(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          mkdirSync(contextDir, { recursive: true });
+          let downloadedCount = 0;
+          let failedCount = 0;
+          for (const file of files) {
+            if (file.fileName.includes("..")) {
+              failedCount++;
+              continue;
+            }
+            const urlResult = await apiRequest(`/v1/repos/${repoId}/context/files/${file.fileName}`);
+            const presignedUrl = urlResult.data?.url ?? urlResult.url;
+            const response = await fetch(presignedUrl);
+            if (response.ok) {
+              const content = await response.text();
+              const filePath = join17(contextDir, file.fileName);
+              mkdirSync(dirname4(filePath), { recursive: true });
+              writeFileSync2(filePath, content, "utf-8");
+              downloadedCount++;
+            } else {
+              failedCount++;
+            }
+          }
+          if (failedCount > 0) {
+            spinner.warn(
+              `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER}/ (${failedCount} failed)`
+            );
+          } else {
+            spinner.succeed(`Context files downloaded to ./${DEFAULT_CONTEXT_FOLDER}/`);
+          }
+          try {
+            ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          } catch {
+          }
+        } else {
+          spinner.warn("No context files found on server");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        spinner.warn(
+          chalk6.yellow(
+            `Cannot reach RepoWise servers to download context: ${msg}
+Files are stored on our servers (not in git). Retry when online.`
+          )
+        );
+      }
+    }
+    const contextFolder = DEFAULT_CONTEXT_FOLDER;
+    let contextFiles = [];
+    if (repoRoot) {
+      contextFiles = await scanLocalContextFiles(repoRoot, contextFolder);
+    }
+    if (contextFiles.length === 0) {
+      console.log(
+        chalk6.yellow(
+          `  No context files found in ${contextFolder}/. Try re-running \`repowise create\`.`
+        )
+      );
+    }
+    if (tools.length > 0 && repoRoot) {
+      spinner.start("Configuring AI tools...");
+      const results = [];
+      for (const tool of tools) {
+        const { created: wasCreated } = await updateToolConfig(
+          repoRoot,
+          tool,
+          repoName,
+          contextFolder,
+          contextFiles
+        );
+        const config2 = AI_TOOL_CONFIG[tool];
+        const action = wasCreated ? "Created" : "Updated";
+        results.push(`  ${action} ${config2.filePath}`);
+      }
+      spinner.succeed("AI tools configured");
+      console.log(chalk6.dim(results.join("\n")));
+    }
+    const updatedRepos = [];
+    if (repoRoot) {
+      const repoEntry = {
+        repoId,
+        localPath: repoRoot,
+        apiUrl: getEnvConfig().apiUrl
+      };
+      if (repoPlatform) repoEntry.platform = repoPlatform;
+      if (repoExternalId) repoEntry.externalId = repoExternalId;
+      updatedRepos.push(repoEntry);
+    }
+    const configUpdate = { aiTools: tools, contextFolder };
+    if (updatedRepos.length > 0) configUpdate.repos = updatedRepos;
+    await mergeAndSaveConfig(configUpdate);
+    let listenerRunning = false;
+    try {
+      await install();
+      listenerRunning = true;
+    } catch {
+      try {
+        await startBackground();
+        listenerRunning = true;
+      } catch {
+      }
+    }
+    if (!listenerRunning) {
+      console.log(
+        chalk6.yellow(
+          "Warning: Could not start listener automatically. Run the following to enable it:"
+        )
+      );
+      console.log(chalk6.yellow(`  $ repowise listen --install`));
+    }
+    const elapsed = formatElapsed(Date.now() - startTime);
+    console.log("");
+    console.log(chalk6.green.bold("  All done! Setup complete!"));
+    console.log(
+      chalk6.green(
+        `  Your AI tools now have access to project context for ${chalk6.bold(repoName)}.`
+      )
+    );
+    if (listenerRunning) {
+      console.log("");
+      console.log(chalk6.cyan("  The RepoWise listener is running in the background \u2014"));
+      console.log(chalk6.cyan("  your context will stay in sync automatically."));
+      console.log(chalk6.cyan("  Go back to coding, we've got it from here!"));
+    }
+    console.log("");
+    console.log(
+      chalk6.cyan(
+        '  Head back to the dashboard and click "Complete Onboarding" to explore your RepoWise dashboard!'
+      )
+    );
+    console.log(chalk6.dim(`
+  Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Create failed";
+    spinner.fail(chalk6.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/member.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, join as join18 } from "path";
+import chalk7 from "chalk";
+import ora2 from "ora";
+var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
+function formatElapsed2(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) return `${seconds}s`;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+async function member() {
+  const startTime = Date.now();
+  const spinner = ora2("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk7.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk7.green(`Authenticated as ${chalk7.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoId;
+    let repoName;
+    let repoRoot;
+    let repoPlatform;
+    let repoExternalId;
+    spinner.start("Checking for pending repository...");
+    try {
+      const pending = await apiRequest("/v1/onboarding/pending");
+      if (pending?.repoId) {
+        repoId = pending.repoId;
+        repoName = pending.repoName;
+        spinner.succeed(`Found pending repository: ${chalk7.bold(repoName)}`);
+        apiRequest("/v1/onboarding/pending", { method: "DELETE" }).catch(() => {
+        });
+      }
+    } catch {
+    }
+    if (!repoId) {
+      spinner.text = "Detecting repository...";
+      try {
+        repoRoot = detectRepoRoot();
+        repoName = detectRepoName(repoRoot);
+        spinner.succeed(`Repository: ${chalk7.bold(repoName)}`);
+      } catch {
+        spinner.fail(
+          chalk7.red("Not in a git repository. Run this command from your project directory.")
+        );
+        process.exitCode = 1;
+        return;
+      }
+    } else {
+      try {
+        repoRoot = detectRepoRoot();
+        const localRepoName = detectRepoName(repoRoot);
+        if (repoName && localRepoName !== repoName && !repoName.endsWith(`/${localRepoName}`)) {
+          spinner.warn(
+            chalk7.yellow(
+              `Pending repo is ${chalk7.bold(repoName)} but you're in ${chalk7.bold(localRepoName)}.
+  Make sure you're in the right project directory, or the context files will be saved here.`
+            )
+          );
+        }
+      } catch {
+        spinner.fail(
+          chalk7.red(
+            "Please navigate to your project directory first, then run `repowise member` again."
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (!repoId || !repoPlatform) {
+      spinner.start("Looking up repository...");
+      try {
+        const repos = await apiRequest("/v1/repos");
+        const match = repos.find(
+          (r) => r.repoId === repoId || r.name === repoName || r.fullName.endsWith(`/${repoName}`)
+        );
+        if (match) {
+          repoId = match.repoId;
+          repoPlatform = match.platform;
+          repoExternalId = match.externalId;
+          if (!repoName) repoName = match.fullName;
+          spinner.succeed(`Repository: ${chalk7.bold(match.fullName)}`);
+        }
+      } catch {
+      }
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk7.red(
+          "This repository is not connected to your team. Ask your team admin to add it on the dashboard."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    spinner.start("Checking for context files...");
+    let files = [];
+    try {
+      const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
+      files = listResult.data?.files ?? listResult.files ?? [];
+    } catch {
+      spinner.fail(chalk7.red("Failed to check context files on server."));
+      process.exitCode = 1;
+      return;
+    }
+    if (files.length === 0) {
+      spinner.fail(
+        chalk7.red(
+          "No context files found for this repository. Your team admin needs to run the initial scan first."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    spinner.succeed(`Found ${chalk7.bold(files.length)} context files on server`);
+    const { tools } = await selectAiTools();
+    spinner.start("Downloading context files...");
+    const contextDir = join18(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    mkdirSync2(contextDir, { recursive: true });
+    let downloadedCount = 0;
+    let failedCount = 0;
+    for (const file of files) {
+      if (file.fileName.includes("..")) {
+        failedCount++;
+        continue;
+      }
+      try {
+        const urlResult = await apiRequest(`/v1/repos/${repoId}/context/files/${file.fileName}`);
+        const presignedUrl = urlResult.data?.url ?? urlResult.url;
+        const response = await fetch(presignedUrl);
+        if (response.ok) {
+          const content = await response.text();
+          const filePath = join18(contextDir, file.fileName);
+          mkdirSync2(dirname5(filePath), { recursive: true });
+          writeFileSync3(filePath, content, "utf-8");
+          downloadedCount++;
+        } else {
+          failedCount++;
+        }
+      } catch {
+        failedCount++;
+      }
+    }
+    if (failedCount > 0) {
+      spinner.warn(
+        `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER2}/ (${failedCount} failed)`
+      );
+    } else {
+      spinner.succeed(`Downloaded ${downloadedCount} files to ./${DEFAULT_CONTEXT_FOLDER2}/`);
+    }
+    try {
+      ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    } catch {
+    }
+    if (tools.length > 0) {
+      spinner.start("Configuring AI tools...");
+      const contextFiles = await scanLocalContextFiles(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+      const configured = [];
+      for (const tool of tools) {
+        const { created } = await updateToolConfig(
+          repoRoot,
+          tool,
+          repoName,
+          DEFAULT_CONTEXT_FOLDER2,
+          contextFiles
+        );
+        const config2 = AI_TOOL_CONFIG[tool];
+        configured.push(`${created ? "Created" : "Updated"} ${config2.filePath}`);
+      }
+      spinner.succeed("AI tools configured");
+      for (const msg of configured) {
+        console.log(chalk7.dim(`  ${msg}`));
+      }
+    }
+    spinner.start("Saving configuration...");
+    const repoEntry = {
+      repoId,
+      localPath: repoRoot,
+      apiUrl: getEnvConfig().apiUrl
+    };
+    if (repoPlatform) repoEntry.platform = repoPlatform;
+    if (repoExternalId) repoEntry.externalId = repoExternalId;
+    await mergeAndSaveConfig({
+      aiTools: tools,
+      contextFolder: DEFAULT_CONTEXT_FOLDER2,
+      repos: [repoEntry]
+    });
+    spinner.succeed("Configuration saved");
+    let listenerRunning = false;
+    try {
+      await install();
+      listenerRunning = true;
+    } catch {
+      try {
+        await startBackground();
+        listenerRunning = true;
+      } catch {
+      }
+    }
+    try {
+      await apiRequest("/v1/onboarding/complete", {
+        method: "POST",
+        body: JSON.stringify({ repoId })
+      });
+    } catch {
+    }
+    const elapsed = formatElapsed2(Date.now() - startTime);
+    console.log("");
+    console.log(chalk7.green.bold("All done! Context downloaded and configured."));
+    console.log("");
+    console.log(`Your AI tools now have access to project context for ${chalk7.bold(repoName)}.`);
+    console.log(
+      `Downloaded ${chalk7.bold(downloadedCount)} context files to ./${DEFAULT_CONTEXT_FOLDER2}/`
+    );
+    console.log("");
+    if (listenerRunning) {
+      console.log(
+        chalk7.dim(
+          "The RepoWise listener is running in the background \u2014\nyour context will stay in sync automatically."
+        )
+      );
+    } else {
+      console.log(
+        chalk7.yellow(
+          "Could not start listener automatically. Run `repowise listen --install` to enable auto-sync."
+        )
+      );
+    }
+    console.log("");
+    console.log(
+      chalk7.dim(`Head back to the dashboard and click "Complete Onboarding" to finish setup.`)
+    );
+    console.log(chalk7.dim(`Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    spinner.fail(chalk7.red(`Setup failed: ${message}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/login.ts
+import chalk8 from "chalk";
+import ora3 from "ora";
+async function login(options = {}) {
+  const spinner = ora3("Preparing login...").start();
+  try {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = generateState();
+    const authorizeUrl = getAuthorizeUrl(codeChallenge, state);
+    const callbackPromise = startCallbackServer();
+    if (options.browser === false) {
+      spinner.stop();
+      console.log(`
+Open this URL in your browser to authenticate:
+`);
+      console.log(chalk8.cyan(authorizeUrl));
+      console.log(`
+Waiting for authentication...`);
+    } else {
+      spinner.text = "Opening browser for authentication...";
+      try {
+        const open = (await import("open")).default;
+        await open(authorizeUrl);
+        spinner.text = "Waiting for authentication in browser...";
+      } catch {
+        spinner.stop();
+        console.log(`
+Could not open browser automatically. Open this URL:
+`);
+        console.log(chalk8.cyan(authorizeUrl));
+        console.log(`
+Waiting for authentication...`);
+      }
+    }
+    const { code, state: returnedState } = await callbackPromise;
+    if (returnedState !== state) {
+      throw new Error("State mismatch \u2014 possible CSRF attack. Please try again.");
+    }
+    spinner.start("Exchanging authorization code...");
+    const credentials = await exchangeCodeForTokens(code, codeVerifier);
+    credentials.cognito = getCognitoConfigForStorage();
+    await storeCredentials2(credentials);
+    const { email } = decodeIdToken(credentials.idToken);
+    spinner.succeed(chalk8.green(`Logged in as ${chalk8.bold(email)}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Login failed";
+    spinner.fail(chalk8.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/logout.ts
+import chalk9 from "chalk";
+async function logout() {
+  const creds = await getStoredCredentials2();
+  if (!creds) {
+    console.log(chalk9.yellow("Not logged in."));
+    return;
+  }
+  await clearCredentials();
+  console.log(chalk9.green("Logged out successfully."));
+}
+
+// src/commands/status.ts
+import { readFile as readFile8 } from "fs/promises";
+import { basename as basename2, join as join19 } from "path";
+async function status() {
+  const configDir = getConfigDir2();
+  const STATE_PATH = join19(configDir, "listener-state.json");
+  const CONFIG_PATH = join19(configDir, "config.json");
+  let state = null;
+  try {
+    const data = await readFile8(STATE_PATH, "utf-8");
+    state = JSON.parse(data);
+  } catch {
+  }
+  let processRunning = false;
+  let pid = null;
+  try {
+    const processStatus = await getStatus();
+    processRunning = processStatus.running;
+    pid = processStatus.pid;
+  } catch {
+  }
+  let serviceInstalled = false;
+  try {
+    serviceInstalled = await isInstalled();
+  } catch {
+  }
+  console.log("RepoWise Status");
+  console.log("===============");
+  if (processRunning) {
+    console.log(`Listener: running (PID: ${pid})`);
+  } else {
+    console.log("Listener: stopped");
+  }
+  if (serviceInstalled) {
+    console.log("Auto-start: enabled");
+  } else {
+    console.log("Auto-start: disabled");
+  }
+  console.log("");
+  if (!state || Object.keys(state.repos).length === 0) {
+    console.log("No sync history. Run `repowise listen` to start syncing.");
+    return;
+  }
+  const repoNames = /* @__PURE__ */ new Map();
+  try {
+    const configData = await readFile8(CONFIG_PATH, "utf-8");
+    const config2 = JSON.parse(configData);
+    for (const repo of config2.repos ?? []) {
+      repoNames.set(repo.repoId, basename2(repo.localPath));
+    }
+  } catch {
+  }
+  console.log("Watched Repos:");
+  for (const [repoId, repoState] of Object.entries(state.repos)) {
+    const name = repoNames.get(repoId);
+    const label = name ? `${name} (${repoId.slice(0, 8)})` : repoId;
+    const syncTime = repoState.lastSyncTimestamp ? new Date(repoState.lastSyncTimestamp).toLocaleString() : "never";
+    const commit = repoState.lastSyncCommitSha ? repoState.lastSyncCommitSha.slice(0, 7) : "none";
+    console.log(`  ${label}: last sync ${syncTime} (commit: ${commit})`);
+  }
+}
+
+// src/commands/sync.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, join as join20 } from "path";
+import chalk10 from "chalk";
+import ora4 from "ora";
+var POLL_INTERVAL_MS2 = 3e3;
+var MAX_POLL_ATTEMPTS2 = 7200;
+var DEFAULT_CONTEXT_FOLDER3 = "repowise-context";
+function formatElapsed3(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) return `${seconds}s`;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+async function sync() {
+  const startTime = Date.now();
+  const spinner = ora4("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk10.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk10.green(`Authenticated as ${chalk10.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoRoot;
+    let repoName;
+    spinner.start("Detecting repository...");
+    try {
+      repoRoot = detectRepoRoot();
+      repoName = detectRepoName(repoRoot);
+      spinner.succeed(`Repository: ${chalk10.bold(repoName)}`);
+    } catch {
+      spinner.fail(
+        chalk10.red("Not in a git repository. Run this command from your repo directory.")
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let repoId;
+    let repoPlatform;
+    let repoExternalId;
+    spinner.start("Resolving repository...");
+    try {
+      const repos = await apiRequest("/v1/repos");
+      const match = repos.find((r) => r.name === repoName || r.fullName.endsWith(`/${repoName}`));
+      if (match) {
+        repoId = match.repoId;
+        repoPlatform = match.platform;
+        repoExternalId = match.externalId;
+      }
+    } catch {
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk10.red(
+          "Could not find this repository in your RepoWise account. Run `repowise create` first."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    spinner.succeed("Repository resolved");
+    spinner.start("Triggering incremental sync...");
+    let syncId;
+    try {
+      const triggerResult = await apiRequest(`/v1/repos/${repoId}/sync`, {
+        method: "POST",
+        body: JSON.stringify({ scanType: "incremental" })
+      });
+      syncId = triggerResult.syncId;
+    } catch (triggerErr) {
+      const msg = triggerErr instanceof Error ? triggerErr.message : "";
+      if (!msg.toLowerCase().includes("already running")) {
+        throw triggerErr;
+      }
+      spinner.text = "Resuming existing sync...";
+      const syncs = await apiRequest(
+        `/v1/repos/${repoId}/syncs?limit=10`
+      );
+      const active = syncs.items.find(
+        (s) => s.status === "in_progress" || s.status === "awaiting_input"
+      );
+      if (!active) {
+        spinner.text = "Retrying...";
+        const retryResult = await apiRequest(`/v1/repos/${repoId}/sync`, {
+          method: "POST",
+          body: JSON.stringify({ scanType: "incremental" })
+        });
+        syncId = retryResult.syncId;
+      } else {
+        syncId = active.syncId;
+        spinner.info(chalk10.cyan("Resuming existing sync..."));
+        spinner.start();
+      }
+    }
+    let pollAttempts = 0;
+    const progressRenderer = new ProgressRenderer();
+    while (true) {
+      if (++pollAttempts > MAX_POLL_ATTEMPTS2) {
+        spinner.fail(chalk10.red("Sync timed out. Check dashboard for status."));
+        process.exitCode = 1;
+        return;
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
+      const syncResult = await apiRequest(`/v1/sync/${syncId}/status`);
+      progressRenderer.update(syncResult, spinner);
+      if (syncResult.status === "awaiting_input" && syncResult.questionId && syncResult.questionText) {
+        spinner.stop();
+        await handleInterview(
+          syncId,
+          syncResult.questionId,
+          syncResult.questionText,
+          syncResult.questionContext ?? void 0,
+          syncResult.discoveryResult?.estimatedInterviewQuestions
+        );
+        spinner.start("Resuming sync...");
+        continue;
+      }
+      if (syncResult.status === "completed") {
+        progressRenderer.finalize();
+        const generatedFiles = syncResult.filesGenerated ?? [];
+        const fileCount = generatedFiles.length;
+        if (fileCount > 0) {
+          spinner.succeed(chalk10.green(`Incremental update complete \u2014 ${fileCount} files updated`));
+        } else {
+          spinner.succeed(chalk10.green("Incremental sync complete \u2014 no files needed updating"));
+        }
+        break;
+      }
+      if (syncResult.status === "failed") {
+        progressRenderer.finalize();
+        spinner.fail(chalk10.red(`Sync failed: ${syncResult.error ?? "Unknown error"}`));
+        process.exitCode = 1;
+        return;
+      }
+    }
+    spinner.start("Downloading context files from server...");
+    try {
+      const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
+      const files = listResult.data?.files ?? listResult.files ?? [];
+      if (files.length > 0) {
+        const contextDir = join20(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        mkdirSync3(contextDir, { recursive: true });
+        let downloadedCount = 0;
+        let failedCount = 0;
+        for (const file of files) {
+          if (file.fileName.includes("..")) {
+            failedCount++;
+            continue;
+          }
+          const urlResult = await apiRequest(`/v1/repos/${repoId}/context/files/${file.fileName}`);
+          const presignedUrl = urlResult.data?.url ?? urlResult.url;
+          const response = await fetch(presignedUrl);
+          if (response.ok) {
+            const content = await response.text();
+            const filePath = join20(contextDir, file.fileName);
+            mkdirSync3(dirname6(filePath), { recursive: true });
+            writeFileSync4(filePath, content, "utf-8");
+            downloadedCount++;
+          } else {
+            failedCount++;
+          }
+        }
+        if (failedCount > 0) {
+          spinner.warn(
+            `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER3}/ (${failedCount} failed)`
+          );
+        } else {
+          spinner.succeed(`Context files downloaded to ./${DEFAULT_CONTEXT_FOLDER3}/`);
+        }
+        try {
+          ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        } catch {
+        }
+      } else {
+        spinner.info("No context files found on server");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      spinner.warn(chalk10.yellow(`Could not download context files: ${msg}
+Retry when online.`));
+    }
+    if (repoRoot && repoId) {
+      try {
+        const existingConfig = await getConfig();
+        const existingRepos = existingConfig.repos ?? [];
+        if (!existingRepos.some((r) => r.repoId === repoId)) {
+          const repoEntry = { repoId, localPath: repoRoot, apiUrl: getEnvConfig().apiUrl };
+          if (repoPlatform) repoEntry.platform = repoPlatform;
+          if (repoExternalId) repoEntry.externalId = repoExternalId;
+          await mergeAndSaveConfig({ repos: [repoEntry] });
+        }
+      } catch {
+      }
+      try {
+        await install();
+      } catch {
+        try {
+          await startBackground();
+        } catch {
+        }
+      }
+    }
+    const elapsed = formatElapsed3(Date.now() - startTime);
+    console.log(chalk10.dim(`
+  Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Sync failed";
+    spinner.fail(chalk10.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/listen.ts
+async function listen(options) {
+  if (options.install) {
+    try {
+      await install();
+      console.log("Auto-start service installed. The listener will start on boot.");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error(`Failed to install auto-start service: ${message}`);
+      console.error("You can still run the listener manually with `repowise listen`.");
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (options.uninstall) {
+    try {
+      await uninstall();
+      console.log("Auto-start service removed.");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error(`Failed to uninstall auto-start service: ${message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const credentials = await getValidCredentials2();
+  if (!credentials) {
+    console.error("Not logged in. Run `repowise login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  console.log("Starting RepoWise listener...");
+  try {
+    await startListener();
+  } catch {
+    console.error("Failed to start listener.");
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/start.ts
+async function start() {
+  try {
+    if (await isRunning()) {
+      console.log("Listener is already running.");
+      return;
+    }
+    try {
+      await install();
+      console.log("Listener service installed and started.");
+    } catch {
+      const pid = await startBackground();
+      console.log(`Listener started (PID: ${pid}).`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error(`Failed to start listener: ${message}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/stop.ts
+async function stop2() {
+  try {
+    if (!await isRunning()) {
+      console.log("Listener is not running.");
+      return;
+    }
+    await stopProcess();
+    try {
+      await stopService();
+    } catch {
+    }
+    console.log("Listener stopped.");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error(`Failed to stop listener: ${message}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/config.ts
+import chalk11 from "chalk";
+import ora5 from "ora";
+import { select } from "@inquirer/prompts";
+async function config() {
+  const spinner = ora5("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk11.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk11.green(`Authenticated as ${chalk11.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    spinner.start("Loading repositories...");
+    const repos = await apiRequest("/v1/repos");
+    spinner.stop();
+    if (repos.length === 0) {
+      console.log(chalk11.yellow("No repositories connected. Run `repowise create` first."));
+      return;
+    }
+    const repoId = await select({
+      message: "Select a repository to configure",
+      choices: repos.map((r) => ({
+        name: r.fullName,
+        value: r.repoId
+      }))
+    });
+    const repo = repos.find((r) => r.repoId === repoId);
+    const currentDelivery = repo.deliveryMode ?? "direct";
+    const currentBranch = repo.monitoredBranch ?? repo.defaultBranch;
+    console.log("");
+    console.log(chalk11.bold(`Settings for ${repo.fullName}`));
+    console.log(chalk11.dim(`  Context storage: RepoWise servers`));
+    console.log(chalk11.dim(`  Delivery mode:   ${currentDelivery}`));
+    console.log(chalk11.dim(`  Monitored branch: ${currentBranch}`));
+    console.log("");
+    const setting = await select({
+      message: "What would you like to change?",
+      choices: [
+        { name: `Delivery mode (current: ${currentDelivery})`, value: "deliveryMode" },
+        { name: `Monitored branch (current: ${currentBranch})`, value: "monitoredBranch" }
+      ]
+    });
+    const patch = {};
+    if (setting === "deliveryMode") {
+      const newMode = await select({
+        message: "Delivery mode",
+        choices: [
+          { name: "Direct push to branch", value: "direct" },
+          { name: "Create pull request", value: "pr" }
+        ],
+        default: currentDelivery
+      });
+      if (newMode === currentDelivery) {
+        console.log(chalk11.dim("No change."));
+        return;
+      }
+      patch.deliveryMode = newMode;
+    } else if (setting === "monitoredBranch") {
+      const { input: input2 } = await import("@inquirer/prompts");
+      const newBranch = await input2({
+        message: "Monitored branch",
+        default: currentBranch
+      });
+      if (newBranch === currentBranch) {
+        console.log(chalk11.dim("No change."));
+        return;
+      }
+      patch.monitoredBranch = newBranch;
+    }
+    spinner.start("Saving...");
+    await apiRequest(`/v1/repos/${repoId}`, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+    spinner.succeed(chalk11.green("Setting updated"));
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : "Config failed";
+    console.error(chalk11.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// bin/repowise.ts
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname = dirname7(__filename);
+var pkg = JSON.parse(readFileSync2(join21(__dirname, "..", "..", "package.json"), "utf-8"));
+var program = new Command();
+program.name(getPackageName2()).description("AI-optimized codebase context generator").version(pkg.version).hook("preAction", async () => {
+  await showWelcome(pkg.version);
+});
+program.command("create").description("Create context for a repository").action(async () => {
+  await create();
+});
+program.command("member").description("Download context and configure AI tools (for team members)").action(async () => {
+  await member();
+});
+program.command("login").description("Authenticate with RepoWise").option("--no-browser", "Print login URL instead of opening browser").action(async (options) => {
+  await login(options);
+});
+program.command("logout").description("Sign out of RepoWise").action(async () => {
+  await logout();
+});
+program.command("status").description("Show current status").action(async () => {
+  await status();
+});
+program.command("sync").description("Trigger a manual sync").action(async () => {
+  await sync();
+});
+program.command("listen").description("Start the context listener").option("--install", "Install auto-start service").option("--uninstall", "Remove auto-start service").action(async (options) => {
+  await listen(options);
+});
+program.command("start").description("Start the listener as a background process").action(async () => {
+  await start();
+});
+program.command("stop").description("Stop the running listener process").action(async () => {
+  await stop2();
+});
+program.command("config").description("Manage configuration").action(async () => {
+  await config();
+});
+if (process.argv[2] === "__listener") {
+  process.on("uncaughtException", (err) => {
+    console.error("Listener uncaught exception:", err);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("Listener unhandled rejection:", reason);
+  });
+  startListener().catch((err) => {
+    console.error("Listener fatal error:", err);
+    process.exitCode = 1;
+  });
+} else {
+  program.parse();
+}