kodingo-cli 1.0.13 → 1.0.15

package/dist/commands/init.js

@@ -2,9 +2,11 @@
 /**
  * kodingo init
  *
- * Interactively configures ~/.kodingo/config.json.
- * Supports both local (psql) and cloud (kodingo-api) modes.
- * On successful cloud init, ensures .kortex/ is in .gitignore.
+ * GitHub-style browser-based authentication and project connection.
+ * - First time on a machine: opens browser to login, saves auth token globally
+ * - Subsequent runs: skips login, goes straight to project selection
+ * - Project selection: type project name, case-insensitive match
+ * - Create new project if name not found
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,142 +47,231 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInitCommand = registerInitCommand;
 const readline = __importStar(require("node:readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const open_1 = __importDefault(require("open"));
 const persistence_config_1 = require("../utils/persistence-config");
-const path_1 = __importDefault(require("path"));
-const scan_repo_1 = require("./scan-repo");
-const fs_1 = __importDefault(require("fs"));
+const API_BASE = "https://kodingo-api.onrender.com";
+const APP_URL = "https://kodingo.xyz";
+const CONFIG_DIR = path.join(os.homedir(), ".kodingo");
+const AUTH_TOKEN_PATH = path.join(CONFIG_DIR, "auth.json");
+// ── Auth token storage ────────────────────────────────────────────────────────
+function readAuthToken() {
+    try {
+        if (fs.existsSync(AUTH_TOKEN_PATH)) {
+            const data = JSON.parse(fs.readFileSync(AUTH_TOKEN_PATH, "utf-8"));
+            return data.token ?? null;
+        }
+    }
+    catch { }
+    return null;
+}
+function saveAuthToken(token, email) {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(AUTH_TOKEN_PATH, JSON.stringify({ token, email }, null, 2), "utf-8");
+}
+function readAuthEmail() {
+    try {
+        if (fs.existsSync(AUTH_TOKEN_PATH)) {
+            const data = JSON.parse(fs.readFileSync(AUTH_TOKEN_PATH, "utf-8"));
+            return data.email ?? '';
+        }
+    }
+    catch { }
+    return '';
+}
+// ── Prompt helper ─────────────────────────────────────────────────────────────
+function prompt(rl, question) {
+    return new Promise(resolve => rl.question(question, ans => resolve(ans.trim())));
+}
+// ── Repo root finder ──────────────────────────────────────────────────────────
 function findRepoRoot(startPath) {
     let current = startPath;
     while (true) {
-        if (fs_1.default.existsSync(path_1.default.join(current, ".git")))
+        if (fs.existsSync(path.join(current, ".git")))
             return current;
-        const parent = path_1.default.dirname(current);
+        const parent = path.dirname(current);
         if (parent === current)
             return startPath;
         current = parent;
     }
 }
-// ── Prompt helper ─────────────────────────────────────────────────────────────
-function prompt(rl, question) {
-    return new Promise((resolve) => rl.question(question, (ans) => resolve(ans.trim())));
-}
-// ── Health check ──────────────────────────────────────────────────────────────
-async function verifyCloudConnection(apiUrl, token) {
-    const url = `${apiUrl.replace(/\/$/, "")}/health`;
-    const res = await fetch(url, { headers: { "X-Kodingo-Token": token } });
-    if (!res.ok)
-        throw new Error(`Health check failed (${res.status}) — check your API URL`);
-}
 // ── .gitignore helper ─────────────────────────────────────────────────────────
 function ensureGitignoreEntry(repoRoot, entry) {
-    const gitignorePath = path_1.default.join(repoRoot, ".gitignore");
+    const gitignorePath = path.join(repoRoot, ".gitignore");
     const line = entry.endsWith("\n") ? entry : `${entry}\n`;
-    if (fs_1.default.existsSync(gitignorePath)) {
-        const contents = fs_1.default.readFileSync(gitignorePath, "utf-8");
-        if (contents.split("\n").some((l) => l.trim() === entry.trim()))
+    if (fs.existsSync(gitignorePath)) {
+        const contents = fs.readFileSync(gitignorePath, "utf-8");
+        if (contents.split("\n").some(l => l.trim() === entry.trim()))
             return;
-        fs_1.default.appendFileSync(gitignorePath, `\n# Kortex — auto-generated context file\n${line}`, "utf-8");
+        fs.appendFileSync(gitignorePath, `\n# Kortex\n${line}`, "utf-8");
     }
     else {
-        fs_1.default.writeFileSync(gitignorePath, `# Kortex — auto-generated context file\n${line}`, "utf-8");
+        fs.writeFileSync(gitignorePath, `# Kortex\n${line}`, "utf-8");
     }
 }
-// ── Command ───────────────────────────────────────────────────────────────────
-async function runInitialScan(repoRoot) {
+// ── Browser login flow ────────────────────────────────────────────────────────
+async function browserLogin(rl) {
+    // Request a state token from the API
+    const initRes = await fetch(`${API_BASE}/cli/auth/init`, { method: "POST" });
+    if (!initRes.ok)
+        throw new Error("Failed to start login flow");
+    const { state, loginUrl } = await initRes.json();
+    console.log("\nPress Enter to open kodingo.xyz in your browser...");
+    console.log(`Or open this URL manually: ${loginUrl}\n`);
+    await new Promise(resolve => {
+        rl.question("", () => resolve());
+    });
+    // Open browser
     try {
-        console.log("\n🔍 Scanning existing codebase for functions without memory...");
-        const captured = await (0, scan_repo_1.scanRepoCommand)({ repo: repoRoot, silent: false });
-        if (captured === 0) {
-            console.log("  No existing functions found — Kortex will capture them as you write and commit code.");
-        }
+        await (0, open_1.default)(loginUrl);
     }
-    catch {
-        // Never fail init because of a scan error
+    catch { }
+    console.log("Waiting for login...");
+    // Poll for completion
+    const start = Date.now();
+    while (Date.now() - start < 5 * 60 * 1000) {
+        await new Promise(r => setTimeout(r, 2000));
+        const pollRes = await fetch(`${API_BASE}/cli/auth/poll/${state}`);
+        if (!pollRes.ok)
+            continue;
+        const data = await pollRes.json();
+        if (data.status === "complete" && data.token) {
+            return { token: data.token, email: data.email ?? "" };
+        }
     }
+    throw new Error("Login timed out. Please try again.");
 }
+// ── Fetch accessible projects ─────────────────────────────────────────────────
+async function fetchProjects(authToken) {
+    const res = await fetch(`${API_BASE}/cli/projects`, {
+        headers: { Authorization: `Bearer ${authToken}` },
+    });
+    if (!res.ok)
+        throw new Error("Failed to fetch projects. Please run `kodingo init` again.");
+    const data = await res.json();
+    return data.projects ?? [];
+}
+// ── Create a new project ──────────────────────────────────────────────────────
+async function createProject(authToken, name, orgId) {
+    const res = await fetch(`${API_BASE}/cli/projects`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${authToken}` },
+        body: JSON.stringify({ name, orgId }),
+    });
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(data.error ?? "Failed to create project");
+    return data;
+}
+// ── Command ───────────────────────────────────────────────────────────────────
 function registerInitCommand(program) {
     program
         .command("init")
-        .description("Configure kodingo CLI (local psql or cloud API)")
-        .option("--local", "Switch to local mode (psql)")
-        .option("--cloud", "Switch to cloud mode (kodingo-api)")
-        .option("--api-url <url>", "Cloud API URL (skips prompt)")
-        .option("--token <token>", "Cloud API token (skips prompt)")
+        .description("Connect this repository to a Kodingo project")
+        .option("--logout", "Log out and clear saved credentials")
         .action(async (opts) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         try {
-            const current = (0, persistence_config_1.readConfig)();
-            // ── Non-interactive flags ─────────────────────────────────────────────
-            if (opts.local) {
-                (0, persistence_config_1.writeConfig)({ mode: "local" });
-                console.log("✔ Switched to local mode — using local psql database.");
+            // ── Logout ──────────────────────────────────────────────────────────
+            if (opts.logout) {
+                if (fs.existsSync(AUTH_TOKEN_PATH))
+                    fs.unlinkSync(AUTH_TOKEN_PATH);
+                console.log("✔ Logged out of Kodingo.");
                 return;
             }
-            if (opts.cloud && opts.apiUrl && opts.token) {
-                console.log("Verifying connection to kodingo-api...");
-                await verifyCloudConnection(opts.apiUrl, opts.token);
-                (0, persistence_config_1.writeConfig)({
-                    mode: "cloud",
-                    apiUrl: opts.apiUrl,
-                    token: opts.token,
-                });
-                const repoRoot = findRepoRoot(process.cwd());
-                ensureGitignoreEntry(repoRoot, ".kortex/");
-                console.log(`✔ Cloud mode configured. Config saved to ${persistence_config_1.CONFIG_PATH}`);
-                // Auto-scan existing codebase silently
-                await runInitialScan(repoRoot);
-                return;
+            // ── Check if already logged in ───────────────────────────────────────
+            let authToken = readAuthToken();
+            let email = readAuthEmail();
+            if (authToken) {
+                console.log(`\n✔ Already logged in as ${email || "your Kodingo account"}\n`);
             }
-            // ── Interactive flow ──────────────────────────────────────────────────
-            console.log("\nKodingo CLI Setup\n");
-            console.log(`Current mode: ${current.mode}`);
-            if (current.apiUrl)
-                console.log(`Current API URL: ${current.apiUrl}`);
-            console.log();
-            const modeInput = await prompt(rl, "Choose mode — (l)ocal or (c)loud [default: local]: ");
-            const mode = modeInput.toLowerCase().startsWith("c")
-                ? "cloud"
-                : "local";
-            if (mode === "local") {
-                (0, persistence_config_1.writeConfig)({ mode: "local" });
-                console.log("\n✔ Local mode configured. Using local psql database.");
-                return;
+            else {
+                console.log("\nKodingo — Connect this repository\n");
+                const result = await browserLogin(rl);
+                authToken = result.token;
+                email = result.email;
+                saveAuthToken(authToken, email);
+                console.log(`\n✔ Logged in as ${email}\n`);
             }
-            // Cloud mode — collect API URL and token
-            const defaultUrl = current.apiUrl ?? "";
-            const apiUrlInput = await prompt(rl, `API URL${defaultUrl ? ` [${defaultUrl}]` : ""}: `);
-            const apiUrl = apiUrlInput || defaultUrl;
-            if (!apiUrl) {
-                console.error("✖ API URL is required for cloud mode.");
+            // ── Fetch projects ───────────────────────────────────────────────────
+            const projects = await fetchProjects(authToken);
+            // ── Ask for project name ─────────────────────────────────────────────
+            const projectName = await prompt(rl, "Enter the project name to connect to this repo: ");
+            if (!projectName) {
+                console.error("✖ Project name is required.");
                 process.exit(1);
             }
-            const tokenInput = await prompt(rl, "API Token (X-Kodingo-Token): ");
-            const token = tokenInput || current.token || "";
-            if (!token) {
-                console.error("✖ API token is required for cloud mode.");
-                process.exit(1);
+            // ── Case-insensitive search ──────────────────────────────────────────
+            const normalised = projectName.toLowerCase().trim();
+            const matches = projects.filter(p => p.name.toLowerCase().trim() === normalised);
+            let selectedProject = null;
+            if (matches.length === 1) {
+                selectedProject = matches[0];
+                console.log(`\n✔ Found project: ${selectedProject.name} (${matches[0].org_name} · ${matches[0].plan} plan)\n`);
+            }
+            else if (matches.length > 1) {
+                // Multiple orgs with same project name — ask which one
+                console.log("\nMultiple projects found with that name:");
+                matches.forEach((p, i) => console.log(`  ${i + 1}. ${p.name} — ${p.org_name}`));
+                const choice = await prompt(rl, "Enter number: ");
+                const idx = parseInt(choice) - 1;
+                if (idx < 0 || idx >= matches.length) {
+                    console.error("✖ Invalid choice.");
+                    process.exit(1);
+                }
+                selectedProject = matches[idx];
             }
-            console.log("\nVerifying connection to kodingo-api...");
-            await verifyCloudConnection(apiUrl, token);
-            const config = { mode: "cloud", apiUrl, token };
-            (0, persistence_config_1.writeConfig)(config);
-            // Save workspace-specific config scoped to this repo
+            else {
+                // No match — offer to create
+                console.log(`\n  No project named "${projectName}" found in your account.`);
+                const create = await prompt(rl, "Would you like to create it? (y/n): ");
+                if (!create.toLowerCase().startsWith("y")) {
+                    console.log("✖ Cancelled.");
+                    process.exit(0);
+                }
+                // If user has multiple orgs, ask which one
+                const orgs = [...new Map(projects.map(p => [p.org_id, { id: p.org_id, name: p.org_name }])).values()];
+                let orgId = orgs[0]?.id;
+                if (orgs.length > 1) {
+                    console.log("\nSelect an organisation:");
+                    orgs.forEach((o, i) => console.log(`  ${i + 1}. ${o.name}`));
+                    const orgChoice = await prompt(rl, "Enter number: ");
+                    const orgIdx = parseInt(orgChoice) - 1;
+                    if (orgIdx < 0 || orgIdx >= orgs.length) {
+                        console.error("✖ Invalid choice.");
+                        process.exit(1);
+                    }
+                    orgId = orgs[orgIdx].id;
+                }
+                const created = await createProject(authToken, projectName, orgId);
+                selectedProject = created;
+                console.log(`\n✔ Project "${created.name}" created\n`);
+            }
+            // ── Save config ──────────────────────────────────────────────────────
             const repoRoot = findRepoRoot(process.cwd());
-            (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, { mode: "cloud", apiUrl, token });
-            // Ensure .kortex/ is gitignored — it's a generated file, not source
+            const apiUrl = API_BASE;
+            (0, persistence_config_1.writeConfig)({ mode: "cloud", apiUrl, token: selectedProject.token });
+            (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, { mode: "cloud", apiUrl, token: selectedProject.token });
             ensureGitignoreEntry(repoRoot, ".kortex/");
-            console.log(`\n✔ Cloud mode configured successfully.`);
-            console.log(`  API URL : ${apiUrl}`);
-            console.log(`  Config  : ${persistence_config_1.CONFIG_PATH}`);
-            console.log("\nYou're ready to use kodingo with the cloud API.");
-            // Auto-scan existing codebase for functions without memory
-            await runInitialScan(repoRoot);
+            console.log(`✔ Connected. Token saved to ${persistence_config_1.CONFIG_PATH}`);
+            console.log("\nKortex is now watching this repo.");
+            console.log("Run `kodingo install-hook` to capture memories on every commit.\n");
+            // Auto-scan existing codebase
+            try {
+                const { scanRepoCommand } = await Promise.resolve().then(() => __importStar(require("./scan-repo")));
+                console.log("🔍 Scanning existing codebase for functions without memory...");
+                const captured = await scanRepoCommand({ repo: repoRoot, silent: false });
+                if (captured === 0) {
+                    console.log("  No existing functions found — Kortex will capture them as you write and commit code.");
+                }
+            }
+            catch { }
         }
         catch (err) {
-            console.error(`\n✖ Init failed: ${err.message}`);
+            console.error(`\n✖ ${err.message}`);
             process.exit(1);
         }
         finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,
@@ -24,12 +24,13 @@
     "@babel/traverse": "^7.29.0",
     "commander": "^12.1.0",
     "kodingo-core": "^0.1.0",
+    "open": "^11.0.0",
     "simple-git": "^3.30.0",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.28.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^22.19.20",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.6.0"
   }