@vectorasystems/cli 0.1.0

package/src/commands/config.js

@@ -0,0 +1,70 @@
+// @vectora/cli — config commands
+import chalk from 'chalk';
+import { getConfigValue, setConfigValue, listConfig, resetConfig, ALLOWED_KEYS } from '../lib/config-store.js';
+import { handleError } from '../lib/errors.js';
+import { renderTable, success } from '../lib/output.js';
+
+/**
+ * vectora config get <key>
+ */
+export async function get(key) {
+  try {
+    if (!key) {
+      console.error(chalk.red('Error — config key is required'));
+      console.error(chalk.dim(`  Valid keys: ${[...ALLOWED_KEYS].join(', ')}`));
+      process.exitCode = 1;
+      return;
+    }
+    const val = getConfigValue(key);
+    console.log(val === null ? chalk.dim('null') : String(val));
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora config set <key> <value>
+ */
+export async function set(key, value) {
+  try {
+    if (!key) {
+      console.error(chalk.red('Error — config key is required'));
+      process.exitCode = 1;
+      return;
+    }
+    setConfigValue(key, value);
+    success(`Set ${chalk.bold(key)} = ${chalk.cyan(String(value))}`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora config list
+ */
+export async function configList() {
+  try {
+    const all = listConfig();
+    renderTable(
+      ['Key', 'Value'],
+      Object.entries(all).map(([k, v]) => [
+        chalk.cyan(k),
+        v === null ? chalk.dim('null') : String(v),
+      ]),
+    );
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora config reset
+ */
+export async function reset() {
+  try {
+    resetConfig();
+    success('Config reset to defaults.');
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/commands/projects.js

@@ -0,0 +1,182 @@
+// @vectora/cli — project commands
+import chalk from 'chalk';
+import { getProjects, createProject, getProject, deleteProject, getWorkspaces } from '../lib/api-client.js';
+import { getConfig, setConfigValue, getConfigValue } from '../lib/config-store.js';
+import { handleError } from '../lib/errors.js';
+import { renderTable, renderJson, renderTime, success, info, warn } from '../lib/output.js';
+
+/**
+ * vectora projects list [--workspace <id>] [--format table|json]
+ */
+export async function list(opts) {
+  try {
+    const format = opts.format ?? getConfig().outputFormat;
+    const projects = await getProjects({ workspaceId: opts.workspace });
+
+    if (projects.length === 0) {
+      info('No projects found. Create one with: vectora projects create <name>');
+      return;
+    }
+
+    const activeProject = getConfigValue('defaultProject');
+
+    if (format === 'json') {
+      renderJson(projects);
+      return;
+    }
+
+    renderTable(
+      ['', 'ID', 'Name', 'Orchestrator', 'Status', 'Updated'],
+      projects.map((p) => [
+        p.id === activeProject ? chalk.green('●') : ' ',
+        chalk.dim(p.id.slice(0, 12)),
+        p.name,
+        chalk.cyan(p.orchestratorId ?? 'forge'),
+        p.status,
+        renderTime(p.updatedAt),
+      ]),
+    );
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora projects create <name> [--orchestrator forge|temper] [--workspace <id>]
+ */
+export async function create(name, opts) {
+  try {
+    if (!name) {
+      console.error(chalk.red('Error — project name is required'));
+      process.exitCode = 1;
+      return;
+    }
+
+    let workspaceId = opts.workspace;
+
+    // Auto-resolve workspace if not provided
+    if (!workspaceId) {
+      workspaceId = getConfigValue('defaultWorkspace');
+      if (!workspaceId) {
+        const workspaces = await getWorkspaces();
+        if (workspaces.length === 0) {
+          console.error(chalk.red('No workspaces found. Cannot create project.'));
+          process.exitCode = 1;
+          return;
+        }
+        workspaceId = workspaces[0].id;
+      }
+    }
+
+    const project = await createProject({
+      name,
+      workspaceId,
+      orchestratorId: opts.orchestrator ?? 'forge',
+    });
+
+    // Auto-select as active project
+    setConfigValue('defaultProject', project.id);
+    if (!getConfigValue('defaultWorkspace')) {
+      setConfigValue('defaultWorkspace', workspaceId);
+    }
+
+    success(`Created project ${chalk.bold(project.name)} ${chalk.dim(`(${project.id})`)}`);
+    info(`Orchestrator: ${chalk.cyan(project.orchestratorId)}`);
+    info('Set as active project.');
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora projects show [<id>]
+ */
+export async function show(id, opts) {
+  try {
+    const projectId = id ?? getConfigValue('defaultProject');
+    if (!projectId) {
+      warn('No project specified. Use --project <id> or select one with: vectora projects select <id>');
+      process.exitCode = 1;
+      return;
+    }
+
+    const project = await getProject(projectId);
+    const format = opts.format ?? getConfig().outputFormat;
+
+    if (format === 'json') {
+      renderJson(project);
+      return;
+    }
+
+    console.log();
+    console.log(chalk.cyan.bold(`  ${project.name}`));
+    console.log(chalk.dim('  ─────────────────────────────'));
+    console.log(`  ID:           ${chalk.dim(project.id)}`);
+    console.log(`  Orchestrator: ${chalk.cyan(project.orchestratorId)}`);
+    console.log(`  Status:       ${project.status}`);
+    console.log(`  Workspace:    ${chalk.dim(project.workspaceId)}`);
+    if (project.ideaSummary) {
+      console.log(`  Idea:         ${project.ideaSummary.slice(0, 80)}`);
+    }
+    console.log(`  Created:      ${renderTime(project.createdAt)}`);
+    console.log(`  Updated:      ${renderTime(project.updatedAt)}`);
+
+    if (project.phases?.length) {
+      console.log();
+      console.log(chalk.dim('  Phases:'));
+      for (const phase of project.phases) {
+        const statusStr = phase.status === 'completed' ? chalk.green('✓') :
+                          phase.status === 'failed' ? chalk.red('✗') :
+                          chalk.yellow('○');
+        console.log(`    ${statusStr} ${phase.phaseType} ${chalk.dim(renderTime(phase.updatedAt))}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora projects select <id>
+ */
+export async function select(id) {
+  try {
+    if (!id) {
+      console.error(chalk.red('Error — project ID is required'));
+      process.exitCode = 1;
+      return;
+    }
+
+    // Validate the project exists
+    const project = await getProject(id);
+    setConfigValue('defaultProject', project.id);
+    success(`Active project: ${chalk.bold(project.name)} ${chalk.dim(`(${project.id})`)}`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+/**
+ * vectora projects delete <id>
+ */
+export async function remove(id) {
+  try {
+    if (!id) {
+      console.error(chalk.red('Error — project ID is required'));
+      process.exitCode = 1;
+      return;
+    }
+
+    await deleteProject(id);
+
+    // Clear if it was the active project
+    if (getConfigValue('defaultProject') === id) {
+      setConfigValue('defaultProject', null);
+    }
+
+    success(`Deleted project ${chalk.dim(id)}`);
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/commands/run.js

@@ -0,0 +1,115 @@
+// @vectora/cli — run command: execute phases with SSE progress
+import chalk from 'chalk';
+import ora from 'ora';
+import { runPhase } from '../lib/api-client.js';
+import { requireToken } from '../lib/auth-store.js';
+import { getConfig, getConfigValue } from '../lib/config-store.js';
+import { streamPhaseProgress } from '../lib/sse-client.js';
+import { collectWorkspaceSnapshot } from '../lib/workspace-scanner.js';
+import { VALID_PHASES } from '../lib/constants.js';
+import { handleError } from '../lib/errors.js';
+import { success, warn, info } from '../lib/output.js';
+
+/**
+ * vectora run <phase> [--project <id>] [--workspace-root <path>]
+ */
+export async function run(phase, opts) {
+  try {
+    // Validate phase name
+    if (!VALID_PHASES.includes(phase)) {
+      console.error(chalk.red(`Unknown phase: ${phase}`));
+      console.error(chalk.dim(`Valid phases: ${VALID_PHASES.join(', ')}`));
+      process.exitCode = 1;
+      return;
+    }
+
+    const projectId = opts.project ?? getConfigValue('defaultProject');
+    if (!projectId) {
+      warn('No project selected. Use --project <id> or: vectora projects select <id>');
+      process.exitCode = 1;
+      return;
+    }
+
+    const token = await requireToken();
+    const { apiUrl } = getConfig();
+    const phaseOptions = {};
+
+    // Auto-collect workspace snapshot for analyze-codebase
+    if (phase === 'analyze-codebase') {
+      const workspaceRoot = opts.workspaceRoot ?? process.cwd();
+      const scanSpinner = ora({ text: 'Scanning workspace...', color: 'cyan' }).start();
+      try {
+        const snapshot = await collectWorkspaceSnapshot(workspaceRoot);
+        scanSpinner.succeed(`Scanned ${snapshot.sampledFileCount} files (${snapshot.manifests.length} manifests, ${snapshot.srcRoots.length} src roots)`);
+        phaseOptions.snapshot = snapshot;
+      } catch (err) {
+        scanSpinner.fail('Failed to scan workspace');
+        throw err;
+      }
+    }
+
+    // Kick off phase
+    const spinner = ora({ text: `Starting ${phase}...`, color: 'cyan' }).start();
+
+    let result;
+    try {
+      result = await runPhase(projectId, phase, phaseOptions);
+    } catch (err) {
+      spinner.fail(`Failed to start ${phase}`);
+      throw err;
+    }
+
+    const { jobId, phaseId } = result;
+    spinner.text = `Phase ${phase} queued (job: ${jobId?.slice(0, 8) ?? '?'})`;
+
+    // Stream SSE progress
+    try {
+      for await (const { event, data } of streamPhaseProgress(apiUrl, jobId, token)) {
+        switch (event) {
+          case 'job:status':
+            spinner.text = `${phase}: ${data.status ?? 'processing'}`;
+            break;
+
+          case 'job:progress': {
+            const step = data.step ?? data.message ?? '';
+            const pct = data.pct != null ? ` (${data.pct}%)` : '';
+            spinner.text = `${phase}: ${step}${pct}`;
+            break;
+          }
+
+          case 'job:completed':
+            spinner.succeed(`${phase} completed`);
+            if (data.output?.artifacts?.length) {
+              info(`Generated ${data.output.artifacts.length} artifact(s)`);
+            }
+            if (data.output?.duration) {
+              info(`Duration: ${(data.output.duration / 1000).toFixed(1)}s`);
+            }
+            return;
+
+          case 'job:failed':
+            spinner.fail(`${phase} failed`);
+            console.error(chalk.red(data.error ?? 'Unknown error'));
+            process.exitCode = 1;
+            return;
+
+          case 'job:timeout':
+            spinner.warn(`${phase} timed out — may still be running on server`);
+            info(`Check status with: vectora status --project ${projectId}`);
+            process.exitCode = 1;
+            return;
+        }
+      }
+
+      // Stream ended without terminal event
+      spinner.warn(`${phase} — SSE stream ended`);
+      info(`Check status with: vectora status --project ${projectId}`);
+    } catch (err) {
+      spinner.fail(`${phase} — lost connection`);
+      info(`Phase may still be running. Check: vectora status --project ${projectId}`);
+      throw err;
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/commands/status.js

@@ -0,0 +1,47 @@
+// @vectora/cli — status command
+import chalk from 'chalk';
+import { getProject, getProjectPhases } from '../lib/api-client.js';
+import { getConfigValue } from '../lib/config-store.js';
+import { handleError } from '../lib/errors.js';
+import { renderPhaseStatus, renderTime, warn } from '../lib/output.js';
+
+/**
+ * vectora status [--project <id>]
+ */
+export async function status(opts) {
+  try {
+    const projectId = opts.project ?? getConfigValue('defaultProject');
+    if (!projectId) {
+      warn('No project selected. Use --project <id> or: vectora projects select <id>');
+      process.exitCode = 1;
+      return;
+    }
+
+    const [project, phases] = await Promise.all([
+      getProject(projectId),
+      getProjectPhases(projectId),
+    ]);
+
+    console.log();
+    console.log(chalk.cyan.bold(`  ${project.name}`));
+    console.log(chalk.dim(`  ${project.orchestratorId} · ${project.status}`));
+    console.log(chalk.dim('  ─────────────────────────────'));
+
+    if (phases.length === 0) {
+      console.log(chalk.dim('  No phases run yet.'));
+      console.log(chalk.dim('  Start with: vectora run analyze-codebase'));
+    } else {
+      for (const phase of phases) {
+        const icon = phase.status === 'completed' ? chalk.green('✓') :
+                     phase.status === 'failed' ? chalk.red('✗') :
+                     phase.status === 'running' ? chalk.yellow('◉') :
+                     chalk.dim('○');
+        const duration = phase.durationMs ? chalk.dim(`${(phase.durationMs / 1000).toFixed(1)}s`) : '';
+        console.log(`  ${icon} ${phase.phaseType.padEnd(20)} ${renderPhaseStatus(phase.status).padEnd(20)} ${duration} ${renderTime(phase.updatedAt)}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/commands/ui.js

@@ -0,0 +1,22 @@
+// @vectora/cli — TUI dashboard command
+// Ink + React are lazy-loaded to keep other commands fast.
+import chalk from 'chalk';
+import { handleError } from '../lib/errors.js';
+
+export async function ui() {
+  try {
+    console.log(chalk.dim('Loading TUI dashboard...'));
+    const { render } = await import('ink');
+    const React = await import('react');
+    const { default: App } = await import('../tui/App.js');
+    render(React.createElement(App));
+  } catch (err) {
+    if (err.code === 'ERR_MODULE_NOT_FOUND') {
+      console.error(chalk.red('TUI dependencies not installed.'));
+      console.error(chalk.dim('Run: cd packages/cli && npm install'));
+      process.exitCode = 1;
+      return;
+    }
+    handleError(err);
+  }
+}

package/src/commands/usage.js

@@ -0,0 +1,62 @@
+// @vectora/cli — usage command
+import chalk from 'chalk';
+import { getUsage } from '../lib/api-client.js';
+import { getConfig } from '../lib/config-store.js';
+import { handleError } from '../lib/errors.js';
+import { renderTable, renderJson } from '../lib/output.js';
+
+/**
+ * vectora usage [--format table|json]
+ */
+export async function usage(opts) {
+  try {
+    const format = opts.format ?? getConfig().outputFormat;
+    const data = await getUsage();
+
+    if (format === 'json') {
+      renderJson(data);
+      return;
+    }
+
+    console.log();
+    console.log(chalk.cyan.bold('  USAGE SUMMARY'));
+    console.log(chalk.dim('  ─────────────────────────────'));
+
+    // Totals
+    console.log(`  Total Tokens: ${chalk.bold(data.totals.tokensTotal.toLocaleString())}`);
+    console.log(`  Cost:         ${chalk.bold('$' + data.totals.costUsd.toFixed(4))}`);
+    console.log(`  API Calls:    ${chalk.bold(data.totals.calls.toLocaleString())}`);
+    console.log();
+
+    // By provider
+    if (data.byProvider?.length) {
+      renderTable(
+        ['Provider', 'Tokens In', 'Tokens Out', 'Cost', 'Calls'],
+        data.byProvider.map((p) => [
+          chalk.cyan(p.provider),
+          p.tokensIn.toLocaleString(),
+          p.tokensOut.toLocaleString(),
+          '$' + p.costUsd.toFixed(4),
+          String(p.calls),
+        ]),
+      );
+    }
+
+    // Breakdown by model
+    if (data.breakdown?.length) {
+      console.log();
+      renderTable(
+        ['Provider', 'Model', 'Tokens', 'Cost', 'Calls'],
+        data.breakdown.map((b) => [
+          chalk.dim(b.provider),
+          b.model,
+          b.tokensTotal.toLocaleString(),
+          '$' + b.costUsd.toFixed(4),
+          String(b.calls),
+        ]),
+      );
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/lib/api-client.js

@@ -0,0 +1,172 @@
+// @vectora/cli — API client
+// Mirrors packages/web/src/lib/api.ts but uses stored API token auth.
+import { getConfig } from './config-store.js';
+import { requireToken } from './auth-store.js';
+import { VectoraApiError, OfflineError } from './errors.js';
+
+/**
+ * Core fetch wrapper with auth and error mapping.
+ */
+async function apiFetch(path, { method, body, token, raw } = {}) {
+  const { apiUrl } = getConfig();
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  let res;
+  try {
+    res = await fetch(`${apiUrl}${path}`, {
+      method: method ?? 'GET',
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(30_000),
+    });
+  } catch (err) {
+    if (err.name === 'TimeoutError' || err.code === 'UND_ERR_CONNECT_TIMEOUT') {
+      throw new OfflineError(apiUrl);
+    }
+    if (err.cause?.code === 'ECONNREFUSED' || err.cause?.code === 'ENOTFOUND' ||
+        err.message?.includes('fetch failed')) {
+      throw new OfflineError(apiUrl);
+    }
+    throw err;
+  }
+
+  if (raw) return res;
+
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    let code = 'UNKNOWN';
+    try {
+      const errJson = await res.json();
+      message = errJson.message ?? errJson.error ?? message;
+      code = errJson.code ?? code;
+    } catch { /* ignore */ }
+    throw new VectoraApiError(message, res.status, code);
+  }
+
+  return res.json();
+}
+
+// ─── Auth-aware wrapper ──────────────────────────────────────────────────────
+
+async function authedFetch(path, opts = {}) {
+  const token = opts.token ?? await requireToken();
+  return apiFetch(path, { ...opts, token });
+}
+
+// ─── Workspaces ──────────────────────────────────────────────────────────────
+
+export async function getWorkspaces() {
+  const res = await authedFetch('/v1/workspaces');
+  return res.workspaces;
+}
+
+// ─── Projects ────────────────────────────────────────────────────────────────
+
+export async function getProjects(opts = {}) {
+  const params = new URLSearchParams();
+  if (opts.workspaceId) params.set('workspaceId', opts.workspaceId);
+  if (opts.limit !== undefined) params.set('limit', String(opts.limit));
+  if (opts.offset !== undefined) params.set('offset', String(opts.offset));
+  const qs = params.toString() ? `?${params.toString()}` : '';
+  const res = await authedFetch(`/v1/projects${qs}`);
+  return res.projects;
+}
+
+export async function createProject(data) {
+  const res = await authedFetch('/v1/projects', { method: 'POST', body: data });
+  return res.project;
+}
+
+export async function getProject(id) {
+  const res = await authedFetch(`/v1/projects/${id}`);
+  return res.project;
+}
+
+export async function patchProject(id, data) {
+  const res = await authedFetch(`/v1/projects/${id}`, { method: 'PATCH', body: data });
+  return res.project;
+}
+
+export async function deleteProject(id) {
+  await authedFetch(`/v1/projects/${id}`, { method: 'DELETE' });
+}
+
+// ─── Phases ──────────────────────────────────────────────────────────────────
+
+export async function getProjectPhases(projectId) {
+  const res = await authedFetch(`/v1/projects/${projectId}/phases`);
+  return res.phases;
+}
+
+export async function runPhase(projectId, phase, options = {}) {
+  return authedFetch(`/v1/projects/${projectId}/phases/${phase}`, {
+    method: 'POST',
+    body: options,
+  });
+}
+
+// ─── Artifacts ───────────────────────────────────────────────────────────────
+
+export async function getProjectArtifacts(projectId, type) {
+  const params = new URLSearchParams();
+  if (type) params.set('type', type);
+  const qs = params.toString() ? `?${params.toString()}` : '';
+  const res = await authedFetch(`/v1/projects/${projectId}/artifacts${qs}`);
+  return res.artifacts;
+}
+
+export async function getArtifact(artifactId) {
+  const res = await authedFetch(`/v1/artifacts/${artifactId}`);
+  return res.artifact;
+}
+
+// ─── Handoff ─────────────────────────────────────────────────────────────────
+
+export async function triggerHandoff(projectId, target) {
+  return authedFetch(`/v1/projects/${projectId}/handoff`, {
+    method: 'POST',
+    body: { target },
+  });
+}
+
+// ─── Billing ─────────────────────────────────────────────────────────────────
+
+export async function getBillingPlan() {
+  return authedFetch('/v1/billing/plan');
+}
+
+// ─── Usage + Models ──────────────────────────────────────────────────────────
+
+export async function getUsage() {
+  const res = await authedFetch('/v1/usage');
+  return { totals: res.totals, breakdown: res.breakdown, byProvider: res.byProvider ?? [] };
+}
+
+export async function getModels() {
+  const res = await authedFetch('/v1/models');
+  return res.models;
+}
+
+// ─── Settings ────────────────────────────────────────────────────────────────
+
+export async function getApiKeys() {
+  const res = await authedFetch('/v1/settings/api-keys');
+  return res.keys;
+}
+
+// ─── Auth (unauthenticated or special) ───────────────────────────────────────
+
+export async function getMe(token) {
+  return apiFetch('/v1/auth/me', { token });
+}
+
+export async function checkHealth() {
+  const { apiUrl } = getConfig();
+  try {
+    const res = await fetch(`${apiUrl}/health`, { signal: AbortSignal.timeout(5000) });
+    return await res.json();
+  } catch {
+    return { status: 'unreachable' };
+  }
+}