codowave 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# Codowave CLI
+
+AI-powered coding agent for your GitHub repos.
+
+## Installation
+
+```bash
+npm install -g codowave
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the CLI
+pnpm --filter codowave build
+
+# Run in development mode
+pnpm --filter codowave dev
+```
+
+## Publishing to npm
+
+This package is published to npm using GitHub Actions. The workflow is defined in `.github/workflows/npm-publish.yml`.
+
+### Publishing a new version
+
+**Option 1: Push a tag**
+```bash
+# Create a tag with the version
+git tag cli/v0.1.0
+git push origin cli/v0.1.0
+```
+
+**Option 2: Manual workflow dispatch**
+1. Go to [Actions > Publish CLI to npm](https://github.com/CodowaveAI/Codowave/actions/workflows/npm-publish.yml)
+2. Click "Run workflow"
+3. Enter the version bump (patch, minor, major) or specific version
+4. Click "Run workflow"
+
+### Required secrets
+
+To publish to npm, you need to set up the following secrets in your repository:
+
+1. **NPM_TOKEN**: An npm access token with publish permissions
+   - Create at: https://www.npmjs.com/settings/<your-username>/tokens
+   - Add to: https://github.com/CodowaveAI/Codowave/settings/secrets/actions
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,1166 @@
+#!/usr/bin/env node
+#!/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/utils/error.ts
+import pc from "picocolors";
+function getErrorMessage(err) {
+  if (err instanceof CodowaveError) {
+    return err.getFormattedMessage();
+  }
+  if (err instanceof Error) {
+    const message = err.message;
+    if (message.includes("ECONNREFUSED") || message.includes("ENOTFOUND")) {
+      return `Unable to connect to the Codowave API. Please check your internet connection and try again.`;
+    }
+    if (message.includes("401") || message.includes("unauthorized")) {
+      return `Authentication failed. Please run 'codowave init' to re-authenticate.`;
+    }
+    if (message.includes("403") || message.includes("forbidden")) {
+      return `Access denied. You don't have permission to perform this action.`;
+    }
+    if (message.includes("404") || message.includes("not found")) {
+      return `The requested resource was not found. Please check the repository or issue number and try again.`;
+    }
+    if (message.includes("rate limit")) {
+      return `Rate limit exceeded. Please wait a moment and try again.`;
+    }
+    return message;
+  }
+  return String(err);
+}
+function handleError(err, context) {
+  const message = getErrorMessage(err);
+  const prefix = context ? `[${context}] ` : "";
+  console.error(`
+${pc.red("\u2716")} ${prefix}${message}
+`);
+  if (err instanceof CodowaveError && err.code) {
+    console.error(pc.gray(`Error code: ${err.code}`));
+  }
+  if (process.env.NODE_ENV === "development" && err instanceof Error && err.stack) {
+    console.error(pc.gray(err.stack));
+  }
+  process.exit(1);
+}
+var CodowaveError, ConfigError, APIError, ErrorCodes;
+var init_error = __esm({
+  "src/utils/error.ts"() {
+    "use strict";
+    CodowaveError = class extends Error {
+      constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = "CodowaveError";
+      }
+      /**
+       * Returns a formatted error message with optional context
+       */
+      getFormattedMessage() {
+        let msg = this.message;
+        if (this.context && Object.keys(this.context).length > 0) {
+          msg += `
+
+Context: ${JSON.stringify(this.context, null, 2)}`;
+        }
+        return msg;
+      }
+    };
+    ConfigError = class extends CodowaveError {
+      constructor(message, context) {
+        super(message, "CONFIG_ERROR", context);
+        this.name = "ConfigError";
+      }
+    };
+    APIError = class extends CodowaveError {
+      constructor(message, statusCode, context) {
+        super(message, "API_ERROR", context);
+        this.statusCode = statusCode;
+        this.name = "APIError";
+      }
+    };
+    ErrorCodes = {
+      CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+      INVALID_CONFIG: "INVALID_CONFIG",
+      REPO_NOT_CONFIGURED: "REPO_NOT_CONFIGURED",
+      API_ERROR: "API_ERROR",
+      NETWORK_ERROR: "NETWORK_ERROR",
+      AUTH_ERROR: "AUTH_ERROR",
+      INVALID_ISSUE_FORMAT: "INVALID_ISSUE_FORMAT",
+      RUN_FAILED: "RUN_FAILED"
+    };
+  }
+});
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { z } from "zod";
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const json = JSON.parse(raw);
+    const parsed = ConfigSchema.safeParse(json);
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+      console.warn(`[config] Config validation failed:
+${issues}`);
+      return null;
+    }
+    return parsed.data;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`[config] Failed to read ${CONFIG_FILE}: ${message}`);
+    return null;
+  }
+}
+function readConfigOrThrow() {
+  const config = readConfig();
+  if (!config) {
+    throw new ConfigError(
+      "No Codowave config found. Run `codowave init` to get started.",
+      { suggestion: "Run 'codowave init' to configure your API key and repositories" }
+    );
+  }
+  return config;
+}
+function writeConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function updateConfig(updates) {
+  const current = readConfig() ?? {
+    apiKey: "",
+    apiUrl: "https://api.codowave.com",
+    repos: []
+  };
+  const merged = {
+    ...current,
+    ...updates
+  };
+  writeConfig(merged);
+  return merged;
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+var AIProviderSchema, ConfigSchema, CONFIG_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_error();
+    AIProviderSchema = z.object({
+      provider: z.enum(["openai", "anthropic", "minimax", "ollama", "custom"]),
+      apiKey: z.string().min(1),
+      model: z.string().default(""),
+      baseUrl: z.string().url().optional()
+    });
+    ConfigSchema = z.object({
+      apiKey: z.string().min(1),
+      apiUrl: z.string().url().default("https://api.codowave.com"),
+      repos: z.array(
+        z.object({
+          owner: z.string(),
+          name: z.string(),
+          id: z.string().optional()
+        })
+      ).default([]),
+      ai: AIProviderSchema.optional()
+    });
+    CONFIG_DIR = join(homedir(), ".codowave");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/components/init/GithubAppStep.tsx
+import { useState, useEffect } from "react";
+import {
+  Box,
+  Text,
+  useInput
+} from "ink";
+import Spinner from "ink-spinner";
+import pc3 from "picocolors";
+import { jsx, jsxs } from "react/jsx-runtime";
+var GithubAppStep;
+var init_GithubAppStep = __esm({
+  "src/components/init/GithubAppStep.tsx"() {
+    "use strict";
+    GithubAppStep = ({ apiUrl, onComplete, onCancel }) => {
+      const [step, setStep] = useState("api-key");
+      const [apiKey, setApiKey] = useState("");
+      const [repos, setRepos] = useState([]);
+      const [selectedRepos, setSelectedRepos] = useState(/* @__PURE__ */ new Set());
+      const [currentSelection, setCurrentSelection] = useState(0);
+      const [loading, setLoading] = useState(false);
+      const [error, setError] = useState(null);
+      useEffect(() => {
+        if (step === "repos" && apiKey && repos.length === 0 && !loading) {
+          fetchRepos();
+        }
+      }, [step, apiKey]);
+      async function fetchRepos() {
+        setLoading(true);
+        setError(null);
+        try {
+          const response = await fetch(`${apiUrl}/api/v1/repos`, {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            if (response.status === 401) {
+              throw new Error("Invalid API key. Please check and try again.");
+            }
+            throw new Error(`Failed to fetch repositories: ${response.status}`);
+          }
+          const data = await response.json();
+          const fetchedRepos = data.repos || data.repositories || [];
+          setRepos(fetchedRepos);
+          if (fetchedRepos.length > 0) {
+            const allIndices = /* @__PURE__ */ new Set();
+            for (let i = 0; i < fetchedRepos.length; i++) {
+              allIndices.add(i);
+            }
+            setSelectedRepos(allIndices);
+          }
+        } catch (err) {
+          setError(err instanceof Error ? err.message : "Failed to fetch repositories");
+        } finally {
+          setLoading(false);
+        }
+      }
+      function handleApiKeySubmit() {
+        if (!apiKey.trim()) {
+          setError("API key cannot be empty");
+          return;
+        }
+        setError(null);
+        setStep("repos");
+      }
+      function handleConfirm() {
+        const selected = Array.from(selectedRepos).map((i) => repos[i]).filter((repo) => repo !== void 0);
+        onComplete(apiKey, selected);
+      }
+      function handleGoBack() {
+        setStep("api-key");
+        setError(null);
+      }
+      useInput((input, key) => {
+        if (step === "api-key") {
+          if (key.return) {
+            handleApiKeySubmit();
+            return;
+          }
+          if (key.escape) {
+            onCancel();
+            return;
+          }
+          if (key.backspace || input === "\b") {
+            setApiKey((prev) => prev.slice(0, -1));
+            setError(null);
+            return;
+          }
+          if (input && !key.ctrl && !key.meta) {
+            setApiKey((prev) => prev + input);
+            setError(null);
+            return;
+          }
+        } else if (step === "repos") {
+          if (key.escape) {
+            handleGoBack();
+            return;
+          }
+          if (key.return) {
+            handleConfirm();
+            return;
+          }
+          if (input === " ") {
+            toggleRepo(currentSelection);
+            return;
+          }
+          if (key.upArrow) {
+            setCurrentSelection((prev) => Math.max(0, prev - 1));
+            return;
+          }
+          if (key.downArrow) {
+            setCurrentSelection((prev) => Math.min(repos.length - 1, prev + 1));
+            return;
+          }
+          if (input === "a" || input === "A") {
+            const allIndices = /* @__PURE__ */ new Set();
+            for (let i = 0; i < repos.length; i++) {
+              allIndices.add(i);
+            }
+            setSelectedRepos(allIndices);
+            return;
+          }
+          if (input === "n" || input === "N") {
+            setSelectedRepos(/* @__PURE__ */ new Set());
+            return;
+          }
+        }
+      });
+      function toggleRepo(index) {
+        const newSelected = new Set(selectedRepos);
+        if (newSelected.has(index)) {
+          newSelected.delete(index);
+        } else {
+          newSelected.add(index);
+        }
+        setSelectedRepos(newSelected);
+      }
+      if (step === "api-key") {
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 1, children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u2550\u2550\u2550 GitHub App Setup \u2550\u2550\u2550" }) }),
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { children: "Enter your Codowave API key:" }) }),
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "> " }),
+            /* @__PURE__ */ jsx(Text, { children: apiKey }),
+            /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+          ] }),
+          error && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: pc3.red("\u2716 " + error) }) }),
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "Press ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "Enter" }),
+            " to continue, ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "Esc" }),
+            " to cancel"
+          ] }) })
+        ] });
+      }
+      if (step === "repos") {
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 1, children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u2550\u2550\u2550 Select Repositories \u2550\u2550\u2550" }) }),
+          loading && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+            /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+            " Loading repositories..."
+          ] }) }),
+          error && /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: pc3.red("\u2716 " + error) }) }),
+          !loading && !error && repos.length === 0 && /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "No repositories found for this API key." }) }),
+          !loading && repos.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: repos.map((repo, index) => /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { children: index === currentSelection ? " > " : "   " }),
+            /* @__PURE__ */ jsxs(Text, { color: selectedRepos.has(index) ? "green" : "gray", children: [
+              "[",
+              selectedRepos.has(index) ? "\u2713" : " ",
+              "]"
+            ] }),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            /* @__PURE__ */ jsx(Text, { bold: index === currentSelection, children: /* @__PURE__ */ jsxs(Text, { dimColor: !selectedRepos.has(index), children: [
+              repo.owner,
+              "/",
+              repo.name
+            ] }) })
+          ] }, index)) }),
+          !loading && repos.length > 0 && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "\u2191/\u2193" }),
+            " navigate | ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "Space" }),
+            " toggle | ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "A" }),
+            " all | ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "N" }),
+            " none"
+          ] }) }),
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "Selected: ",
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "green", children: selectedRepos.size }),
+            " / ",
+            repos.length,
+            " repos | ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "Enter" }),
+            " confirm | ",
+            /* @__PURE__ */ jsx(Text, { bold: true, children: "Esc" }),
+            " back"
+          ] }) })
+        ] });
+      }
+      return null;
+    };
+  }
+});
+
+// src/commands/init.tsx
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import { Command } from "commander";
+import pc4 from "picocolors";
+import { render } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var initCommand;
+var init_init = __esm({
+  "src/commands/init.tsx"() {
+    "use strict";
+    init_config();
+    init_GithubAppStep();
+    initCommand = new Command("init").description("Initialize Codowave and connect your GitHub repositories").action(async () => {
+      const existingConfig = readConfig();
+      const defaultApiUrl = "https://api.codowave.com";
+      const apiUrl = existingConfig?.apiUrl || defaultApiUrl;
+      if (existingConfig?.apiKey) {
+        console.log(pc4.yellow("\n\u26A0 Codowave is already initialized.\n"));
+        console.log(`  API URL: ${pc4.cyan(existingConfig.apiUrl)}`);
+        console.log(`  Config: ${getConfigPath()}`);
+        console.log(pc4.gray("\n  Run this command again to reconfigure.\n"));
+        return;
+      }
+      let wizardComplete = false;
+      let capturedApiKey = "";
+      let capturedRepos = [];
+      const { waitUntilExit } = render(
+        /* @__PURE__ */ jsx2(
+          GithubAppStep,
+          {
+            apiUrl,
+            onComplete: (apiKey, repos) => {
+              capturedApiKey = apiKey;
+              capturedRepos = repos;
+              wizardComplete = true;
+            },
+            onCancel: () => {
+              process.exit(0);
+            }
+          }
+        )
+      );
+      await waitUntilExit();
+      if (!wizardComplete) {
+        return;
+      }
+      writeConfig({
+        apiKey: capturedApiKey,
+        apiUrl,
+        repos: capturedRepos
+      });
+      console.log(pc4.green("\n\u2713 Initialization complete!"));
+      console.log(`
+  Config saved to: ${pc4.cyan(getConfigPath())}`);
+      console.log(`  API URL: ${pc4.cyan(apiUrl)}`);
+      console.log(`  Repositories: ${pc4.bold(capturedRepos.length)} configured
+`);
+      console.log(pc4.gray("  Run ") + pc4.bold("codowave run") + pc4.gray(" to start coding!\n"));
+    });
+  }
+});
+
+// src/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  runCommand: () => runCommand
+});
+import { Command as Command2 } from "commander";
+import pc5 from "picocolors";
+function parseIssue(input) {
+  const urlMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
+  if (urlMatch && urlMatch[1] && urlMatch[2] && urlMatch[3]) {
+    return { owner: urlMatch[1], repo: urlMatch[2], number: parseInt(urlMatch[3], 10) };
+  }
+  const repoMatch = input.match(/([^/]+)\/([^#]+)#(\d+)/);
+  if (repoMatch && repoMatch[1] && repoMatch[2] && repoMatch[3]) {
+    return { owner: repoMatch[1], repo: repoMatch[2], number: parseInt(repoMatch[3], 10) };
+  }
+  const numMatch = input.match(/^(\d+)$/);
+  if (numMatch && numMatch[1]) {
+    return { owner: "", repo: "", number: parseInt(numMatch[1], 10) };
+  }
+  return null;
+}
+async function triggerRun(config, issue) {
+  const apiUrl = config.apiUrl;
+  const apiKey = config.apiKey;
+  const repoConfig = config.repos.find(
+    (r) => r.owner === issue.owner && r.name === issue.repo
+  );
+  if (!repoConfig) {
+    throw new ConfigError(
+      `Repository ${issue.owner}/${issue.repo} is not configured.`,
+      {
+        suggestion: `Run 'codowave config add-repo ${issue.owner}/${issue.repo}' to add this repository`,
+        configuredRepos: config.repos.map((r) => `${r.owner}/${r.name}`)
+      }
+    );
+  }
+  let response;
+  try {
+    response = await fetch(`${apiUrl}/api/runs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        repositoryId: repoConfig.id,
+        issueNumber: issue.number
+      })
+    });
+  } catch {
+    throw new CodowaveError(
+      `Failed to connect to Codowave API at ${apiUrl}`,
+      ErrorCodes.NETWORK_ERROR,
+      { suggestion: "Check your internet connection and verify the API URL in your config." }
+    );
+  }
+  if (!response.ok) {
+    let errorMessage = `API returned status ${response.status}`;
+    let errorBody = {};
+    try {
+      errorBody = await response.json();
+      errorMessage = errorBody.error || errorBody.message || errorMessage;
+    } catch {
+      errorMessage = response.statusText || errorMessage;
+    }
+    if (response.status === 401) {
+      throw new CodowaveError(
+        `Authentication failed: ${errorMessage}`,
+        ErrorCodes.AUTH_ERROR,
+        { suggestion: "Run 'codowave init' to re-authenticate." }
+      );
+    }
+    if (response.status === 403) {
+      throw new CodowaveError(
+        `Access denied: ${errorMessage}`,
+        ErrorCodes.AUTH_ERROR,
+        { suggestion: "You don't have permission to trigger runs for this repository." }
+      );
+    }
+    if (response.status === 404) {
+      throw new CodowaveError(
+        `Resource not found: ${errorMessage}`,
+        ErrorCodes.API_ERROR,
+        { suggestion: "The repository or issue may no longer exist." }
+      );
+    }
+    const errorText = await response.text();
+    throw new APIError(
+      `Failed to trigger run: ${response.status} ${response.statusText}`,
+      response.status,
+      { response: errorText, issueNumber: issue.number, repo: `${issue.owner}/${issue.repo}` }
+    );
+  }
+  const data = await response.json();
+  return data.runId;
+}
+function createDemoRun(issue) {
+  const runId = `run-${Date.now()}`;
+  const run = {
+    id: runId,
+    repo: issue.owner && issue.repo ? `${issue.owner}/${issue.repo}` : "CodowaveAI/Codowave",
+    status: "in_progress",
+    issue: `#${issue.number}`,
+    branchName: `agent/issue-${issue.number}`,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stages: [
+      { name: "context", status: "pending" },
+      { name: "planning", status: "pending" },
+      { name: "implementation", status: "pending" },
+      { name: "testing", status: "pending" },
+      { name: "pr-creation", status: "pending" }
+    ]
+  };
+  demoRuns.set(runId, run);
+  return run;
+}
+function streamDemoRun(run) {
+  const stages = ["context", "planning", "implementation", "testing", "pr-creation"];
+  let currentStage = 0;
+  console.log(pc5.bold("\n=== Starting Run ===\n"));
+  console.log(pc5.bold("Run ID:   ") + run.id);
+  console.log(pc5.bold("Repo:     ") + run.repo);
+  console.log(pc5.bold("Issue:    ") + run.issue);
+  console.log(pc5.bold("Branch:   ") + run.branchName);
+  console.log("");
+  const interval = setInterval(() => {
+    if (currentStage >= stages.length) {
+      clearInterval(interval);
+      run.status = "completed";
+      run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      run.prNumber = 100 + Math.floor(Math.random() * 50);
+      run.prTitle = `feat: Implement issue #${run.issue}`;
+      console.log(pc5.green("\n\u2713 Run completed successfully!"));
+      console.log(pc5.bold("\n=== Result ===\n"));
+      console.log(pc5.bold("PR:       ") + `#${run.prNumber} - ${run.prTitle}`);
+      console.log(pc5.bold("Branch:   ") + run.branchName);
+      console.log("");
+      process.exit(0);
+      return;
+    }
+    const stageName = stages[currentStage];
+    const stage = run.stages.find((s) => s.name === stageName);
+    if (stage) {
+      stage.status = "running";
+      console.log(pc5.blue(`
+--- ${stageName} ---`));
+      setTimeout(() => {
+        stage.status = "completed";
+        stage.logs = `${stageName} completed successfully`;
+        currentStage++;
+      }, 1e3 + Math.random() * 2e3);
+    } else {
+      currentStage++;
+    }
+  }, 500);
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    run.status = "cancelled";
+    console.log(pc5.yellow("\n\n\u26A0 Run cancelled"));
+    process.exit(1);
+  });
+}
+var demoRuns, runCommand;
+var init_run = __esm({
+  "src/commands/run.ts"() {
+    "use strict";
+    init_config();
+    init_error();
+    demoRuns = /* @__PURE__ */ new Map();
+    runCommand = new Command2("run").description("Trigger Codowave to process a GitHub issue").argument("<issue>", "GitHub issue number, URL (https://github.com/owner/repo/issues/123), or owner/repo#123").option("-r, --repo <owner/repo>", "Target repository (e.g. owner/repo)").option("-s, --stream", "Stream run progress (SSE)", false).action(async (_issueArg, _options) => {
+      try {
+        const parsed = parseIssue(_issueArg);
+        if (!parsed) {
+          console.error(pc5.red("\nInvalid issue format. Expected one of:"));
+          console.error(pc5.gray("  \u2022 Issue number: 123"));
+          console.error(pc5.gray("  \u2022 Full URL: https://github.com/owner/repo/issues/123"));
+          console.error(pc5.gray("  \u2022 Short form: owner/repo#123"));
+          console.error(pc5.gray("  \u2022 With repo flag: --repo owner/repo 123"));
+          process.exit(1);
+        }
+        if (_options.repo) {
+          const parts = _options.repo.split("/");
+          parsed.owner = parts[0] || "";
+          parsed.repo = parts[1] || "";
+        }
+        let config = null;
+        try {
+          config = readConfig();
+        } catch {
+        }
+        if (config && config.apiKey && config.repos.length > 0) {
+          console.log(pc5.blue("Connecting to Codowave API..."));
+          if (!parsed.owner || !parsed.repo) {
+            console.error(pc5.red("Repository required. Use -r option or include in issue URL."));
+            process.exit(1);
+          }
+          const runId = await triggerRun(config, parsed);
+          console.log(pc5.green(`\u2713 Run triggered: ${runId}`));
+          if (_options.stream) {
+            console.log(pc5.blue("\nStreaming run progress..."));
+          } else {
+            console.log(pc5.gray(`
+Run started. Use \`codowave status ${runId}\` to check progress.`));
+          }
+        } else {
+          console.log(pc5.yellow("\u26A0 No config found. Running in demo mode.\n"));
+          const run = createDemoRun(parsed);
+          if (_options.stream || !process.stdout.isTTY) {
+            streamDemoRun(run);
+          } else {
+            console.log(pc5.green(`\u2713 Run started: ${run.id}`));
+            console.log(pc5.gray(`
+Use \`codowave status ${run.id}\` to check progress.`));
+            console.log(pc5.gray(`Use \`codowave logs ${run.id} -f\` to follow logs.`));
+          }
+        }
+      } catch (err) {
+        handleError(err, "run");
+      }
+    });
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  getRun: () => getRun,
+  statusCommand: () => statusCommand
+});
+import { Command as Command3 } from "commander";
+import pc6 from "picocolors";
+function initDemoData() {
+  if (demoRuns2.size === 0) {
+    const demoRun = {
+      id: "latest",
+      repo: "CodowaveAI/Codowave",
+      status: "in_progress",
+      issue: "#53: Implement CLI status and logs commands",
+      branchName: "agent/issue-53",
+      startedAt: new Date(Date.now() - 5 * 60 * 1e3).toISOString(),
+      stages: [
+        { name: "context", status: "completed", logs: "Loaded 12 files, 3 PRs context" },
+        { name: "planning", status: "completed", logs: "Generated implementation plan" },
+        { name: "implementation", status: "running", logs: "Implementing status command..." },
+        { name: "testing", status: "pending" },
+        { name: "pr-creation", status: "pending" }
+      ]
+    };
+    demoRuns2.set(demoRun.id, demoRun);
+    const completedRun = {
+      id: "abc-123-def",
+      repo: "CodowaveAI/Codowave",
+      status: "completed",
+      issue: "#52: Add authentication flow",
+      prNumber: 78,
+      prTitle: "feat: Add OAuth authentication flow",
+      branchName: "feat/auth-flow",
+      startedAt: new Date(Date.now() - 60 * 60 * 1e3).toISOString(),
+      completedAt: new Date(Date.now() - 45 * 60 * 1e3).toISOString(),
+      stages: [
+        { name: "context", status: "completed" },
+        { name: "planning", status: "completed" },
+        { name: "implementation", status: "completed" },
+        { name: "testing", status: "completed" },
+        { name: "pr-creation", status: "completed" }
+      ]
+    };
+    demoRuns2.set(completedRun.id, completedRun);
+  }
+}
+function getRun(runId) {
+  initDemoData();
+  if (!runId) {
+    return Array.from(demoRuns2.values()).sort(
+      (a, b) => new Date(b.startedAt || 0).getTime() - new Date(a.startedAt || 0).getTime()
+    )[0];
+  }
+  return demoRuns2.get(runId);
+}
+function formatStatus(status) {
+  switch (status) {
+    case "pending":
+      return pc6.gray("pending");
+    case "in_progress":
+      return pc6.blue("in_progress");
+    case "completed":
+      return pc6.green("completed");
+    case "failed":
+      return pc6.red("failed");
+    case "cancelled":
+      return pc6.gray("cancelled");
+    default:
+      return pc6.gray(status);
+  }
+}
+function formatStageStatus(status) {
+  switch (status) {
+    case "pending":
+      return pc6.gray("[ ]");
+    case "running":
+      return pc6.blue("[~]");
+    case "completed":
+      return pc6.green("[+]");
+    case "failed":
+      return pc6.red("[x]");
+    case "skipped":
+      return pc6.gray("[-]");
+    default:
+      return pc6.gray("[?]");
+  }
+}
+function formatDuration(startedAt, completedAt) {
+  if (!startedAt) return "";
+  const start = new Date(startedAt).getTime();
+  const end = completedAt ? new Date(completedAt).getTime() : Date.now();
+  const seconds = Math.floor((end - start) / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+var demoRuns2, statusCommand;
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_error();
+    demoRuns2 = /* @__PURE__ */ new Map();
+    statusCommand = new Command3("status").description("Show the status of a Codowave run").argument("[run-id]", "Run ID (defaults to latest)").option("-r, --repo <owner/repo>", "Filter by repository").action(async (_runId, _options) => {
+      try {
+        const run = getRun(_runId);
+        if (!run) {
+          console.log(pc6.yellow("No runs found. Run `codowave run <issue>` to start a new run."));
+          return;
+        }
+        if (_options?.repo && run.repo !== _options.repo) {
+          console.log(pc6.yellow("No run found for repository " + _options.repo));
+          return;
+        }
+        console.log(pc6.bold("\n=== Run Status ===\n"));
+        console.log(pc6.bold("ID:       ") + run.id);
+        console.log(pc6.bold("Repo:     ") + run.repo);
+        console.log(pc6.bold("Issue:    ") + run.issue);
+        console.log(pc6.bold("Status:   ") + formatStatus(run.status));
+        console.log(pc6.bold("Branch:   ") + (run.branchName || pc6.gray("(none)")));
+        if (run.prNumber) {
+          console.log(pc6.bold("PR:       ") + "#" + run.prNumber + " - " + (run.prTitle || ""));
+        }
+        if (run.startedAt) {
+          console.log(pc6.bold("Started:  ") + new Date(run.startedAt).toLocaleString());
+        }
+        if (run.completedAt) {
+          console.log(pc6.bold("Duration: ") + formatDuration(run.startedAt, run.completedAt));
+        } else if (run.startedAt) {
+          console.log(pc6.bold("Duration: ") + pc6.blue("running... ") + formatDuration(run.startedAt));
+        }
+        if (run.errorMessage) {
+          console.log(pc6.bold("Error:    ") + pc6.red(run.errorMessage));
+        }
+        console.log(pc6.bold("\n=== Stages ===\n"));
+        for (const stage of run.stages) {
+          const statusIcon = formatStageStatus(stage.status);
+          const statusText = pc6.bold("[" + stage.status + "]");
+          console.log("  " + statusIcon + " " + pc6.bold(stage.name.padEnd(20)) + " " + statusText);
+        }
+        console.log("");
+      } catch (err) {
+        handleError(err, "status");
+      }
+    });
+  }
+});
+
+// src/commands/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  logsCommand: () => logsCommand
+});
+import { Command as Command4 } from "commander";
+import pc7 from "picocolors";
+var logsCommand;
+var init_logs = __esm({
+  "src/commands/logs.ts"() {
+    "use strict";
+    init_status();
+    init_error();
+    logsCommand = new Command4("logs").description("Stream logs for a Codowave run").argument("[run-id]", "Run ID (defaults to latest)").option("-f, --follow", "Follow log output (SSE stream)").option("-s, --stage <name>", "Show logs for a specific stage").option("--no-color", "Disable colored output").action(async (_runId, _options) => {
+      try {
+        const run = getRun(_runId);
+        if (!run) {
+          console.log(pc7.yellow("No runs found. Run `codowave run <issue>` to start a new run."));
+          return;
+        }
+        if (_options?.stage) {
+          const stage = run.stages.find((s) => s.name === _options.stage);
+          if (!stage) {
+            console.log(pc7.red('Stage "' + _options.stage + '" not found.'));
+            console.log(pc7.gray("Available stages: ") + run.stages.map((s) => s.name).join(", "));
+            return;
+          }
+          console.log(pc7.bold("\n=== Logs: " + stage.name + " ===\n"));
+          console.log(pc7.bold("Status: ") + stage.status);
+          if (stage.logs) {
+            console.log(pc7.gray("\n--- Output ---\n"));
+            console.log(stage.logs);
+          } else {
+            console.log(pc7.gray("\n(no logs available yet)"));
+          }
+          if (_options.follow && stage.status === "running") {
+            console.log(pc7.blue("\n--- Following live logs (Ctrl+C to exit) ---\n"));
+            console.log(pc7.gray("(Live streaming would connect to API SSE endpoint in production)"));
+          }
+          console.log("");
+          return;
+        }
+        console.log(pc7.bold("\n=== Logs: " + run.id + " ===\n"));
+        console.log(pc7.bold("Issue: ") + run.issue);
+        console.log(pc7.bold("Status: ") + run.status);
+        console.log("");
+        for (const stage of run.stages) {
+          const statusIcon = stage.status === "completed" ? "[+]" : stage.status === "failed" ? "[x]" : stage.status === "running" ? "[~]" : "[ ]";
+          console.log(pc7.bold("\n" + statusIcon + " " + stage.name + "\n"));
+          if (stage.logs) {
+            console.log(stage.logs);
+          } else if (stage.status === "pending") {
+            console.log(pc7.gray("(pending)"));
+          } else if (stage.status === "running") {
+            console.log(pc7.blue("(running...)"));
+          } else if (stage.status === "skipped") {
+            console.log(pc7.gray("(skipped)"));
+          }
+        }
+        if (_options?.follow && run.status === "in_progress") {
+          console.log(pc7.blue("\n--- Following live logs (Ctrl+C to exit) ---\n"));
+          console.log(pc7.gray("(Live streaming would connect to API SSE endpoint in production)"));
+          let dots = 0;
+          const interval = setInterval(() => {
+            dots = (dots + 1) % 4;
+            process.stdout.write(pc7.blue("\r" + "   ".repeat(dots) + " waiting for updates..."));
+          }, 500);
+          process.on("SIGINT", () => {
+            clearInterval(interval);
+            console.log(pc7.gray("\n\n(Stopped following)"));
+            process.exit(0);
+          });
+        }
+        console.log("");
+      } catch (err) {
+        handleError(err, "logs");
+      }
+    });
+  }
+});
+
+// src/commands/config-cmd.ts
+var config_cmd_exports = {};
+__export(config_cmd_exports, {
+  configCommand: () => configCommand
+});
+import { Command as Command5 } from "commander";
+import pc8 from "picocolors";
+var configCommand;
+var init_config_cmd = __esm({
+  "src/commands/config-cmd.ts"() {
+    "use strict";
+    init_config();
+    configCommand = new Command5("config").description("Get or set Codowave configuration values");
+    configCommand.command("list").description("List all available config options").action(() => {
+      console.log(pc8.bold("\n\u{1F4CB} Available Config Options:\n"));
+      console.log(`  ${pc8.cyan("apiKey")}       ${pc8.gray("\u2014 Your Codowave API key")}`);
+      console.log(`  ${pc8.cyan("apiUrl")}       ${pc8.gray("\u2014 API endpoint URL (default: https://api.codowave.com)")}`);
+      console.log(`  ${pc8.cyan("repos")}        ${pc8.gray("\u2014 List of configured repositories")}`);
+      console.log(`  ${pc8.cyan("configPath")}   ${pc8.gray("\u2014 Path to the config file")}`);
+      console.log("");
+    });
+    configCommand.command("get <key>").description("Get a config value").action((key) => {
+      try {
+        const config = readConfigOrThrow();
+        if (key === "configPath") {
+          console.log(pc8.green(getConfigPath()));
+          return;
+        }
+        if (key === "repos") {
+          if (config.repos.length === 0) {
+            console.log(pc8.yellow("No repos configured."));
+          } else {
+            console.log(pc8.bold("\n\u{1F4E6} Configured Repositories:\n"));
+            config.repos.forEach((repo, index) => {
+              console.log(`  ${index + 1}. ${pc8.cyan(`${repo.owner}/${repo.name}`)}`);
+              if (repo.id) {
+                console.log(`     ${pc8.gray("ID: " + repo.id)}`);
+              }
+            });
+            console.log("");
+          }
+          return;
+        }
+        const value = config[key];
+        if (value === void 0) {
+          console.error(pc8.red(`\u2716 Unknown config key: ${key}`));
+          console.log(pc8.gray(`  Run \`codowave config list\` to see available options.`));
+          process.exit(1);
+        }
+        console.log(value);
+      } catch (err) {
+        console.error(pc8.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+    configCommand.command("set <key> <value>").description("Set a config value").action((key, value) => {
+      try {
+        const validKeys = ["apiKey", "apiUrl"];
+        if (!validKeys.includes(key)) {
+          console.error(pc8.red(`\u2716 Cannot set '${key}' directly.`));
+          console.log(pc8.gray(`  For 'repos', use \`codowave init\` to manage repositories.`));
+          console.log(pc8.gray(`  Run \`codowave config list\` to see available options.`));
+          process.exit(1);
+        }
+        if (key === "apiUrl") {
+          try {
+            new URL(value);
+          } catch {
+            console.error(pc8.red(`\u2716 Invalid URL: ${value}`));
+            process.exit(1);
+          }
+        }
+        const updates = { [key]: value };
+        const newConfig = updateConfig(updates);
+        console.log(pc8.green(`\u2713 Updated ${key}`));
+        console.log(pc8.gray(`  ${key} = ${newConfig[key]}`));
+      } catch (err) {
+        console.error(pc8.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+    configCommand.command("show").description("Show all current config values").action(() => {
+      try {
+        const config = readConfigOrThrow();
+        console.log(pc8.bold("\n\u2699\uFE0F  Current Configuration:\n"));
+        console.log(`  ${pc8.cyan("apiKey")}:       ${config.apiKey ? pc8.green("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022") + pc8.gray(" (hidden)") : pc8.yellow("not set")}`);
+        console.log(`  ${pc8.cyan("apiUrl")}:       ${config.apiUrl}`);
+        console.log(`  ${pc8.cyan("repos")}:        ${config.repos.length} repository(s) configured`);
+        console.log(`  ${pc8.cyan("configPath")}:  ${pc8.gray(getConfigPath())}`);
+        if (config.repos.length > 0) {
+          console.log(pc8.bold(pc8.gray("\n  Repositories:")));
+          config.repos.forEach((repo) => {
+            console.log(`    \u2022 ${repo.owner}/${repo.name}${repo.id ? pc8.gray(` (${repo.id})`) : ""}`);
+          });
+        }
+        console.log("");
+      } catch (err) {
+        console.error(pc8.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+    configCommand.action(() => {
+      configCommand.help();
+    });
+  }
+});
+
+// src/commands/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  connectCommand: () => connectCommand,
+  performConnect: () => performConnect
+});
+import { Command as Command6 } from "commander";
+import pc9 from "picocolors";
+async function performConnect(accessToken) {
+  const config = updateConfig({
+    apiKey: accessToken,
+    apiUrl: PRO_API_URL
+  });
+  console.log(pc9.green("\u2713 Connected to Codowave Pro!"));
+  console.log(pc9.gray(`  API URL: ${config.apiUrl}`));
+}
+var PRO_API_URL, connectCommand;
+var init_connect = __esm({
+  "src/commands/connect.ts"() {
+    "use strict";
+    init_config();
+    PRO_API_URL = "https://api.codowave.com";
+    connectCommand = new Command6("connect").description("Connect to Codowave Pro (upgrade from OSS)").action(async () => {
+      try {
+        console.log(pc9.bold("\n\u{1F517} Codowave Connect\n"));
+        console.log(pc9.gray("This command upgrades your OSS installation to Codowave Pro.\n"));
+        const config = readConfig();
+        const isAlreadyPro = config?.apiUrl === PRO_API_URL;
+        if (isAlreadyPro) {
+          console.log(pc9.green("\u2713 You are already connected to Codowave Pro!"));
+          console.log(pc9.gray(`  API URL: ${config?.apiUrl}`));
+          console.log("");
+          return;
+        }
+        console.log(pc9.blue("Starting OAuth device flow...\n"));
+        console.log(pc9.gray("  1. Requesting device code..."));
+        const deviceCode = `CODOWAVE-${Date.now().toString(36).toUpperCase()}`;
+        const verificationUri = "https://codowave.com/activate";
+        console.log(pc9.green("\n  \u26A0\uFE0F  Device Code: ") + pc9.bold(deviceCode));
+        console.log(pc9.gray("\n  2. Please visit: ") + pc9.cyan(verificationUri));
+        console.log(pc9.gray("     and enter the device code above.\n"));
+        console.log(pc9.yellow("  \u2139\uFE0F  This is a stub implementation."));
+        console.log(pc9.gray("     In production, this would poll for OAuth completion.\n"));
+        console.log(pc9.blue("  3. Would save Pro token and switch API URL...\n"));
+        console.log(pc9.bold("What would happen:\n"));
+        console.log(`  \u2022 Save Pro API token to ${getConfigPath()}`);
+        console.log(`  \u2022 Set apiUrl to ${PRO_API_URL}`);
+        console.log("");
+        console.log(pc9.gray("Run with ") + pc9.cyan("CODOWAVE_CONNECT=1") + pc9.gray(" to enable (not implemented yet)"));
+        console.log("");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(pc9.red(`
+\u2716 Error: ${message}
+`));
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/index.ts
+init_config();
+import { Command as Command7 } from "commander";
+import pc10 from "picocolors";
+
+// src/utils/global-error.ts
+init_error();
+import process2 from "process";
+import pc2 from "picocolors";
+function setupGlobalErrorHandlers() {
+  process2.on("uncaughtException", (err) => {
+    console.error(pc2.red("\n\u{1F4A5} Unexpected Error"));
+    console.error(pc2.gray(err.stack || ""));
+    handleError(err, "uncaughtException");
+  });
+  process2.on("unhandledRejection", (reason, _promise) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    const stack = reason instanceof Error ? reason.stack : void 0;
+    console.error(pc2.red("\n\u{1F4A5} Unhandled Promise Rejection"));
+    if (stack) {
+      console.error(pc2.gray(stack));
+    } else {
+      console.error(pc2.gray(`Reason: ${message}`));
+    }
+    console.error(pc2.yellow("\nWarning: Unhandled promise rejections can cause instability."));
+    console.error(pc2.gray("Please report this issue: https://github.com/CodowaveAI/Codowave/issues"));
+    process2.exit(1);
+  });
+}
+
+// src/index.ts
+setupGlobalErrorHandlers();
+var { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+var { runCommand: runCommand2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+var { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+var { logsCommand: logsCommand2 } = await Promise.resolve().then(() => (init_logs(), logs_exports));
+var { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config_cmd(), config_cmd_exports));
+var { connectCommand: connectCommand2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
+var VERSION = "0.1.0";
+var program = new Command7();
+program.name("codowave").description(
+  pc10.bold("Codowave") + " \u2014 AI-powered coding agent for your GitHub repositories"
+).version(VERSION, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help").addHelpText(
+  "beforeAll",
+  `
+${pc10.cyan("  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557    \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
+${pc10.cyan("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D")}
+${pc10.cyan("  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  ")}
+${pc10.cyan("  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
+`
+).option("--api-url <url>", "Override the Codowave API URL");
+program.addCommand(initCommand2);
+program.addCommand(runCommand2);
+program.addCommand(statusCommand2);
+program.addCommand(logsCommand2);
+program.addCommand(configCommand2);
+program.addCommand(connectCommand2);
+program.configureOutput({
+  writeErr: (str) => process.stderr.write(pc10.red(str))
+});
+var args = process.argv.slice(2);
+var isInitOrHelp = args[0] === "init" || args.includes("--help") || args.includes("-h") || args.includes("--version") || args.includes("-v") || args.length === 0;
+if (!isInitOrHelp) {
+  const config = readConfig();
+  if (!config) {
+    console.warn(
+      pc10.yellow(
+        "\u26A0  No config found. Run " + pc10.bold("codowave init") + " to get started.\n"
+      )
+    );
+  }
+}
+program.parseAsync(process.argv).catch((err) => {
+  console.error(pc10.red(`
+\u2716 Error: ${err instanceof Error ? err.message : String(err)}
+`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "codowave",
+  "version": "0.1.0",
+  "description": "Codowave OSS CLI — AI-powered coding agent for your GitHub repos",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "codowave": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ink": "^5.0.1",
+    "ink-spinner": "^5.0.0",
+    "picocolors": "^1.1.0",
+    "react": "^18.3.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.1",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}