repowise 0.1.32 → 0.1.34

package/dist/bin/repowise.js

@@ -1,102 +1,2860 @@
 #!/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);
-});
-program
-    .command('create')
-    .description('Create context for a repository')
-    .option('--context-storage <mode>', 'Context storage mode: git or server (skips prompt)')
-    .action(async (options) => {
-    const { create } = await import('../src/commands/create.js');
-    const validModes = ['git', 'server'];
-    const mode = options.contextStorage;
-    await create({
-        contextStorage: mode && validModes.includes(mode) ? mode : undefined,
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/env.ts
+function setStagingMode(value) {
+  staging = value;
+}
+function getEnvConfig() {
+  return staging ? STAGING : PRODUCTION;
+}
+var staging, PRODUCTION, STAGING;
+var init_env = __esm({
+  "src/lib/env.ts"() {
+    "use strict";
+    staging = false;
+    PRODUCTION = {
+      apiUrl: "https://api.repowise.ai",
+      cognitoDomain: "auth.repowise.ai",
+      cognitoClientId: "",
+      // TODO: set after production Cognito deploy
+      cognitoRegion: "us-east-1",
+      customDomain: true
+    };
+    STAGING = {
+      apiUrl: "https://staging-api.repowise.ai",
+      cognitoDomain: "auth-staging.repowise.ai",
+      cognitoClientId: "7h0l0dhjcb1v5erer0gaclv0q6",
+      cognitoRegion: "us-east-1",
+      customDomain: true
+    };
+  }
+});
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+async function getConfig() {
+  try {
+    const data = await readFile(CONFIG_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config2) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(config2, null, 2));
+}
+var CONFIG_DIR, CONFIG_PATH;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join(homedir(), ".repowise");
+    CONFIG_PATH = join(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/lib/auth.ts
+import { createHash, randomBytes } from "crypto";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod, unlink } from "fs/promises";
+import http from "http";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getCognitoConfig() {
+  const env = getEnvConfig();
+  return {
+    domain: process.env["REPOWISE_COGNITO_DOMAIN"] ?? env.cognitoDomain,
+    clientId: process.env["REPOWISE_COGNITO_CLIENT_ID"] ?? env.cognitoClientId,
+    region: process.env["REPOWISE_COGNITO_REGION"] ?? env.cognitoRegion,
+    customDomain: env.customDomain
+  };
+}
+function getCognitoBaseUrl() {
+  const { domain, region, customDomain } = getCognitoConfig();
+  return customDomain ? `https://${domain}` : `https://${domain}.auth.${region}.amazoncognito.com`;
+}
+function generateCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function generateState() {
+  return randomBytes(32).toString("hex");
+}
+function getAuthorizeUrl(codeChallenge, state) {
+  const { clientId } = getCognitoConfig();
+  if (!clientId) {
+    throw new Error(
+      "Missing REPOWISE_COGNITO_CLIENT_ID environment variable. Configure it before running login."
+    );
+  }
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: clientId,
+    redirect_uri: `http://localhost:${CLI_CALLBACK_PORT}/callback`,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    scope: "openid email profile",
+    state
+  });
+  return `${getCognitoBaseUrl()}/oauth2/authorize?${params.toString()}`;
+}
+function getTokenUrl() {
+  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(getTokenUrl(), {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: getCognitoConfig().clientId,
+      redirect_uri: `http://localhost:${CLI_CALLBACK_PORT}/callback`,
+      code,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function 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,
+    // Cognito does not return a new refresh token
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function getStoredCredentials() {
+  try {
+    const data = await readFile2(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_DIR2, { recursive: true, mode: 448 });
+  await writeFile2(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2));
+  await chmod(CREDENTIALS_PATH, 384);
+}
+async function clearCredentials() {
+  try {
+    await unlink(CREDENTIALS_PATH);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+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 {
+      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 storeCredentials(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" };
+  }
+}
+var CONFIG_DIR2, CREDENTIALS_PATH, CLI_CALLBACK_PORT, CALLBACK_TIMEOUT_MS;
+var init_auth = __esm({
+  "src/lib/auth.ts"() {
+    "use strict";
+    init_env();
+    CONFIG_DIR2 = join2(homedir2(), ".repowise");
+    CREDENTIALS_PATH = join2(CONFIG_DIR2, "credentials.json");
+    CLI_CALLBACK_PORT = 19876;
+    CALLBACK_TIMEOUT_MS = 12e4;
+  }
+});
+
+// src/lib/api.ts
+function getApiUrl() {
+  return process.env["REPOWISE_API_URL"] ?? getEnvConfig().apiUrl;
+}
+async function apiRequest(path, options) {
+  const credentials = await getValidCredentials();
+  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;
+}
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_auth();
+    init_env();
+  }
+});
+
+// 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 };
+  }
+}
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/ai-tools.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
+import { join as join3, dirname } from "path";
+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 = join3(repoRoot, config2.filePath);
+  const dir = dirname(fullPath);
+  if (dir !== repoRoot) {
+    await mkdir3(dir, { recursive: true });
+  }
+  const referenceBlock = generateReference(tool, repoName, contextFolder, contextFiles);
+  let existing = "";
+  let created = true;
+  try {
+    existing = await readFile3(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 writeFile3(fullPath, content, "utf-8");
+  return { created };
+}
+async function scanLocalContextFiles(repoRoot, contextFolder) {
+  const folderPath = join3(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;
+  }
+}
+var AI_TOOL_CONFIG, SUPPORTED_TOOLS;
+var init_ai_tools = __esm({
+  "src/lib/ai-tools.ts"() {
+    "use strict";
+    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"
+      }
+    };
+    SUPPORTED_TOOLS = Object.keys(AI_TOOL_CONFIG);
+  }
+});
+
+// src/lib/interview-handler.ts
+import chalk3 from "chalk";
+import { input } from "@inquirer/prompts";
+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("");
+}
+var INTERVIEW_TIMEOUT_MS, MAX_QUESTIONS, questionCounter;
+var init_interview_handler = __esm({
+  "src/lib/interview-handler.ts"() {
+    "use strict";
+    init_api();
+    INTERVIEW_TIMEOUT_MS = 5 * 60 * 1e3;
+    MAX_QUESTIONS = 10;
+    questionCounter = 0;
+  }
+});
+
+// src/lib/progress-renderer.ts
+import chalk4 from "chalk";
+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 CORE_FILES, FILE_DESCRIPTIONS, ALL_PERSONAS, PERSONA_LABELS, ProgressRenderer;
+var init_progress_renderer = __esm({
+  "src/lib/progress-renderer.ts"() {
+    "use strict";
+    CORE_FILES = /* @__PURE__ */ new Set([
+      "project-overview.md",
+      "architecture.md",
+      "data-models.md",
+      "api-contracts.md",
+      "coding-patterns.md"
+    ]);
+    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"
+    };
+    ALL_PERSONAS = ["pm", "architect", "dev", "analyst", "tea", "ux", "sm", "techWriter"];
+    PERSONA_LABELS = {
+      pm: "Product Manager",
+      architect: "Architect",
+      dev: "Developer",
+      analyst: "Business Analyst",
+      tea: "Test Architect",
+      ux: "UX Designer",
+      sm: "Scrum Master",
+      techWriter: "Tech Writer"
+    };
+    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(contextStorage, spinner) {
+        if (this.pushShown) return;
+        this.pushShown = true;
+        spinner.stop();
+        console.log("");
+        if (contextStorage === "server") {
+          console.log(chalk4.cyan.bold("  \u2500\u2500 Uploading Context \u2500\u2500"));
+          console.log(
+            `  ${chalk4.dim("Encrypting and uploading context files to RepoWise servers...")}`
+          );
+        } else {
+          console.log(chalk4.cyan.bold("  \u2500\u2500 Pushing to Repository \u2500\u2500"));
+          console.log(`  ${chalk4.dim("Committing context files to your repository...")}`);
+        }
+        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(syncResult.contextStorage, spinner);
+        }
+        spinner.text = this.getSpinnerText(syncResult);
+      }
+    };
+  }
+});
+
+// ../listener/dist/service-installer.js
+var service_installer_exports = {};
+__export(service_installer_exports, {
+  install: () => install,
+  isInstalled: () => isInstalled,
+  uninstall: () => uninstall
+});
+import { execFile } from "child_process";
+import { writeFile as writeFile4, mkdir as mkdir4, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+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"] };
+  }
+}
+function exec(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(String(stdout ?? ""));
     });
+  });
+}
+function plistPath() {
+  return join4(homedir3(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function logDir() {
+  return join4(homedir3(), ".repowise", "logs");
+}
+function buildPlist() {
+  const cmd = resolveListenerCommand();
+  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>${join4(logs, "listener-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join4(logs, "listener-stderr.log")}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>`;
+}
+async function darwinInstall() {
+  await mkdir4(logDir(), { recursive: true });
+  await mkdir4(join4(homedir3(), "Library", "LaunchAgents"), { recursive: true });
+  await writeFile4(plistPath(), buildPlist());
+  await exec("launchctl", ["load", plistPath()]);
+}
+async function darwinUninstall() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  try {
+    await unlink2(plistPath());
+  } catch {
+  }
+}
+async function darwinIsInstalled() {
+  try {
+    const stdout = await exec("launchctl", ["list"]);
+    return stdout.includes(PLIST_LABEL);
+  } catch {
+    return false;
+  }
+}
+function unitPath() {
+  return join4(homedir3(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+}
+function buildUnit() {
+  const cmd = resolveListenerCommand();
+  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:${join4(logs, "listener-stdout.log")}
+StandardError=append:${join4(logs, "listener-stderr.log")}
+
+[Install]
+WantedBy=default.target`;
+}
+async function linuxInstall() {
+  await mkdir4(logDir(), { recursive: true });
+  await mkdir4(join4(homedir3(), ".config", "systemd", "user"), { recursive: true });
+  await writeFile4(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 unlink2(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;
+  }
+}
+async function win32Install() {
+  await mkdir4(logDir(), { recursive: true });
+  const cmd = resolveListenerCommand();
+  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;
+  }
+}
+var PLIST_LABEL, SYSTEMD_SERVICE, TASK_NAME;
+var init_service_installer = __esm({
+  "../listener/dist/service-installer.js"() {
+    "use strict";
+    PLIST_LABEL = "com.repowise.listener";
+    SYSTEMD_SERVICE = "repowise-listener";
+    TASK_NAME = "RepoWise Listener";
+  }
+});
+
+// ../listener/dist/process-manager.js
+var process_manager_exports = {};
+__export(process_manager_exports, {
+  getStatus: () => getStatus,
+  isRunning: () => isRunning,
+  startBackground: () => startBackground,
+  stopProcess: () => stopProcess
+});
+import { spawn } from "child_process";
+import { openSync, closeSync } from "fs";
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir5, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join5 } 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"] };
+  }
+}
+async function readPid() {
+  try {
+    const content = await readFile4(PID_PATH, "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 mkdir5(LOG_DIR, { recursive: true });
+  const cmd = resolveListenerCommand2();
+  const stdoutFd = openSync(join5(LOG_DIR, "listener-stdout.log"), "a");
+  const stderrFd = openSync(join5(LOG_DIR, "listener-stderr.log"), "a");
+  const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
+    detached: true,
+    stdio: ["ignore", stdoutFd, stderrFd],
+    cwd: homedir4(),
+    env: { ...process.env }
+  });
+  child.unref();
+  closeSync(stdoutFd);
+  closeSync(stderrFd);
+  const pid = child.pid;
+  if (!pid)
+    throw new Error("Failed to spawn listener process");
+  await writeFile5(PID_PATH, String(pid));
+  return pid;
+}
+async function stopProcess() {
+  const pid = await readPid();
+  if (pid === null)
+    return;
+  if (!isAlive(pid)) {
+    await removePidFile();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline && isAlive(pid)) {
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (isAlive(pid)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  await removePidFile();
+}
+async function isRunning() {
+  const pid = await readPid();
+  if (pid === null)
+    return false;
+  return isAlive(pid);
+}
+async function getStatus() {
+  const pid = await readPid();
+  if (pid === null)
+    return { running: false, pid: null };
+  const alive = isAlive(pid);
+  return { running: alive, pid: alive ? pid : null };
+}
+async function removePidFile() {
+  try {
+    await unlink3(PID_PATH);
+  } catch {
+  }
+}
+var REPOWISE_DIR, PID_PATH, LOG_DIR;
+var init_process_manager = __esm({
+  "../listener/dist/process-manager.js"() {
+    "use strict";
+    REPOWISE_DIR = join5(homedir4(), ".repowise");
+    PID_PATH = join5(REPOWISE_DIR, "listener.pid");
+    LOG_DIR = join5(REPOWISE_DIR, "logs");
+  }
+});
+
+// src/commands/create.ts
+var create_exports = {};
+__export(create_exports, {
+  create: () => 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('logout')
-    .description('Sign out of RepoWise')
-    .action(async () => {
-    const { logout } = await import('../src/commands/logout.js');
-    await logout();
-});
-program
-    .command('status')
-    .description('Show current status')
-    .action(async () => {
-    const { status } = await import('../src/commands/status.js');
-    await status();
-});
-program
-    .command('sync')
-    .description('Trigger a manual sync')
-    .action(async () => {
-    const { sync } = await import('../src/commands/sync.js');
-    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('start')
-    .description('Start the listener as a background process')
-    .action(async () => {
-    const { start } = await import('../src/commands/start.js');
-    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('config')
-    .description('Manage configuration')
-    .action(async () => {
-    const { config } = await import('../src/commands/config.js');
-    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();
-}
-//# sourceMappingURL=repowise.js.map
+import { execSync } from "child_process";
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join6 } from "path";
+import chalk5 from "chalk";
+import ora from "ora";
+import { select } from "@inquirer/prompts";
+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`;
+}
+async function create(options = {}) {
+  const startTime = Date.now();
+  const spinner = ora("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials();
+    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`."
+        )
+      );
+    }
+    let contextStorage = options.contextStorage ?? "git";
+    if (!options.contextStorage) {
+      console.log("");
+      console.log(chalk5.bold("How should we deliver your context files?"));
+      console.log(
+        chalk5.dim("RepoWise generates markdown files that help AI tools understand your project \u2014")
+      );
+      console.log(
+        chalk5.dim("architecture docs, API references, patterns. No secrets or source code.")
+      );
+      console.log("");
+      contextStorage = await select({
+        message: "Context storage",
+        choices: [
+          { name: "Push to your git repo (recommended)", value: "git" },
+          { name: "Store encrypted on RepoWise servers", value: "server" }
+        ]
+      });
+      if (contextStorage === "server") {
+        console.log(
+          chalk5.yellow(
+            "\n  Warning: Server storage opts out of zero-retention. Files are encrypted (AES-256/KMS)"
+          )
+        );
+        console.log(chalk5.yellow("  and deletable anytime from your dashboard or CLI.\n"));
+      }
+    } else if (options.contextStorage === "server") {
+      console.log(chalk5.yellow("Using server-side encrypted storage (--context-storage=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 (contextStorage === "server" && 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 = join6(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          mkdirSync(contextDir, { recursive: true });
+          for (const file of files) {
+            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(join6(contextDir, file.fileName), content, "utf-8");
+            }
+          }
+          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.`
+          )
+        );
+      }
+    } else if (repoRoot) {
+      spinner.start("Pulling latest changes...");
+      try {
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          stdio: "pipe"
+        }).trim();
+        execSync(`git pull origin ${branch}`, { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" });
+        spinner.succeed("Pulled latest changes");
+      } catch (err) {
+        const stderr = err instanceof Error && "stderr" in err ? String(err.stderr).trim() : "";
+        const reason = stderr || (err instanceof Error ? err.message : "Unknown error");
+        spinner.warn(
+          chalk5.yellow(
+            `Could not pull latest changes: ${reason}
+You may need to run \`git pull\` manually.`
+          )
+        );
+      }
+    }
+    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}/. You may need to run \`git pull\` manually or re-run \`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 {
+      const { install: install2 } = await Promise.resolve().then(() => (init_service_installer(), service_installer_exports));
+      const { startBackground: startBackground2 } = await Promise.resolve().then(() => (init_process_manager(), process_manager_exports));
+      await install2();
+      await startBackground2();
+      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;
+  }
+}
+var POLL_INTERVAL_MS, MAX_POLL_ATTEMPTS, DEFAULT_CONTEXT_FOLDER;
+var init_create = __esm({
+  "src/commands/create.ts"() {
+    "use strict";
+    init_auth();
+    init_api();
+    init_prompts();
+    init_ai_tools();
+    init_config();
+    init_interview_handler();
+    init_progress_renderer();
+    POLL_INTERVAL_MS = 3e3;
+    MAX_POLL_ATTEMPTS = 600;
+    DEFAULT_CONTEXT_FOLDER = "repowise-context";
+  }
+});
+
+// src/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  login: () => login
+});
+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 storeCredentials(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;
+  }
+}
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    init_auth();
+  }
+});
+
+// src/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  logout: () => logout
+});
+import chalk7 from "chalk";
+async function logout() {
+  const creds = await getStoredCredentials();
+  if (!creds) {
+    console.log(chalk7.yellow("Not logged in."));
+    return;
+  }
+  await clearCredentials();
+  console.log(chalk7.green("Logged out successfully."));
+}
+var init_logout = __esm({
+  "src/commands/logout.ts"() {
+    "use strict";
+    init_auth();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  status: () => status
+});
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+async function status() {
+  let state = null;
+  try {
+    const data = await readFile5(STATE_PATH, "utf-8");
+    state = JSON.parse(data);
+  } catch {
+  }
+  let processRunning = false;
+  let pid = null;
+  try {
+    const { getStatus: getStatus2 } = await Promise.resolve().then(() => (init_process_manager(), process_manager_exports));
+    const processStatus = await getStatus2();
+    processRunning = processStatus.running;
+    pid = processStatus.pid;
+  } catch {
+  }
+  let serviceInstalled = false;
+  try {
+    const { isInstalled: isInstalled2 } = await Promise.resolve().then(() => (init_service_installer(), service_installer_exports));
+    serviceInstalled = await isInstalled2();
+  } 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})`);
+  }
+}
+var STATE_PATH;
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    STATE_PATH = join7(homedir5(), ".repowise", "listener-state.json");
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  sync: () => sync
+});
+function sync() {
+  console.log("Sync command - not yet implemented");
+}
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+  }
+});
+
+// ../listener/dist/lib/config.js
+import { readFile as readFile6 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+async function getListenerConfig() {
+  const apiUrl = process.env["REPOWISE_API_URL"] ?? DEFAULT_API_URL;
+  try {
+    const data = await readFile6(CONFIG_PATH2, "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: [] };
+  }
+}
+var CONFIG_DIR3, CONFIG_PATH2, DEFAULT_API_URL;
+var init_config2 = __esm({
+  "../listener/dist/lib/config.js"() {
+    "use strict";
+    CONFIG_DIR3 = join8(homedir6(), ".repowise");
+    CONFIG_PATH2 = join8(CONFIG_DIR3, "config.json");
+    DEFAULT_API_URL = "https://api.repowise.ai";
+  }
+});
+
+// ../listener/dist/lib/state.js
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir6, chmod as chmod2 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+function emptyState() {
+  return { repos: {} };
+}
+async function loadState() {
+  try {
+    const data = await readFile7(STATE_PATH2, "utf-8");
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return emptyState();
+    }
+    throw err;
+  }
+}
+async function saveState(state) {
+  await mkdir6(CONFIG_DIR4, { recursive: true, mode: 448 });
+  await writeFile6(STATE_PATH2, JSON.stringify(state, null, 2));
+  await chmod2(STATE_PATH2, 384);
+}
+var CONFIG_DIR4, STATE_PATH2;
+var init_state = __esm({
+  "../listener/dist/lib/state.js"() {
+    "use strict";
+    CONFIG_DIR4 = join9(homedir7(), ".repowise");
+    STATE_PATH2 = join9(CONFIG_DIR4, "listener-state.json");
+  }
+});
+
+// ../listener/dist/lib/auth.js
+import { readFile as readFile8, writeFile as writeFile7, mkdir as mkdir7, chmod as chmod3 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join10 } from "path";
+function getCognitoConfig2() {
+  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 getTokenUrl2() {
+  const { domain, region } = getCognitoConfig2();
+  return `https://${domain}.auth.${region}.amazoncognito.com/oauth2/token`;
+}
+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,
+    idToken: data.id_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function getStoredCredentials2() {
+  try {
+    const data = await readFile8(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 mkdir7(CONFIG_DIR5, { recursive: true, mode: 448 });
+  await writeFile7(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2));
+  await chmod3(CREDENTIALS_PATH2, 384);
+}
+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 {
+      return null;
+    }
+  }
+  return creds;
+}
+var CONFIG_DIR5, CREDENTIALS_PATH2;
+var init_auth2 = __esm({
+  "../listener/dist/lib/auth.js"() {
+    "use strict";
+    CONFIG_DIR5 = join10(homedir8(), ".repowise");
+    CREDENTIALS_PATH2 = join10(CONFIG_DIR5, "credentials.json");
+  }
+});
+
+// ../listener/dist/poll-client.js
+var POLL_TIMEOUT_MS, AuthError, PollClient;
+var init_poll_client = __esm({
+  "../listener/dist/poll-client.js"() {
+    "use strict";
+    init_auth2();
+    POLL_TIMEOUT_MS = 3e4;
+    AuthError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AuthError";
+      }
+    };
+    PollClient = class {
+      apiUrl;
+      constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+      }
+      async poll(repoIds, since) {
+        const credentials = await getValidCredentials2();
+        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, BackoffCalculator;
+var init_reconnection = __esm({
+  "../listener/dist/reconnection.js"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      initialDelay: 1e3,
+      maxDelay: 6e4,
+      jitterMax: 1e3
+    };
+    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";
+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 {
+  }
+}
+var TITLE, notify;
+var init_notification = __esm({
+  "../listener/dist/notification.js"() {
+    "use strict";
+    TITLE = "RepoWise";
+    notify = notifier.notify.bind(notifier);
+  }
+});
+
+// ../listener/dist/file-writer.js
+import { access } from "fs/promises";
+import { join as join11 } from "path";
+async function verifyContextFolder(localPath) {
+  try {
+    await access(join11(localPath, "repowise-context"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_file_writer = __esm({
+  "../listener/dist/file-writer.js"() {
+    "use strict";
+  }
+});
+
+// ../listener/dist/context-fetcher.js
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir8, writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
+import { promisify } from "util";
+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 = join12(localPath, "repowise-context");
+    await mkdir8(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 writeFile8(join12(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: [] };
+  }
+}
+var execFileAsync;
+var init_context_fetcher = __esm({
+  "../listener/dist/context-fetcher.js"() {
+    "use strict";
+    init_file_writer();
+    execFileAsync = promisify(execFile2);
+  }
+});
+
+// ../listener/dist/main.js
+var main_exports = {};
+__export(main_exports, {
+  startListener: () => startListener,
+  stop: () => stop
+});
+import { readFile as readFile9, writeFile as writeFile9, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join13 } from "path";
+async function writePidFile() {
+  await mkdir9(join13(homedir9(), ".repowise"), { recursive: true });
+  await writeFile9(PID_PATH2, String(process.pid));
+}
+async function removePidFile2() {
+  try {
+    await unlink4(PID_PATH2);
+  } catch {
+  }
+}
+async function handleStalePid() {
+  try {
+    const content = await readFile9(PID_PATH2, "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 (notif.contextStorage === "server" && 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 [, localPath] of repoLocalPaths) {
+      const 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 getValidCredentials2();
+  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 removePidFile2();
+  };
+  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);
+      if (offlineState.isOffline) {
+        await handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, config2.apiUrl, credentials?.idToken);
+        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, credentials?.idToken);
+        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 removePidFile2();
+}
+var TWENTY_FOUR_HOURS_MS, PID_PATH2, running, sleepResolve, isDirectRun;
+var init_main = __esm({
+  "../listener/dist/main.js"() {
+    "use strict";
+    init_config2();
+    init_state();
+    init_auth2();
+    init_poll_client();
+    init_reconnection();
+    init_notification();
+    init_context_fetcher();
+    TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+    PID_PATH2 = join13(homedir9(), ".repowise", "listener.pid");
+    running = false;
+    sleepResolve = null;
+    isDirectRun = process.argv[1]?.endsWith("main.js") || process.argv[1]?.endsWith("main.ts");
+    if (isDirectRun) {
+      startListener().catch((err) => {
+        console.error("Listener fatal error:", err);
+        process.exitCode = 1;
+      });
+    }
+  }
+});
+
+// src/commands/listen.ts
+var listen_exports = {};
+__export(listen_exports, {
+  listen: () => listen
+});
+async function listen(options) {
+  if (options.install) {
+    try {
+      const { install: install2 } = await Promise.resolve().then(() => (init_service_installer(), service_installer_exports));
+      await install2();
+      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 {
+      const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_service_installer(), service_installer_exports));
+      await uninstall2();
+      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 getValidCredentials();
+  if (!credentials) {
+    console.error("Not logged in. Run `repowise login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  console.log("Starting RepoWise listener...");
+  try {
+    const { startListener: startListener2 } = await Promise.resolve().then(() => (init_main(), main_exports));
+    await startListener2();
+  } catch {
+    console.error("Failed to start listener. Ensure @repowise/listener is installed.");
+    process.exitCode = 1;
+  }
+}
+var init_listen = __esm({
+  "src/commands/listen.ts"() {
+    "use strict";
+    init_auth();
+  }
+});
+
+// src/commands/start.ts
+var start_exports = {};
+__export(start_exports, {
+  start: () => start
+});
+async function start() {
+  try {
+    const { isRunning: isRunning2, startBackground: startBackground2 } = await Promise.resolve().then(() => (init_process_manager(), process_manager_exports));
+    if (await isRunning2()) {
+      console.log("Listener is already running.");
+      return;
+    }
+    const pid = await startBackground2();
+    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;
+  }
+}
+var init_start = __esm({
+  "src/commands/start.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/stop.ts
+var stop_exports = {};
+__export(stop_exports, {
+  stop: () => stop2
+});
+async function stop2() {
+  try {
+    const { isRunning: isRunning2, stopProcess: stopProcess2 } = await Promise.resolve().then(() => (init_process_manager(), process_manager_exports));
+    if (!await isRunning2()) {
+      console.log("Listener is not running.");
+      return;
+    }
+    await stopProcess2();
+    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;
+  }
+}
+var init_stop = __esm({
+  "src/commands/stop.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/config.ts
+var config_exports = {};
+__export(config_exports, {
+  config: () => config
+});
+import chalk8 from "chalk";
+import ora3 from "ora";
+import { select as select2 } from "@inquirer/prompts";
+async function config() {
+  const spinner = ora3("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials();
+    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");
+    }
+    spinner.start("Loading repositories...");
+    const repos = await apiRequest("/v1/repos");
+    spinner.stop();
+    if (repos.length === 0) {
+      console.log(chalk8.yellow("No repositories connected. Run `repowise create` first."));
+      return;
+    }
+    const repoId = await select2({
+      message: "Select a repository to configure",
+      choices: repos.map((r) => ({
+        name: `${r.fullName} (storage: ${r.contextStorage ?? "git"})`,
+        value: r.repoId
+      }))
+    });
+    const repo = repos.find((r) => r.repoId === repoId);
+    const currentStorage = repo.contextStorage ?? "git";
+    const currentDelivery = repo.deliveryMode ?? "direct";
+    const currentBranch = repo.monitoredBranch ?? repo.defaultBranch;
+    console.log("");
+    console.log(chalk8.bold(`Settings for ${repo.fullName}`));
+    console.log(chalk8.dim(`  Context storage: ${currentStorage}`));
+    console.log(chalk8.dim(`  Delivery mode:   ${currentDelivery}`));
+    console.log(chalk8.dim(`  Monitored branch: ${currentBranch}`));
+    console.log("");
+    const setting = await select2({
+      message: "What would you like to change?",
+      choices: [
+        { name: `Context storage (current: ${currentStorage})`, value: "contextStorage" },
+        { name: `Delivery mode (current: ${currentDelivery})`, value: "deliveryMode" },
+        { name: `Monitored branch (current: ${currentBranch})`, value: "monitoredBranch" }
+      ]
+    });
+    const patch = {};
+    if (setting === "contextStorage") {
+      const newStorage = await select2({
+        message: "Context storage",
+        choices: [
+          { name: "Push to your git repo", value: "git" },
+          { name: "Store encrypted on RepoWise servers", value: "server" }
+        ],
+        default: currentStorage
+      });
+      if (newStorage === currentStorage) {
+        console.log(chalk8.dim("No change."));
+        return;
+      }
+      if (newStorage === "server") {
+        console.log(
+          chalk8.yellow(
+            "\n  Warning: Server storage opts out of zero-retention. Files are encrypted (AES-256/KMS)"
+          )
+        );
+        console.log(chalk8.yellow("  and deletable anytime from your dashboard or CLI.\n"));
+      }
+      if (newStorage === "git" && currentStorage === "server") {
+        console.log(chalk8.cyan("\n  Note: Existing server-stored files will be deleted."));
+        console.log(chalk8.cyan("  A new sync will push context files to your git repo.\n"));
+      }
+      patch.contextStorage = newStorage;
+    } else if (setting === "deliveryMode") {
+      const newMode = await select2({
+        message: "Delivery mode",
+        choices: [
+          { name: "Direct push to branch", value: "direct" },
+          { name: "Create pull request", value: "pr" }
+        ],
+        default: currentDelivery
+      });
+      if (newMode === currentDelivery) {
+        console.log(chalk8.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(chalk8.dim("No change."));
+        return;
+      }
+      patch.monitoredBranch = newBranch;
+    }
+    spinner.start("Saving...");
+    await apiRequest(`/v1/repos/${repoId}`, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+    spinner.succeed(chalk8.green("Setting updated"));
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : "Config failed";
+    console.error(chalk8.red(message));
+    process.exitCode = 1;
+  }
+}
+var init_config3 = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_auth();
+    init_api();
+  }
+});
+
+// bin/repowise.ts
+init_env();
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join14 } from "path";
+import { Command } from "commander";
+
+// src/lib/welcome.ts
+init_config();
+import chalk from "chalk";
+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 {
+  }
+}
+
+// bin/repowise.ts
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname = dirname2(__filename);
+var pkg = JSON.parse(readFileSync(join14(__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").option("--context-storage <mode>", "Context storage mode: git or server (skips prompt)").action(async (options) => {
+  const { create: create2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+  const validModes = ["git", "server"];
+  const mode = options.contextStorage;
+  await create2({
+    contextStorage: mode && validModes.includes(mode) ? mode : void 0
+  });
+});
+program.command("login").description("Authenticate with RepoWise").option("--no-browser", "Print login URL instead of opening browser").action(async (options) => {
+  const { login: login2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+  await login2(options);
+});
+program.command("logout").description("Sign out of RepoWise").action(async () => {
+  const { logout: logout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+  await logout2();
+});
+program.command("status").description("Show current status").action(async () => {
+  const { status: status2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  await status2();
+});
+program.command("sync").description("Trigger a manual sync").action(async () => {
+  const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  sync2();
+});
+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: listen2 } = await Promise.resolve().then(() => (init_listen(), listen_exports));
+  await listen2(options);
+});
+program.command("start").description("Start the listener as a background process").action(async () => {
+  const { start: start2 } = await Promise.resolve().then(() => (init_start(), start_exports));
+  await start2();
+});
+program.command("stop").description("Stop the running listener process").action(async () => {
+  const { stop: stop3 } = await Promise.resolve().then(() => (init_stop(), stop_exports));
+  await stop3();
+});
+program.command("config").description("Manage configuration").action(async () => {
+  const { config: config2 } = await Promise.resolve().then(() => (init_config3(), config_exports));
+  await config2();
+});
+if (process.argv[2] === "__listener") {
+  const { startListener: startListener2 } = await Promise.resolve().then(() => (init_main(), main_exports));
+  await startListener2();
+} else {
+  program.parse();
+}