@pentatonic-ai/ai-agent-sdk 0.5.11 → 0.7.0

package/bin/cli.js

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
 
 import { createInterface } from "readline";
-import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
 
 const DEFAULT_ENDPOINT = "https://api.pentatonic.com";
 
@@ -31,8 +27,14 @@ function parseArgs() {
       flags.alert = true;
     } else if (a === "--no-plugins") {
       flags.noPlugins = true;
+    } else if (a === "--engine-url" && args[i + 1]) {
+      flags.engineUrl = args[++i];
+    } else if (a.startsWith("--engine-url=")) {
+      flags.engineUrl = a.split("=")[1];
     } else if (!a.startsWith("--")) {
-      flags.command = a;
+      // First non-flag arg is the command; subsequent ones are subcommand
+      // arguments handled by the dispatched cmd (e.g. `ingest <path>`).
+      if (!flags.command) flags.command = a;
     }
   }
   return flags;
@@ -64,8 +66,6 @@ async function runDoctorCommand(flags) {
   if (report.summary.warning > 0) return 1;
   return 0;
 }
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 300000; // 5 minutes
 
 let rl = createInterface({ input: process.stdin, output: process.stdout });
 
@@ -73,243 +73,125 @@ function ask(question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
 
-function askSecret(question) {
-  // Non-TTY fallback: piped/redirected input can't use raw mode.
-  // rl.close() would discard buffered stdin, so use readline directly instead.
-  if (!process.stdin.isTTY) {
-    return new Promise((resolve) => rl.question(question, resolve));
-  }
-
-  return new Promise((resolve) => {
-    // Close readline so it stops echoing input
-    rl.close();
-
-    process.stdout.write(question);
-    const stdin = process.stdin;
-    stdin.setRawMode(true);
-    stdin.resume();
-
-    let input = "";
-    const onData = (ch) => {
-      const c = ch.toString();
-      if (c === "\n" || c === "\r") {
-        stdin.removeListener("data", onData);
-        stdin.setRawMode(false);
-        stdin.pause();
-        process.stdout.write("\n");
-        // Recreate readline for subsequent prompts
-        rl = createInterface({ input: process.stdin, output: process.stdout });
-        resolve(input);
-      } else if (c === "\u007f" || c === "\b") {
-        if (input.length > 0) {
-          input = input.slice(0, -1);
-          process.stdout.write("\b \b");
-        }
-      } else if (c === "\u0003") {
-        process.exit(1);
-      } else {
-        input += c;
-        process.stdout.write("*");
-      }
-    };
-    stdin.on("data", onData);
-  });
-}
-
-function askChoice(question, choices) {
-  return new Promise((resolve) => {
-    const choiceStr = choices.map((c, i) => `  ${i + 1}) ${c}`).join("\n");
-    process.stdout.write(`${question}\n${choiceStr}\n`);
-    rl.question("? Choice: ", (answer) => {
-      const idx = parseInt(answer, 10) - 1;
-      if (idx >= 0 && idx < choices.length) {
-        resolve(choices[idx]);
-      } else {
-        const match = choices.find(
-          (c) => c.toLowerCase() === answer.trim().toLowerCase()
-        );
-        resolve(match || choices[0]);
-      }
-    });
-  });
-}
-
-function spinner(text) {
-  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-  let i = 0;
-  const id = setInterval(() => {
-    process.stdout.write(`\r${frames[i++ % frames.length]} ${text}`);
-  }, 80);
-  return {
-    stop(result) {
-      clearInterval(id);
-      process.stdout.write(`\r✓ ${result}\n`);
-    },
-    fail(msg) {
-      clearInterval(id);
-      process.stdout.write(`\r✗ ${msg}\n`);
-    },
-  };
-}
-
-async function httpPost(url, body) {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
-  const data = await response.json();
-  return { status: response.status, ok: response.ok, data };
-}
-
-async function graphql(endpoint, token, query, variables) {
-  const response = await fetch(`${endpoint}/api/graphql`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({ query, variables }),
-  });
-  const data = await response.json();
-  if (data.errors?.length) {
-    throw new Error(data.errors[0].message);
-  }
-  return data.data;
-}
-
-function toClientId(companyName) {
-  return companyName
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "");
-}
+// setupLocalMemory + its `spinner` helper were the legacy "bring up
+// Postgres + Ollama" wrapper for the in-process memory server. Removed
+// in favour of:
+//   - `tes config local`  → writes the plugin config + prints engine
+//                           bring-up instructions
+//   - `cd packages/memory-engine && docker compose up -d` → runs the
+//                           actual engine
+// `ask` is kept for any future interactive prompts.
 
-async function setupLocalMemory() {
-  console.log(`\n  Local Memory Setup\n`);
 
-  // Check Docker
-  try {
-    execFileSync("docker", ["info"], { stdio: "pipe" });
-  } catch {
-    console.error("  Error: Docker is required. Install it from https://docker.com\n");
-    process.exit(1);
-  }
-
-  const memoryDir = new URL("../packages/memory", import.meta.url).pathname;
+async function main() {
+  const flags = parseArgs();
+  const TES_ENDPOINT = flags.endpoint || DEFAULT_ENDPOINT;
 
-  // Start infrastructure + memory server
-  const infraSpinner = spinner("Starting memory server + PostgreSQL + Ollama...");
-  try {
-    execFileSync("docker", ["compose", "up", "-d", "memory", "postgres", "ollama"], {
-      cwd: memoryDir,
-      stdio: "pipe",
-    });
-    infraSpinner.stop("Memory stack running!");
-  } catch (err) {
-    infraSpinner.fail(`Failed to start: ${err.message}`);
-    process.exit(1);
+  if (flags.command === "doctor") {
+    const code = await runDoctorCommand(flags);
+    rl.close();
+    process.exit(code);
   }
 
-  // Pull models
-  const embModel = process.env.EMBEDDING_MODEL || "nomic-embed-text";
-  const llmModel = process.env.LLM_MODEL || "llama3.2:3b";
-
-  const embSpinner = spinner(`Pulling ${embModel}...`);
-  try {
-    execFileSync("docker", ["compose", "exec", "ollama", "ollama", "pull", embModel], {
-      cwd: memoryDir,
-      stdio: "pipe",
+  // SDK login (browser-based OAuth) — replaces the old in-terminal
+  // setupHostedTes flow. `login` opens api.pentatonic.com/cli-init in
+  // a browser, listens on localhost for the OAuth callback, exchanges
+  // for an access token, mints a long-lived tes_* via createClientApiToken,
+  // writes ~/.config/tes/credentials.json. `init` is kept as a one-major
+  // alias (Task 10).
+  if (flags.command === "login") {
+    const { runLoginCommand } = await import("./commands/login.js");
+    const { exitCode } = await runLoginCommand({
+      endpoint: TES_ENDPOINT,
     });
-    embSpinner.stop(`${embModel} ready!`);
-  } catch {
-    embSpinner.fail(`Failed to pull ${embModel}. Run manually: docker compose exec ollama ollama pull ${embModel}`);
+    rl.close();
+    process.exit(exitCode);
   }
 
-  const llmSpinner = spinner(`Pulling ${llmModel}...`);
-  try {
-    execFileSync("docker", ["compose", "exec", "ollama", "ollama", "pull", llmModel], {
-      cwd: memoryDir,
-      stdio: "pipe",
+  // SDK login identity check. Named `whoami` rather than `status`
+  // because the corpus subcommand `tes status` already exists (shows
+  // tracked repos). Matches the standard CLI convention for "who am
+  // I logged in as" and avoids the conflict.
+  if (flags.command === "whoami") {
+    const { runWhoamiCommand } = await import("./commands/whoami.js");
+    const { exitCode } = await runWhoamiCommand();
+    rl.close();
+    process.exit(exitCode);
+  }
+
+  // tes config <local|hosted|show> — point Claude Code's tes-memory
+  // plugin at a memory backend, or inspect what's configured. Each
+  // subcommand is a thin scaffold:
+  //   local  → write mode: local + memory_url; print engine bring-up steps
+  //   hosted → run the login flow (delegates to runLoginCommand)
+  //   show   → read and print the current plugin config
+  // Future: `tes config set <key> <value>` for engine env-var tweaks.
+  if (flags.command === "config") {
+    const sub = process.argv.slice(3).find((a) => !a.startsWith("--"));
+    const { runConfigCommand } = await import("./commands/config.js");
+    const { exitCode } = await runConfigCommand({
+      sub,
+      endpoint: TES_ENDPOINT,
+      engineUrl: flags.engineUrl,
     });
-    llmSpinner.stop(`${llmModel} ready!`);
-  } catch {
-    llmSpinner.fail(`Failed to pull ${llmModel}. Run manually: docker compose exec ollama ollama pull ${llmModel}`);
-  }
-
-  // Write local config (warn if hosted config exists)
-  const configDir = join(homedir(), ".claude-pentatonic");
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-
-  const configPath = join(configDir, "tes-memory.local.md");
-  if (existsSync(configPath)) {
-    const existing = readFileSync(configPath, "utf-8");
-    if (existing.includes("tes_endpoint") && !existing.includes("mode: local")) {
-      console.log("\n  ⚠ Hosted TES config detected. Switching to local mode will");
-      console.log("  disable hosted memory. To restore, run: npx @pentatonic-ai/ai-agent-sdk init\n");
-      const confirm = await ask("  Switch to local mode? (y/n): ");
-      if (confirm.toLowerCase() !== "y") {
-        console.log("  Cancelled. Hosted config unchanged.\n");
-        rl.close();
-        return;
+    rl.close();
+    process.exit(exitCode);
+  }
+
+  // Corpus subcommands — onboarding/repo ingest (spec 01)
+  const CORPUS_COMMANDS = new Set([
+    "onboard", "ingest", "status", "resync", "corpus",
+    "install-git-hook", "ingest-paths",
+  ]);
+  if (CORPUS_COMMANDS.has(flags.command)) {
+    const corpusCli = await import("../packages/memory/src/corpus/cli.js");
+    const subArgs = process.argv.slice(2).filter((a) => a !== flags.command);
+    const ctx = { ask, close: () => rl.close() };
+    let code = 0;
+    try {
+      switch (flags.command) {
+        case "onboard": code = await corpusCli.cmdOnboard(subArgs, ctx); break;
+        case "ingest": code = await corpusCli.cmdIngest(subArgs); break;
+        case "status": code = await corpusCli.cmdStatus(); break;
+        case "resync": code = await corpusCli.cmdResync(subArgs); break;
+        case "corpus": code = await corpusCli.cmdCorpus(subArgs, ctx); break;
+        case "install-git-hook": code = await corpusCli.cmdInstallGitHook(); break;
+        case "ingest-paths": code = await corpusCli.cmdIngestPaths(subArgs); break;
       }
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}\n`);
+      code = 2;
     }
-  }
-
-  writeFileSync(
-    configPath,
-    `---
-mode: local
-memory_url: http://localhost:3333
----
-`
-  );
-
-  console.log(`\n  Config written to ${configPath}`);
-
-  const sdkDir = new URL("..", import.meta.url).pathname;
-
-  console.log(`
-  Memory server: http://localhost:3333
-  Hooks are auto-configured to use local memory.
-
-  Install the plugin in Claude Code:
-    /plugin marketplace add Pentatonic-Ltd/ai-agent-sdk
-    /plugin install tes-memory@pentatonic-ai
-
-  You're ready! Every prompt auto-searches memory,
-  every turn auto-stores. No MCP setup needed.
-`);
-
-  rl.close();
-}
-
-async function main() {
-  const flags = parseArgs();
-  const TES_ENDPOINT = flags.endpoint || DEFAULT_ENDPOINT;
-
-  if (flags.command === "memory") {
-    await setupLocalMemory();
-    return;
-  }
-
-  if (flags.command === "doctor") {
-    const code = await runDoctorCommand(flags);
     rl.close();
     process.exit(code);
   }
 
-  if (flags.command !== "init") {
-    console.log(`
+  console.log(`
 @pentatonic-ai/ai-agent-sdk
 
 Usage:
-  npx @pentatonic-ai/ai-agent-sdk init                    Set up hosted TES account
-  npx @pentatonic-ai/ai-agent-sdk memory                  Set up local memory stack
+  npx @pentatonic-ai/ai-agent-sdk login                   First-time hosted setup: browser sign-in + writes credentials
+  npx @pentatonic-ai/ai-agent-sdk whoami                  Show current login identity
+  npx @pentatonic-ai/ai-agent-sdk config <sub>            Configure memory backend; see 'config --help'
   npx @pentatonic-ai/ai-agent-sdk doctor                  Run health checks (exit 0/1/2)
-  npx @pentatonic-ai/ai-agent-sdk init --endpoint URL     Use a custom TES endpoint
+
+  config subcommands:
+    config local                                          Point plugin at a local memory engine
+    config hosted                                         Switch to hosted (delegates to login)
+    config show                                           Print current plugin config + creds
+
+Memory corpus (onboarding):
+  npx @pentatonic-ai/ai-agent-sdk onboard                 Interactive: pick paths, ingest, install hooks
+  npx @pentatonic-ai/ai-agent-sdk ingest <path>           One-shot ingest of a path (any folder works)
+  npx @pentatonic-ai/ai-agent-sdk status                  Show tracked paths and corpus stats
+  npx @pentatonic-ai/ai-agent-sdk resync [<path>]         Delta-sync (or all tracked paths)
+  npx @pentatonic-ai/ai-agent-sdk corpus list             List tracked paths
+  npx @pentatonic-ai/ai-agent-sdk corpus remove <path>    Stop tracking a path
+  npx @pentatonic-ai/ai-agent-sdk corpus reset            Wipe local corpus state
+  npx @pentatonic-ai/ai-agent-sdk install-git-hook        Install post-commit hook in cwd
+
+Corpus commands route to the backend configured via 'config' (local engine
+or hosted TES). Override with env vars: MEMORY_ENGINE_URL, TES_ENDPOINT, …
 
 doctor flags:
   --json                  Emit a JSON report
@@ -319,221 +201,8 @@ doctor flags:
   --timeout <ms>          Per-check timeout (default 10000)
 
 For docs, see https://api.pentatonic.com
-    `);
-    process.exit(0);
-  }
-
-  const isLocal = /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(TES_ENDPOINT);
-  if (!TES_ENDPOINT.startsWith("https://") && !isLocal) {
-    console.error(`\n  Error: endpoint must use https:// (http:// is only allowed for localhost)\n`);
-    process.exit(1);
-  }
-
-  console.log(`\n  Welcome to Pentatonic AI Events SDK`);
-  if (TES_ENDPOINT !== DEFAULT_ENDPOINT) {
-    console.log(`  Using endpoint: ${TES_ENDPOINT}`);
-  }
-  console.log("");
-
-  // Collect info
-  const email = await ask("? Email: ");
-  const clientId = toClientId(await ask("? Client ID: "));
-  const password = await askSecret("? Password: ");
-  const region = await askChoice("? Region:", ["EU", "US"]);
-
-  // Try login first — account may already be verified from a previous run
-  let accessToken = null;
-  const loginSpinner = spinner("Checking for existing account...");
-  try {
-    const { ok, data } = await httpPost(
-      `${TES_ENDPOINT}/api/enrollment/login`,
-      { email, password, clientId }
-    );
-    if (ok && data.tokens?.accessToken) {
-      accessToken = data.tokens.accessToken;
-      loginSpinner.stop("Account already verified!");
-    } else {
-      loginSpinner.stop("No existing account found.");
-    }
-  } catch {
-    loginSpinner.stop("No existing account found.");
-  }
-
-  // If not already verified, submit enrollment
-  if (!accessToken) {
-    const enrollSpinner = spinner("Creating account...");
-    try {
-      const { ok, data } = await httpPost(
-        `${TES_ENDPOINT}/api/enrollment/submit`,
-        {
-          clientId,
-          companyName: clientId,
-          industryType: "technology",
-          authProvider: "native",
-          adminEmail: email,
-          adminPassword: password,
-          region: region.toLowerCase(),
-        }
-      );
-
-      if (!ok) {
-        const errors = data.errors || {};
-        const isPending =
-          errors.clientId?.includes("already pending") ||
-          errors.adminEmail?.includes("already has a pending");
-        const isAlreadyRegistered =
-          errors.clientId?.includes("already registered");
-
-        if (isPending) {
-          enrollSpinner.stop("Enrollment already pending — waiting for verification.");
-        } else if (isAlreadyRegistered) {
-          enrollSpinner.fail(
-            "This client ID is already registered.\n" +
-            "  If you belong to this organization, ask your admin to invite you.\n" +
-            "  Then run this command again — it will log you in automatically."
-          );
-          process.exit(1);
-        } else {
-          enrollSpinner.fail(
-            data.message || Object.values(errors).join(", ") || "Enrollment failed"
-          );
-          process.exit(1);
-        }
-      } else {
-        enrollSpinner.stop("Account created! Check your email to verify.");
-      }
-    } catch (err) {
-      enrollSpinner.fail(`Failed to connect: ${err.message}`);
-      process.exit(1);
-    }
-
-    // Poll for verification
-    console.log("\n  Waiting for email verification...");
-    console.log("  (Check your inbox and click the verification link)\n");
-
-    const pollSpinner = spinner("Waiting for verification...");
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < POLL_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-
-      try {
-        const { ok, data } = await httpPost(
-          `${TES_ENDPOINT}/api/enrollment/login`,
-          { email, password, clientId }
-        );
-
-        if (ok && data.tokens?.accessToken) {
-          accessToken = data.tokens.accessToken;
-          pollSpinner.stop("Email verified!");
-          break;
-        }
-      } catch {
-        // Not verified yet, keep polling
-      }
-    }
-
-    if (!accessToken) {
-      pollSpinner.fail(
-        "Verification timed out. Run `npx @pentatonic-ai/ai-agent-sdk init` again — it will resume where you left off."
-      );
-      process.exit(1);
-    }
-  }
-
-  // Get API key — use the service token created during enrollment,
-  // or create a new one if not available (e.g., existing account login)
-  const keySpinner = spinner("Getting API key...");
-  try {
-    let apiKey;
-
-    // Try to retrieve the enrollment service token first (created during verification)
-    try {
-      const tokenRes = await fetch(
-        `${TES_ENDPOINT}/api/enrollment/service-token?client_id=${clientId}`
-      );
-      if (tokenRes.ok) {
-        const tokenData = await tokenRes.json();
-        if (tokenData.token) {
-          apiKey = tokenData.token;
-        }
-      }
-    } catch {
-      // Service token not available, will create one
-    }
-
-    // Fallback: create a new token via GraphQL
-    if (!apiKey) {
-      const result = await graphql(
-        TES_ENDPOINT,
-        accessToken,
-        `mutation CreateApiToken($clientId: String!, $input: CreateApiTokenInput!) {
-          createClientApiToken(clientId: $clientId, input: $input) {
-            success
-            plainTextToken
-          }
-        }`,
-        {
-          clientId,
-          input: {
-            name: "ai-events-sdk",
-            role: "agent-events",
-          },
-        }
-      );
-      apiKey = result.createClientApiToken.plainTextToken;
-    }
-
-    keySpinner.stop("API key ready!");
-
-    // Print credentials
-    const clientEndpoint =
-      TES_ENDPOINT === DEFAULT_ENDPOINT
-        ? `https://${clientId}.api.pentatonic.com`
-        : TES_ENDPOINT;
-
-    console.log("\n  Add these to your environment:\n");
-    console.log(`  TES_ENDPOINT=${clientEndpoint}`);
-    console.log(`  TES_CLIENT_ID=${clientId}`);
-    console.log(`  TES_API_KEY=${apiKey}`);
-    console.log("");
-
-    // Install SDK
-    const installChoice = await askChoice("Install SDK:", [
-      "npm install @pentatonic-ai/ai-agent-sdk",
-      "pip install pentatonic-ai-agent-sdk",
-      "Skip — I'll install manually",
-    ]);
-
-    if (installChoice.startsWith("npm")) {
-      const installSpinner = spinner("Installing @pentatonic-ai/ai-agent-sdk...");
-      try {
-        execFileSync("npm", ["install", "@pentatonic-ai/ai-agent-sdk"], { stdio: "pipe" });
-        installSpinner.stop("@pentatonic-ai/ai-agent-sdk installed!");
-      } catch {
-        installSpinner.fail("Install failed. Run manually: npm install @pentatonic-ai/ai-agent-sdk");
-      }
-    } else if (installChoice.startsWith("pip")) {
-      const installSpinner = spinner("Installing pentatonic-ai-agent-sdk...");
-      try {
-        execFileSync("pip", ["install", "pentatonic-ai-agent-sdk"], { stdio: "pipe" });
-        installSpinner.stop("pentatonic-ai-agent-sdk installed!");
-      } catch {
-        installSpinner.fail("Install failed. Run manually: pip install pentatonic-ai-agent-sdk");
-      }
-    } else {
-      console.log("\n  Install later with:");
-      console.log("    npm install @pentatonic-ai/ai-agent-sdk");
-      console.log("    pip install pentatonic-ai-agent-sdk");
-    }
-
-    console.log("  You're ready! See docs at https://api.pentatonic.com\n");
-  } catch (err) {
-    keySpinner.fail(`Failed to generate key: ${err.message}`);
-    process.exit(1);
-  }
-
-  rl.close();
+  `);
+  process.exit(0);
 }
 
 main().catch((err) => {