repowise 0.1.39 → 0.1.40

package/dist/bin/repowise.js

@@ -1,97 +1,2732 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { Command } from 'commander';
-import { setStagingMode } from '../src/lib/env.js';
-import { showWelcome } from '../src/lib/welcome.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
-const program = new Command();
-program
-    .name('repowise')
-    .description('AI-optimized codebase context generator')
-    .version(pkg.version)
-    .option('--staging', 'Use the staging environment')
-    .hook('preAction', async () => {
-    if (program.opts()['staging']) {
-        setStagingMode(true);
-    }
-    await showWelcome(pkg.version);
+#!/usr/bin/env node
+
+// bin/repowise.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join15 } from "path";
+
+// ../listener/dist/main.js
+import { readFile as readFile4, writeFile as writeFile4, unlink, mkdir as mkdir4 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+
+// ../listener/dist/lib/config.js
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".repowise");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var DEFAULT_API_URL = "https://api.repowise.ai";
+async function getListenerConfig() {
+  const apiUrl = process.env["REPOWISE_API_URL"] ?? DEFAULT_API_URL;
+  try {
+    const data = await readFile(CONFIG_PATH, "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 {
+      apiUrl: raw.apiUrl ?? apiUrl,
+      repos: validRepos
+    };
+  } catch {
+    return { apiUrl, repos: [] };
+  }
+}
+
+// ../listener/dist/lib/state.js
+import { readFile as readFile2, writeFile, mkdir, chmod } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var CONFIG_DIR2 = join2(homedir2(), ".repowise");
+var STATE_PATH = join2(CONFIG_DIR2, "listener-state.json");
+function emptyState() {
+  return { repos: {} };
+}
+async function loadState() {
+  try {
+    const data = await readFile2(STATE_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return emptyState();
+    }
+    throw err;
+  }
+}
+async function saveState(state) {
+  await mkdir(CONFIG_DIR2, { recursive: true, mode: 448 });
+  await writeFile(STATE_PATH, JSON.stringify(state, null, 2));
+  await chmod(STATE_PATH, 384);
+}
+
+// ../listener/dist/lib/auth.js
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var CONFIG_DIR3 = join3(homedir3(), ".repowise");
+var CREDENTIALS_PATH = join3(CONFIG_DIR3, "credentials.json");
+function getCognitoConfig() {
+  return {
+    domain: process.env["REPOWISE_COGNITO_DOMAIN"] ?? "auth-repowise-dev",
+    clientId: process.env["REPOWISE_COGNITO_CLIENT_ID"] ?? "",
+    region: process.env["REPOWISE_COGNITO_REGION"] ?? "us-east-1"
+  };
+}
+function getTokenUrl() {
+  const { domain, region } = getCognitoConfig();
+  return `https://${domain}.auth.${region}.amazoncognito.com/oauth2/token`;
+}
+async function refreshTokens(refreshToken) {
+  const response = await fetch(getTokenUrl(), {
+    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,
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function getStoredCredentials() {
+  try {
+    const data = await readFile3(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function storeCredentials(credentials) {
+  await mkdir2(CONFIG_DIR3, { recursive: true, mode: 448 });
+  await writeFile2(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2));
+  await chmod2(CREDENTIALS_PATH, 384);
+}
+async function getValidCredentials() {
+  const creds = await getStoredCredentials();
+  if (!creds)
+    return null;
+  if (Date.now() > creds.expiresAt - 5 * 60 * 1e3) {
+    try {
+      const refreshed = await refreshTokens(creds.refreshToken);
+      await storeCredentials(refreshed);
+      return refreshed;
+    } catch {
+      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) {
+    const credentials = await getValidCredentials();
+    if (!credentials) {
+      throw new AuthError("Not logged in. Run `repowise login` first.");
+    }
+    const params = new URLSearchParams({
+      repoIds: repoIds.join(","),
+      since
+    });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), POLL_TIMEOUT_MS);
+    try {
+      const response = await fetch(`${this.apiUrl}/v1/listeners/poll?${params.toString()}`, {
+        headers: {
+          Authorization: `Bearer ${credentials.accessToken}`,
+          "Content-Type": "application/json"
+        },
+        signal: controller.signal
+      });
+      if (response.status === 401) {
+        throw new AuthError("Session expired. Run `repowise login` again.");
+      }
+      if (!response.ok) {
+        throw new Error(`Poll request failed: ${response.status}`);
+      }
+      const json = await response.json();
+      return json.data;
+    } 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 mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { join as join5 } from "path";
+import { promisify } from "util";
+
+// ../listener/dist/file-writer.js
+import { access } from "fs/promises";
+import { join as join4 } from "path";
+async function verifyContextFolder(localPath) {
+  try {
+    await access(join4(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: [] };
+  }
+}
+async function fetchContextFromServer(repoId, localPath, apiUrl, authToken) {
+  try {
+    const headers = { Authorization: `Bearer ${authToken}`, "Content-Type": "application/json" };
+    const listRes = await fetch(`${apiUrl}/v1/repos/${repoId}/context`, { headers });
+    if (!listRes.ok) {
+      console.error(`Context list failed (${listRes.status}) for repo ${repoId}`);
+      return { success: false, updatedFiles: [] };
+    }
+    const listData = await listRes.json();
+    const files = listData.data?.files ?? [];
+    if (files.length === 0) {
+      return { success: true, updatedFiles: [] };
+    }
+    const contextDir = join5(localPath, "repowise-context");
+    await mkdir3(contextDir, { recursive: true });
+    const updatedFiles = [];
+    for (const file of files) {
+      const urlRes = await fetch(`${apiUrl}/v1/repos/${repoId}/context/${file.fileName}`, {
+        headers
+      });
+      if (!urlRes.ok)
+        continue;
+      const urlData = await urlRes.json();
+      const presignedUrl = urlData.data?.url;
+      if (!presignedUrl)
+        continue;
+      const contentRes = await fetch(presignedUrl);
+      if (!contentRes.ok)
+        continue;
+      const content = await contentRes.text();
+      await writeFile3(join5(contextDir, file.fileName), content, "utf-8");
+      updatedFiles.push(file.fileName);
+    }
+    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/main.js
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var PID_PATH = join6(homedir4(), ".repowise", "listener.pid");
+var running = false;
+var sleepResolve = null;
+async function writePidFile() {
+  await mkdir4(join6(homedir4(), ".repowise"), { recursive: true });
+  await writeFile4(PID_PATH, String(process.pid));
+}
+async function removePidFile() {
+  try {
+    await unlink(PID_PATH);
+  } catch {
+  }
+}
+async function handleStalePid() {
+  try {
+    const content = await readFile4(PID_PATH, "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    if (!Number.isNaN(pid) && pid !== process.pid) {
+      try {
+        process.kill(pid, 0);
+        console.error(`Listener already running (PID: ${pid}). Stop it first with \`repowise stop\`.`);
+        process.exitCode = 1;
+        return true;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function stop() {
+  running = false;
+  if (sleepResolve) {
+    sleepResolve();
+    sleepResolve = null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    sleepResolve = resolve;
+    const timer = setTimeout(() => {
+      sleepResolve = null;
+      resolve();
+    }, ms);
+    if (typeof timer === "object" && "unref" in timer)
+      timer.unref();
+  });
+}
+async function processNotifications(notifications, state, repoLocalPaths, apiUrl, authToken) {
+  let updateCount = 0;
+  for (const notif of notifications) {
+    if (notif.type === "sync.completed") {
+      const localPath = repoLocalPaths.get(notif.repoId);
+      if (localPath) {
+        let result;
+        if (apiUrl && authToken) {
+          result = await fetchContextFromServer(notif.repoId, localPath, apiUrl, authToken);
+        } else {
+          result = await fetchContextUpdates(localPath);
+        }
+        if (result.success) {
+          updateCount++;
+          notifyContextUpdated(notif.repoId, result.updatedFiles.length);
+        }
+      }
+    }
+    state.repos[notif.repoId] = {
+      lastSyncTimestamp: notif.createdAt,
+      lastSyncCommitSha: notif.commitSha
+    };
+  }
+  return updateCount;
+}
+async function handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, apiUrl, authToken) {
+  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 && authToken) {
+        result = await fetchContextFromServer(repoId, localPath, apiUrl, authToken);
+      } else {
+        result = await fetchContextUpdates(localPath);
+      }
+      if (result.success)
+        syncCount++;
+    }
+    notifyBackOnline(syncCount);
+  } else {
+    const sinceTimestamp = offlineState.offlineSince;
+    const response = await pollClient.poll(repoIds, sinceTimestamp);
+    const updateCount = await processNotifications(response.notifications, state, repoLocalPaths, apiUrl, authToken);
+    await saveState(state);
+    notifyBackOnline(updateCount);
+  }
+}
+async function startListener() {
+  running = true;
+  const alreadyRunning = await handleStalePid();
+  if (alreadyRunning)
+    return;
+  await writePidFile();
+  const config2 = await getListenerConfig();
+  if (config2.repos.length === 0) {
+    console.error("No repos configured. Add repos to ~/.repowise/config.json");
+    process.exitCode = 1;
+    return;
+  }
+  const credentials = await getValidCredentials();
+  if (!credentials) {
+    console.error("Not logged in. Run `repowise login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const state = await loadState();
+  const pollClient = new PollClient(config2.apiUrl);
+  const backoff = new BackoffCalculator();
+  const repoIds = config2.repos.map((r) => r.repoId);
+  const repoLocalPaths = new Map(config2.repos.map((r) => [r.repoId, r.localPath]));
+  const offlineState = {
+    isOffline: false,
+    offlineSince: null,
+    attemptCount: 0
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const repoId of repoIds) {
+    if (!state.repos[repoId]) {
+      state.repos[repoId] = { lastSyncTimestamp: now, lastSyncCommitSha: null };
+    }
+  }
+  let pollIntervalMs = 5e3;
+  console.log(`RepoWise Listener started \u2014 watching ${repoIds.length} repo(s)`);
+  const shutdown = async () => {
+    console.log("Shutting down...");
+    stop();
+    await saveState(state);
+    await removePidFile();
+  };
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  while (running) {
+    try {
+      const sinceTimestamp = repoIds.reduce((earliest, id) => {
+        const ts = state.repos[id]?.lastSyncTimestamp ?? now;
+        return ts < earliest ? ts : earliest;
+      }, now);
+      const response = await pollClient.poll(repoIds, sinceTimestamp);
+      const freshCredentials = await getValidCredentials();
+      const authToken = freshCredentials?.idToken;
+      if (offlineState.isOffline) {
+        await handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, config2.apiUrl, authToken);
+        offlineState.isOffline = false;
+        offlineState.offlineSince = null;
+        offlineState.attemptCount = 0;
+        backoff.reset();
+      } else if (response.notifications.length > 0) {
+        await processNotifications(response.notifications, state, repoLocalPaths, config2.apiUrl, authToken);
+        await saveState(state);
+      }
+      pollIntervalMs = response.pollIntervalMs;
+      await sleep(pollIntervalMs);
+    } catch (err) {
+      if (!running)
+        break;
+      if (err instanceof AuthError) {
+        console.error(err.message);
+        process.exitCode = 1;
+        break;
+      }
+      if (!offlineState.isOffline) {
+        offlineState.isOffline = true;
+        offlineState.offlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        offlineState.attemptCount = 0;
+        notifyConnectionLost();
+      }
+      offlineState.attemptCount++;
+      const delay = backoff.nextDelay();
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error(`Poll failed (attempt ${offlineState.attemptCount}): ${message}. Retrying in ${Math.round(delay / 1e3)}s`);
+      await sleep(delay);
+    }
+  }
+  await removePidFile();
+}
+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;
+  });
+}
+
+// bin/repowise.ts
+import { Command } from "commander";
+
+// src/lib/env.ts
+var staging = false;
+function setStagingMode(value) {
+  staging = value;
+}
+var PRODUCTION = {
+  apiUrl: "https://api.repowise.ai",
+  cognitoDomain: "auth.repowise.ai",
+  cognitoClientId: "",
+  // TODO: set after production Cognito deploy
+  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 staging ? STAGING : PRODUCTION;
+}
+
+// src/lib/welcome.ts
+import chalk from "chalk";
+
+// src/lib/config.ts
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+var CONFIG_DIR4 = join7(homedir5(), ".repowise");
+var CONFIG_PATH2 = join7(CONFIG_DIR4, "config.json");
+async function getConfig() {
+  try {
+    const data = await readFile5(CONFIG_PATH2, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config2) {
+  await mkdir5(CONFIG_DIR4, { recursive: true });
+  await writeFile5(CONFIG_PATH2, JSON.stringify(config2, null, 2));
+}
+
+// src/lib/welcome.ts
+var W = 41;
+function row(styled, visible) {
+  return chalk.cyan("  \u2502") + styled + " ".repeat(W - visible) + chalk.cyan("\u2502");
+}
+async function showWelcome(currentVersion) {
+  try {
+    const config2 = await getConfig();
+    if (config2.lastSeenVersion === currentVersion) return;
+    const isUpgrade = !!config2.lastSeenVersion;
+    const tag = isUpgrade ? "updated" : "installed";
+    const titleText = `RepoWise v${currentVersion}`;
+    const titleStyled = "   " + chalk.bold(titleText) + chalk.green(` \u2713 ${tag}`);
+    const titleVisible = 3 + titleText.length + 3 + tag.length;
+    const border = "\u2500".repeat(W);
+    console.log("");
+    console.log(chalk.cyan(`  \u256D${border}\u256E`));
+    console.log(row("", 0));
+    console.log(row(titleStyled, titleVisible));
+    console.log(row("", 0));
+    console.log(row("   " + chalk.dim("Get started:"), 15));
+    console.log(row("     $ " + chalk.bold("repowise create"), 22));
+    console.log(row("", 0));
+    console.log(row("   " + chalk.dim("Thank you for using RepoWise!"), 32));
+    console.log(row("   " + chalk.dim("https://repowise.ai"), 22));
+    console.log(row("", 0));
+    console.log(chalk.cyan(`  \u2570${border}\u256F`));
+    console.log("");
+    await saveConfig({ ...config2, lastSeenVersion: currentVersion });
+  } catch {
+  }
+}
+
+// src/commands/create.ts
+import { execSync } from "child_process";
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join12 } from "path";
+
+// ../listener/dist/process-manager.js
+import { spawn } from "child_process";
+import { openSync, closeSync } from "fs";
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+var REPOWISE_DIR = join8(homedir6(), ".repowise");
+var PID_PATH2 = join8(REPOWISE_DIR, "listener.pid");
+var LOG_DIR = join8(REPOWISE_DIR, "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 readFile6(PID_PATH2, "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() {
+  await mkdir6(LOG_DIR, { recursive: true });
+  const cmd = resolveListenerCommand();
+  const stdoutFd = openSync(join8(LOG_DIR, "listener-stdout.log"), "a");
+  const stderrFd = openSync(join8(LOG_DIR, "listener-stderr.log"), "a");
+  const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
+    detached: true,
+    stdio: ["ignore", stdoutFd, stderrFd],
+    cwd: homedir6(),
+    env: { ...process.env }
+  });
+  child.unref();
+  closeSync(stdoutFd);
+  closeSync(stderrFd);
+  const pid = child.pid;
+  if (!pid)
+    throw new Error("Failed to spawn listener process");
+  await writeFile6(PID_PATH2, String(pid));
+  return pid;
+}
+async function stopProcess() {
+  const pid = await readPid();
+  if (pid === null)
+    return;
+  if (!isAlive(pid)) {
+    await removePidFile2();
+    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 removePidFile2();
+}
+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 removePidFile2() {
+  try {
+    await unlink2(PID_PATH2);
+  } catch {
+  }
+}
+
+// ../listener/dist/service-installer.js
+import { execFile as execFile2 } from "child_process";
+import { writeFile as writeFile7, mkdir as mkdir7, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+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) => {
+    execFile2(cmd, args, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(String(stdout ?? ""));
+    });
+  });
+}
+var PLIST_LABEL = "com.repowise.listener";
+function plistPath() {
+  return join9(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function logDir() {
+  return join9(homedir7(), ".repowise", "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>${join9(logs, "listener-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join9(logs, "listener-stderr.log")}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>`;
+}
+async function darwinInstall() {
+  await mkdir7(logDir(), { recursive: true });
+  await mkdir7(join9(homedir7(), "Library", "LaunchAgents"), { recursive: true });
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  await writeFile7(plistPath(), buildPlist());
+  await exec("launchctl", ["load", plistPath()]);
+}
+async function darwinUninstall() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  try {
+    await unlink3(plistPath());
+  } catch {
+  }
+}
+async function darwinIsInstalled() {
+  try {
+    const stdout = await exec("launchctl", ["list"]);
+    return stdout.includes(PLIST_LABEL);
+  } catch {
+    return false;
+  }
+}
+var SYSTEMD_SERVICE = "repowise-listener";
+function unitPath() {
+  return join9(homedir7(), ".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=on-failure
+RestartSec=10
+StandardOutput=append:${join9(logs, "listener-stdout.log")}
+StandardError=append:${join9(logs, "listener-stderr.log")}
+
+[Install]
+WantedBy=default.target`;
+}
+async function linuxInstall() {
+  await mkdir7(logDir(), { recursive: true });
+  await mkdir7(join9(homedir7(), ".config", "systemd", "user"), { recursive: true });
+  await writeFile7(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 unlink3(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 = "RepoWise Listener";
+async function win32Install() {
+  await mkdir7(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 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 chalk5 from "chalk";
+import ora from "ora";
+
+// src/lib/auth.ts
+import { createHash, randomBytes } from "crypto";
+import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8, chmod as chmod3, unlink as unlink4 } from "fs/promises";
+import http from "http";
+import { homedir as homedir8 } from "os";
+import { join as join10 } from "path";
+var CONFIG_DIR5 = join10(homedir8(), ".repowise");
+var CREDENTIALS_PATH2 = join10(CONFIG_DIR5, "credentials.json");
+var CLI_CALLBACK_PORT = 19876;
+var CALLBACK_TIMEOUT_MS = 12e4;
+function getCognitoConfig2() {
+  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 } = getCognitoConfig2();
+  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 } = getCognitoConfig2();
+  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: getCognitoConfig2().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: getCognitoConfig2().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 data = await readFile7(CREDENTIALS_PATH2, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function storeCredentials2(credentials) {
+  await mkdir8(CONFIG_DIR5, { recursive: true, mode: 448 });
+  await writeFile8(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2));
+  await chmod3(CREDENTIALS_PATH2, 384);
+}
+async function clearCredentials() {
+  try {
+    await unlink4(CREDENTIALS_PATH2);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+async function getValidCredentials2() {
+  const creds = await getStoredCredentials2();
+  if (!creds) return null;
+  if (Date.now() > creds.expiresAt - 5 * 60 * 1e3) {
+    try {
+      const refreshed = await refreshTokens2(creds.refreshToken);
+      await storeCredentials2(refreshed);
+      return refreshed;
+    } catch {
+      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);
+  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;
+}
+async function apiRequest(path, options) {
+  const credentials = await getValidCredentials2();
+  if (!credentials) {
+    throw new Error("Not logged in. Run `repowise login` first.");
+  }
+  const response = await fetch(`${getApiUrl()}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${credentials.accessToken}`,
+      ...options?.headers
+    }
+  });
+  if (response.status === 401) {
+    await clearCredentials();
+    throw new Error("Session expired. Run `repowise login` again.");
+  }
+  if (!response.ok) {
+    let message = `Request failed with status ${response.status}`;
+    try {
+      const body = await response.json();
+      if (body.error?.message) message = body.error.message;
+    } catch {
+    }
+    throw new Error(message);
+  }
+  const json = await response.json();
+  return json.data;
+}
+
+// src/lib/prompts.ts
+import { checkbox, confirm } from "@inquirer/prompts";
+import chalk2 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) {
+    console.log(chalk2.dim("  Use Space to select, Enter to continue.\n"));
+    const selected = await checkbox({
+      message: chalk2.bold("Which AI tools do you use?"),
+      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 readFile8, writeFile as writeFile9, mkdir as mkdir9, readdir } from "fs/promises";
+import { join as join11, dirname } 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 desc = fileDescriptionFromName(f.fileName);
+    const isOverview = f.fileName === "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.`,
+      `Before making changes, read the relevant context files in \`${contextFolder}/\` to understand the project's architecture, coding patterns, conventions, and domain knowledge.`,
+      "",
+      `**Start here:** \`${contextFolder}/project-overview.md\` \u2014 the routing document that describes every context file and when to read it.`,
+      ""
+    ];
+    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.`,
+    `# Before making changes, read the relevant context files in ${contextFolder}/`,
+    `# to understand the project's architecture, coding patterns, conventions, and domain knowledge.`,
+    "#",
+    `# Start here: ${contextFolder}/project-overview.md`,
+    `#   The routing document that describes every context file and when to read it.`
+  ];
+  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 = join11(repoRoot, config2.filePath);
+  const dir = dirname(fullPath);
+  if (dir !== repoRoot) {
+    await mkdir9(dir, { recursive: true });
+  }
+  const referenceBlock = generateReference(tool, repoName, contextFolder, contextFiles);
+  let existing = "";
+  let created = true;
+  try {
+    existing = await readFile8(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 writeFile9(fullPath, content, "utf-8");
+  return { created };
+}
+async function scanLocalContextFiles(repoRoot, contextFolder) {
+  const folderPath = join11(repoRoot, contextFolder);
+  try {
+    const entries = await readdir(folderPath, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => ({
+      fileName: e.name,
+      relativePath: `${contextFolder}/${e.name}`
+    })).sort((a, b) => a.fileName.localeCompare(b.fileName));
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/lib/interview-handler.ts
+import chalk3 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(chalk3.cyan.bold("  \u2500\u2500 Interview \u2500\u2500"));
+    console.log(chalk3.dim("  Help us understand your project better. Answer a few short"));
+    console.log(
+      chalk3.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(chalk3.cyan.bold(`  Question ${questionCounter}/${total}`));
+  if (questionContext) {
+    console.log(chalk3.dim(`  ${questionContext}`));
+  }
+  console.log(`  ${questionText}`);
+  console.log(chalk3.dim('  (Enter to skip \xB7 "done" to finish early)'));
+  let answer;
+  try {
+    answer = await Promise.race([
+      input({
+        message: chalk3.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(chalk3.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(chalk3.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(chalk3.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(chalk3.yellow("  Could not submit answer \u2014 pipeline will continue."));
+      return;
+    }
+  }
+  if (action === "done") {
+    console.log(chalk3.dim("  Interview ended early."));
+  } else if (action === "skip") {
+    console.log(chalk3.dim("  Skipped."));
+  } else {
+    console.log(chalk3.dim("  Answer recorded."));
+  }
+  console.log("");
+}
+
+// src/lib/progress-renderer.ts
+import chalk4 from "chalk";
+var CORE_FILES = /* @__PURE__ */ new Set([
+  "project-overview.md",
+  "architecture.md",
+  "data-models.md",
+  "api-contracts.md",
+  "coding-patterns.md"
+]);
+var FILE_DESCRIPTIONS = {
+  // Core
+  "project-overview.md": "Project overview & file index",
+  "architecture.md": "System design & components",
+  "data-models.md": "Schemas, entities & relationships",
+  "api-contracts.md": "API endpoints & contracts",
+  "coding-patterns.md": "Code conventions & patterns",
+  // Tailored
+  "domain-knowledge.md": "Business domain & terminology",
+  "testing-strategy.md": "Test frameworks & coverage",
+  "deployment-workflows.md": "CI/CD & release process",
+  "state-management.md": "State & caching patterns",
+  "performance-optimization.md": "Performance & optimization",
+  "accessibility-patterns.md": "Accessibility & ARIA patterns",
+  "tech-stack.md": "Technology inventory & versions",
+  "tribal-knowledge.md": "Team knowledge & conventions",
+  "development-setup.md": "Dev environment setup",
+  "ui-patterns.md": "UI components & design system",
+  "ux-patterns.md": "UX interactions & feedback",
+  "user-flows.md": "User journeys & navigation",
+  "security-patterns.md": "Auth & security patterns",
+  "error-handling.md": "Error handling & recovery",
+  "integration-patterns.md": "External integrations & APIs",
+  "configuration.md": "Config & environment settings"
+};
+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 ?? 6;
+  const stepPct = syncResult.progressPercentage ?? 0;
+  return Math.min(100, Math.round(((stepNumber - 1) * 100 + stepPct) / totalSteps));
+}
+var ProgressRenderer = class {
+  privacyShieldShown = false;
+  discoveryShown = false;
+  scanSummaryShown = false;
+  validationShown = false;
+  lastValidationSnapshot = "";
+  lastValidationLineCount = 0;
+  pushShown = false;
+  fileStatusHeaderShown = false;
+  lastFileStatusSnapshot = "";
+  lastFileStatusLineCount = 0;
+  renderPrivacyShield(enabled, spinner) {
+    if (this.privacyShieldShown) return;
+    this.privacyShieldShown = true;
+    spinner.stop();
+    console.log("");
+    console.log(chalk4.cyan.bold("  \u2500\u2500 Privacy Shield \u2500\u2500"));
+    if (enabled) {
+      console.log(`  ${chalk4.green("\u2713")} Privacy Shield active`);
+      console.log(`  ${chalk4.green("\u2713")} Private connection established`);
+    } else {
+      console.log(`  ${chalk4.yellow("\u2139")} Privacy Shield not in current plan`);
+      console.log(chalk4.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(chalk4.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(`  ${chalk4.dim("Languages:")} ${langs}`);
+    }
+    if (result.frameworks.length > 0) {
+      console.log(
+        `  ${chalk4.dim("Frameworks:")} ${result.frameworks.map((f) => f.name).join(", ")}`
+      );
+    }
+    console.log(
+      `  ${chalk4.dim("Structure:")} ${result.structureType} ${chalk4.dim(`(${result.fileCount} files)`)}`
+    );
+    if (result.existingDocs.length > 0) {
+      console.log(`  ${chalk4.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(chalk4.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" ? chalk4.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);
+    });
+  }
+  renderScanSummary(summary, spinner) {
+    if (this.scanSummaryShown) return;
+    this.scanSummaryShown = true;
+    spinner.stop();
+    console.log(
+      chalk4.dim(
+        `  Scan complete: ${summary.totalFiles} files, ${summary.totalFunctions} functions, ${summary.totalClasses} classes, ${summary.totalEndpoints} endpoints`
+      )
+    );
+    console.log("");
+    spinner.start();
+  }
+  renderValidation(progress, spinner) {
+    const resultMap = new Map(progress.personaResults.map((r) => [r.persona, r.score]));
+    const isComplete = progress.status === "complete";
+    if (isComplete && this.validationShown) return;
+    const snapshot = `${progress.round}:${progress.status}:${progress.personaResults.map((r) => `${r.persona}:${r.score}`).join(",")}`;
+    if (snapshot === this.lastValidationSnapshot) return;
+    this.lastValidationSnapshot = snapshot;
+    if (isComplete) this.validationShown = true;
+    spinner.stop();
+    if (this.lastValidationLineCount > 0) {
+      process.stdout.write(`\x1B[${this.lastValidationLineCount}A`);
+    }
+    const lines = [];
+    const title = isComplete ? "Validation Results" : "Validation";
+    lines.push(chalk4.cyan.bold(`  \u2500\u2500 ${title} \u2500\u2500`));
+    if (!isComplete) {
+      lines.push(
+        chalk4.dim(
+          `  ${ALL_PERSONAS.length} AI reviewers checking context quality \u2014 issues are auto-fixed.`
+        )
+      );
+    }
+    const passCount = progress.personaResults.filter((r) => r.score === "PASS").length;
+    if (isComplete) {
+      const roundInfo = progress.round > 1 ? ` (${progress.round} rounds)` : "";
+      lines.push(chalk4.dim(`  ${passCount}/${ALL_PERSONAS.length} PASS${roundInfo}`));
+    } else if (progress.personaResults.length > 0) {
+      const statusSuffix = progress.status === "regenerating" ? chalk4.dim(" \u2014 improving files based on feedback") : "";
+      lines.push(
+        `  Round ${progress.round}/${progress.maxRounds}: ${passCount}/${ALL_PERSONAS.length} passed${statusSuffix}`
+      );
+    } else {
+      lines.push(chalk4.dim(`  Round ${progress.round}/${progress.maxRounds}: validating...`));
+    }
+    for (const persona of ALL_PERSONAS) {
+      const label = PERSONA_LABELS[persona] ?? persona;
+      const score = resultMap.get(persona);
+      if (score) {
+        const icon = score === "PASS" ? chalk4.green("\u2713") : chalk4.red("\u2717");
+        const scoreColor = score === "PASS" ? chalk4.green : score === "PARTIAL" ? chalk4.yellow : chalk4.red;
+        const fixingSuffix = progress.status === "regenerating" && score !== "PASS" ? chalk4.dim(" \u2192 fixing...") : "";
+        lines.push(`  ${icon} ${label}: ${scoreColor(score)}${fixingSuffix}`);
+      } else {
+        lines.push(`  ${chalk4.dim("\u25CB")} ${chalk4.dim(label)}`);
+      }
+    }
+    if (isComplete && passCount < ALL_PERSONAS.length) {
+      lines.push(chalk4.yellow("  \u26A0 Continuing with best-effort context"));
+    }
+    lines.push("");
+    for (const line of lines) {
+      process.stdout.write(`\x1B[2K${line}
+`);
+    }
+    for (let i = lines.length; i < this.lastValidationLineCount; i++) {
+      process.stdout.write("\x1B[2K\n");
+    }
+    this.lastValidationLineCount = lines.length;
+    spinner.start();
+  }
+  renderFileStatuses(fileStatuses, spinner) {
+    const snapshot = fileStatuses.map((f) => `${f.fileName}:${f.status}`).join(",");
+    if (snapshot === this.lastFileStatusSnapshot) return;
+    this.lastFileStatusSnapshot = snapshot;
+    const completedCount = fileStatuses.filter((f) => f.status === "completed").length;
+    const totalCount = fileStatuses.length;
+    spinner.stop();
+    if (!this.fileStatusHeaderShown) {
+      this.fileStatusHeaderShown = true;
+      console.log("");
+      console.log(chalk4.cyan.bold("  \u2500\u2500 RepoWise Context Generation \u2500\u2500"));
+      console.log(chalk4.dim("  Building AI-optimized context files from your codebase."));
+    }
+    if (this.lastFileStatusLineCount > 0) {
+      process.stdout.write(`\x1B[${this.lastFileStatusLineCount}A`);
+    }
+    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 maxCoreLen = coreFiles.reduce((m, f) => Math.max(m, f.fileName.length), 0);
+    const maxTailoredLen = tailoredFiles.reduce((m, f) => Math.max(m, f.fileName.length), 0);
+    const formatFileLine = (file, padLen) => {
+      const baseName = file.fileName.split("/").pop() ?? file.fileName;
+      const desc = FILE_DESCRIPTIONS[baseName] ?? baseName.replace(/\.md$/, "").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      const padded = file.fileName.padEnd(padLen);
+      switch (file.status) {
+        case "completed":
+          return `    ${chalk4.green("\u2713")} ${padded} ${chalk4.dim(`\u2014 ${desc}`)}`;
+        case "generating":
+          return `    ${chalk4.cyan("\u27F3")} ${padded} ${chalk4.dim(`\u2014 ${desc}`)}`;
+        case "failed":
+          return `    ${chalk4.red("\u2717")} ${padded} ${chalk4.dim(`\u2014 ${desc}`)}`;
+        case "pending":
+          return `    ${chalk4.dim("\u25CB")} ${chalk4.dim(`${padded} \u2014 ${desc}`)}`;
+      }
+    };
+    const lines = [];
+    lines.push(chalk4.dim(`  Generated ${completedCount}/${totalCount} files`));
+    lines.push("");
+    lines.push(`  ${chalk4.bold("Core")}`);
+    for (const file of coreFiles) {
+      lines.push(formatFileLine(file, maxCoreLen));
+    }
+    if (tailoredFiles.length > 0) {
+      lines.push("");
+      lines.push(`  ${chalk4.bold("Tailored")}`);
+      for (const file of tailoredFiles) {
+        lines.push(formatFileLine(file, maxTailoredLen));
+      }
+    }
+    lines.push("");
+    for (const line of lines) {
+      process.stdout.write(`\x1B[2K${line}
+`);
+    }
+    for (let i = lines.length; i < this.lastFileStatusLineCount; i++) {
+      process.stdout.write("\x1B[2K\n");
+    }
+    this.lastFileStatusLineCount = lines.length;
+    spinner.start();
+  }
+  renderPush(spinner) {
+    if (this.pushShown) return;
+    this.pushShown = true;
+    spinner.stop();
+    console.log("");
+    console.log(chalk4.cyan.bold("  \u2500\u2500 Saving Context \u2500\u2500"));
+    console.log(`  ${chalk4.dim("Encrypting and saving context files to RepoWise servers...")}`);
+    console.log("");
+    spinner.start();
+  }
+  getSpinnerText(syncResult) {
+    const stepLabel = syncResult.stepLabel ?? syncResult.currentStep ?? "Processing";
+    const overallPct = computeOverallProgress(syncResult);
+    let progressText = stepLabel;
+    if (syncResult.scanProgress && !syncResult.scanProgress.summary) {
+      progressText = `Scanning batch ${syncResult.scanProgress.currentBatch}/${syncResult.scanProgress.totalBatches}`;
+    } else if (syncResult.generationProgress) {
+      const gp = syncResult.generationProgress;
+      if (gp.fileStatuses && gp.fileStatuses.length > 0) {
+        const completed = gp.fileStatuses.filter((f) => f.status === "completed").length;
+        const total = gp.fileStatuses.length;
+        const generating = gp.fileStatuses.find((f) => f.status === "generating");
+        if (completed === total) {
+          progressText = stepLabel;
+        } else if (generating) {
+          progressText = `Generating ${generating.fileName} (${completed}/${total})`;
+        } else {
+          progressText = `Generating (${completed}/${total})`;
+        }
+      } else {
+        progressText = `Generating ${gp.currentFileName} (${gp.currentFile}/${gp.totalFiles})`;
+      }
+    } else if (syncResult.validationProgress && syncResult.validationProgress.status !== "complete") {
+      const vp = syncResult.validationProgress;
+      if (vp.status === "regenerating") {
+        progressText = `Improving files based on feedback (round ${vp.round})`;
+      } else {
+        progressText = `Validation round ${vp.round}/${vp.maxRounds}`;
+      }
+    }
+    return `${progressText}... ${chalk4.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?.summary && syncResult.scanProgress.summary.totalFiles > 0) {
+      this.renderScanSummary(syncResult.scanProgress.summary, 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 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";
+}
+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 = 600;
+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(chalk5.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk5.green(`Authenticated as ${chalk5.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoId;
+    let repoName;
+    let repoRoot;
+    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: ${chalk5.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: ${chalk5.bold(repoName)}`);
+      } catch {
+        spinner.fail(
+          chalk5.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;
+        }
+      } catch {
+      }
+    } else {
+      try {
+        repoRoot = detectRepoRoot();
+      } catch {
+      }
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk5.red(
+          "Could not find this repository in your RepoWise account. Connect it on the dashboard first."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const { tools, hasOther } = await selectAiTools();
+    if (hasOther) {
+      console.log(
+        chalk5.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(
+        chalk5.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 triggerResult = await apiRequest(`/v1/repos/${repoId}/sync`, {
+        method: "POST",
+        body: JSON.stringify({ scanType: "full", contextStorage })
+      });
+      syncId = triggerResult.syncId;
+    } catch (triggerErr) {
+      const msg = triggerErr instanceof Error ? triggerErr.message : "";
+      if (!msg.toLowerCase().includes("already running")) {
+        throw triggerErr;
+      }
+      spinner.text = "Resuming existing pipeline...";
+      const syncs = await apiRequest(
+        `/v1/repos/${repoId}/syncs?limit=1`
+      );
+      const active = syncs.items.find(
+        (s) => s.status === "in_progress" || s.status === "awaiting_input"
+      );
+      if (!active) {
+        throw new Error("Could not find active sync to resume. Please try again.");
+      }
+      syncId = active.syncId;
+      spinner.info(chalk5.cyan("Resuming existing pipeline..."));
+      spinner.start();
+    }
+    let pollAttempts = 0;
+    const progressRenderer = new ProgressRenderer();
+    while (true) {
+      if (++pollAttempts > MAX_POLL_ATTEMPTS) {
+        spinner.fail(chalk5.red("Pipeline timed out. Check dashboard for status."));
+        process.exitCode = 1;
+        return;
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      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 pipeline...");
+        continue;
+      }
+      if (syncResult.status === "completed") {
+        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(chalk5.yellow("Pipeline completed but no context files were generated."));
+          console.log(
+            chalk5.yellow(
+              "  This may be due to AI throttling or a parsing issue. Try running `repowise create` again."
+            )
+          );
+        }
+        break;
+      }
+      if (syncResult.status === "failed") {
+        spinner.fail(chalk5.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 = join12(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          mkdirSync(contextDir, { recursive: true });
+          let downloadedCount = 0;
+          let failedCount = 0;
+          for (const file of files) {
+            if (file.fileName.includes("..") || file.fileName.includes("/")) {
+              failedCount++;
+              continue;
+            }
+            const urlResult = await apiRequest(`/v1/repos/${repoId}/context/${file.fileName}`);
+            const presignedUrl = urlResult.data?.url ?? urlResult.url;
+            const response = await fetch(presignedUrl);
+            if (response.ok) {
+              const content = await response.text();
+              writeFileSync(join12(contextDir, file.fileName), 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}/`);
+          }
+        } else {
+          spinner.warn("No context files found on server");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        spinner.warn(
+          chalk5.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(
+        chalk5.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(chalk5.dim(results.join("\n")));
+    }
+    const existingConfig = await getConfig();
+    const existingRepos = existingConfig.repos ?? [];
+    const updatedRepos = existingRepos.filter((r) => r.repoId !== repoId);
+    if (repoRoot) {
+      updatedRepos.push({ repoId, localPath: repoRoot });
+    }
+    await saveConfig({
+      ...existingConfig,
+      aiTools: tools,
+      contextFolder,
+      repos: updatedRepos
+    });
+    let listenerRunning = false;
+    try {
+      await install();
+      await startBackground();
+      listenerRunning = true;
+    } catch {
+      console.log(
+        chalk5.yellow(
+          "Warning: Could not start listener automatically. Run the following to enable it:"
+        )
+      );
+      console.log(chalk5.yellow(`  $ repowise listen --install`));
+    }
+    const elapsed = formatElapsed(Date.now() - startTime);
+    console.log("");
+    console.log(chalk5.green.bold("  All done! Setup complete!"));
+    console.log(
+      chalk5.green(
+        `  Your AI tools now have access to project context for ${chalk5.bold(repoName)}.`
+      )
+    );
+    if (listenerRunning) {
+      console.log("");
+      console.log(chalk5.cyan("  The RepoWise listener is running in the background \u2014"));
+      console.log(chalk5.cyan("  your context will stay in sync automatically."));
+      console.log(chalk5.cyan("  Go back to coding, we've got it from here!"));
+    }
+    console.log("");
+    console.log(
+      chalk5.cyan(
+        '  Head back to the dashboard and click "Complete Onboarding" to explore your RepoWise dashboard!'
+      )
+    );
+    console.log(chalk5.dim(`
+  Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Create failed";
+    spinner.fail(chalk5.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/login.ts
+import chalk6 from "chalk";
+import ora2 from "ora";
+async function login(options = {}) {
+  const spinner = ora2("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(chalk6.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(chalk6.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);
+    await storeCredentials2(credentials);
+    const { email } = decodeIdToken(credentials.idToken);
+    spinner.succeed(chalk6.green(`Logged in as ${chalk6.bold(email)}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Login failed";
+    spinner.fail(chalk6.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/logout.ts
+import chalk7 from "chalk";
+async function logout() {
+  const creds = await getStoredCredentials2();
+  if (!creds) {
+    console.log(chalk7.yellow("Not logged in."));
+    return;
+  }
+  await clearCredentials();
+  console.log(chalk7.green("Logged out successfully."));
+}
+
+// src/commands/status.ts
+import { readFile as readFile9 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join13 } from "path";
+var STATE_PATH2 = join13(homedir9(), ".repowise", "listener-state.json");
+async function status() {
+  let state = null;
+  try {
+    const data = await readFile9(STATE_PATH2, "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;
+  }
+  console.log("Watched Repos:");
+  for (const [repoId, repoState] of Object.entries(state.repos)) {
+    const syncTime = repoState.lastSyncTimestamp ? new Date(repoState.lastSyncTimestamp).toLocaleString() : "never";
+    const commit = repoState.lastSyncCommitSha ? repoState.lastSyncCommitSha.slice(0, 7) : "none";
+    console.log(`  ${repoId}: last sync ${syncTime} (commit: ${commit})`);
+  }
+}
+
+// src/commands/sync.ts
+import { execSync as execSync2 } from "child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join14 } from "path";
+import chalk8 from "chalk";
+import ora3 from "ora";
+var POLL_INTERVAL_MS2 = 3e3;
+var MAX_POLL_ATTEMPTS2 = 600;
+var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
+function detectRepoRoot2() {
+  return execSync2("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+}
+function detectRepoName2(repoRoot) {
+  try {
+    const remoteUrl = execSync2("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";
+}
+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 sync() {
+  const startTime = Date.now();
+  const spinner = ora3("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk8.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk8.green(`Authenticated as ${chalk8.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoRoot;
+    let repoName;
+    spinner.start("Detecting repository...");
+    try {
+      repoRoot = detectRepoRoot2();
+      repoName = detectRepoName2(repoRoot);
+      spinner.succeed(`Repository: ${chalk8.bold(repoName)}`);
+    } catch {
+      spinner.fail(
+        chalk8.red("Not in a git repository. Run this command from your repo directory.")
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let repoId;
+    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;
+      }
+    } catch {
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk8.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=1`
+      );
+      const active = syncs.items.find(
+        (s) => s.status === "in_progress" || s.status === "awaiting_input"
+      );
+      if (!active) {
+        throw new Error("Could not find active sync to resume. Please try again.");
+      }
+      syncId = active.syncId;
+      spinner.info(chalk8.cyan("Resuming existing sync..."));
+      spinner.start();
+    }
+    let pollAttempts = 0;
+    const progressRenderer = new ProgressRenderer();
+    while (true) {
+      if (++pollAttempts > MAX_POLL_ATTEMPTS2) {
+        spinner.fail(chalk8.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") {
+        const generatedFiles = syncResult.filesGenerated ?? [];
+        const fileCount = generatedFiles.length;
+        if (fileCount > 0) {
+          spinner.succeed(chalk8.green(`Incremental update complete \u2014 ${fileCount} files updated`));
+        } else {
+          spinner.succeed(chalk8.green("Incremental sync complete \u2014 no files needed updating"));
+        }
+        break;
+      }
+      if (syncResult.status === "failed") {
+        spinner.fail(chalk8.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 = join14(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+        mkdirSync2(contextDir, { recursive: true });
+        let downloadedCount = 0;
+        let failedCount = 0;
+        for (const file of files) {
+          if (file.fileName.includes("..") || file.fileName.includes("/")) {
+            failedCount++;
+            continue;
+          }
+          const urlResult = await apiRequest(`/v1/repos/${repoId}/context/${file.fileName}`);
+          const presignedUrl = urlResult.data?.url ?? urlResult.url;
+          const response = await fetch(presignedUrl);
+          if (response.ok) {
+            const content = await response.text();
+            writeFileSync2(join14(contextDir, file.fileName), content, "utf-8");
+            downloadedCount++;
+          } else {
+            failedCount++;
+          }
+        }
+        if (failedCount > 0) {
+          spinner.warn(
+            `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER2}/ (${failedCount} failed)`
+          );
+        } else {
+          spinner.succeed(`Context files downloaded to ./${DEFAULT_CONTEXT_FOLDER2}/`);
+        }
+      } else {
+        spinner.info("No context files found on server");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      spinner.warn(chalk8.yellow(`Could not download context files: ${msg}
+Retry when online.`));
+    }
+    const elapsed = formatElapsed2(Date.now() - startTime);
+    console.log(chalk8.dim(`
+  Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Sync failed";
+    spinner.fail(chalk8.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;
+    }
+    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();
+    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 chalk9 from "chalk";
+import ora4 from "ora";
+import { select } from "@inquirer/prompts";
+async function config() {
+  const spinner = ora4("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk9.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk9.green(`Authenticated as ${chalk9.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    spinner.start("Loading repositories...");
+    const repos = await apiRequest("/v1/repos");
+    spinner.stop();
+    if (repos.length === 0) {
+      console.log(chalk9.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(chalk9.bold(`Settings for ${repo.fullName}`));
+    console.log(chalk9.dim(`  Context storage: RepoWise servers`));
+    console.log(chalk9.dim(`  Delivery mode:   ${currentDelivery}`));
+    console.log(chalk9.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(chalk9.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(chalk9.dim("No change."));
+        return;
+      }
+      patch.monitoredBranch = newBranch;
+    }
+    spinner.start("Saving...");
+    await apiRequest(`/v1/repos/${repoId}`, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+    spinner.succeed(chalk9.green("Setting updated"));
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : "Config failed";
+    console.error(chalk9.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// bin/repowise.ts
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname = dirname2(__filename);
+var pkg = JSON.parse(readFileSync(join15(__dirname, "..", "..", "package.json"), "utf-8"));
+var program = new Command();
+program.name("repowise").description("AI-optimized codebase context generator").version(pkg.version).option("--staging", "Use the staging environment").hook("preAction", async () => {
+  if (program.opts()["staging"]) {
+    setStagingMode(true);
+  }
+  await showWelcome(pkg.version);
 });
-program
-    .command('create')
-    .description('Create context for a repository')
-    .action(async () => {
-    const { create } = await import('../src/commands/create.js');
-    await create();
+program.command("create").description("Create context for a repository").action(async () => {
+  await create();
 });
-program
-    .command('login')
-    .description('Authenticate with RepoWise')
-    .option('--no-browser', 'Print login URL instead of opening browser')
-    .action(async (options) => {
-    const { login } = await import('../src/commands/login.js');
-    await login(options);
+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 () => {
-    const { logout } = await import('../src/commands/logout.js');
-    await logout();
+program.command("logout").description("Sign out of RepoWise").action(async () => {
+  await logout();
 });
-program
-    .command('status')
-    .description('Show current status')
-    .action(async () => {
-    const { status } = await import('../src/commands/status.js');
-    await status();
+program.command("status").description("Show current status").action(async () => {
+  await status();
 });
-program
-    .command('sync')
-    .description('Trigger a manual sync')
-    .action(async () => {
-    const { sync } = await import('../src/commands/sync.js');
-    await sync();
+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) => {
-    const { listen } = await import('../src/commands/listen.js');
-    await listen(options);
+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 () => {
-    const { start } = await import('../src/commands/start.js');
-    await start();
+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 () => {
-    const { stop } = await import('../src/commands/stop.js');
-    await stop();
+program.command("stop").description("Stop the running listener process").action(async () => {
+  await stop2();
 });
-program
-    .command('config')
-    .description('Manage configuration')
-    .action(async () => {
-    const { config } = await import('../src/commands/config.js');
-    await config();
+program.command("config").description("Manage configuration").action(async () => {
+  await config();
 });
-// Handle internal listener mode (used when spawning listener from bundled CLI)
-if (process.argv[2] === '__listener') {
-    const { startListener } = (await import('@repowise/listener/main'));
-    await startListener();
-}
-else {
-    program.parse();
+if (process.argv[2] === "__listener") {
+  await startListener();
+} else {
+  program.parse();
 }
-//# sourceMappingURL=repowise.js.map