deepline 0.1.0 → 0.1.1

package/dist/repo/sdk/src/cli/commands/csv.ts

@@ -0,0 +1,123 @@
+import { Command } from 'commander';
+import { buildDatasetStats } from '../dataset-stats.js';
+import { readCsvRows, printJson, clip } from '../utils.js';
+
+type CsvShowOptions = {
+  format?: 'json' | 'csv' | 'table';
+  rows?: string;
+  columns?: string;
+  summary?: boolean;
+  verbose?: boolean;
+};
+
+function parseRowRange(raw: string | undefined): [number, number] {
+  const source = raw?.trim() || '0:19';
+  const [startRaw, endRaw] = source.split(':', 2);
+  const start = Number.parseInt(startRaw ?? '', 10);
+  const end = Number.parseInt(endRaw ?? '', 10);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end < start) {
+    throw new Error(`Invalid --rows value: ${source} (expected start:end, e.g. 0:19).`);
+  }
+  return [start, end];
+}
+
+function selectRows<T>(rows: T[], start: number, end: number): T[] {
+  return rows.slice(start, end + 1);
+}
+
+function selectColumns(
+  rows: Array<Record<string, string>>,
+  rawColumns: string | undefined,
+): Array<Record<string, string>> {
+  if (!rawColumns?.trim()) return rows;
+  const requested = rawColumns.split(',').map((part) => part.trim()).filter(Boolean);
+  if (requested.length === 0) {
+    throw new Error('Invalid --columns value: provide at least one column name.');
+  }
+  const available = new Set(Object.keys(rows[0] ?? {}));
+  const missing = requested.filter((column) => !available.has(column));
+  if (missing.length > 0) {
+    throw new Error(`Unknown --columns value(s): ${missing.join(', ')}.`);
+  }
+  return rows.map((row) => {
+    const next: Record<string, string> = {};
+    for (const column of requested) next[column] = row[column] ?? '';
+    return next;
+  });
+}
+
+function renderTable(rows: Array<Record<string, string>>, totalRows: number, verbose: boolean): string {
+  const columns = Object.keys(rows[0] ?? {});
+  if (columns.length === 0) return 'No rows.';
+  const widths = Object.fromEntries(
+    columns.map((column) => [
+      column,
+      Math.max(
+        column.length,
+        ...rows.map((row) => {
+          const value = row[column] ?? '';
+          return (verbose ? value : clip(value, 42)).length;
+        }),
+      ),
+    ]),
+  ) as Record<string, number>;
+
+  const header = columns.map((column) => column.padEnd(widths[column]!)).join(' | ');
+  const divider = columns.map((column) => '-'.repeat(widths[column]!)).join('-+-');
+  const body = rows.map((row) =>
+    columns
+      .map((column) => {
+        const raw = row[column] ?? '';
+        const display = verbose ? raw : clip(raw, 42);
+        return display.padEnd(widths[column]!);
+      })
+      .join(' | '),
+  );
+  return [header, divider, ...body, '', `showing ${rows.length} row(s) of ${totalRows}`].join('\n');
+}
+
+async function handleCsvShow(options: CsvShowOptions & { csv: string }): Promise<void> {
+  const csvPath = options.csv;
+  const [rowStart, rowEnd] = parseRowRange(options.rows);
+  const allRows = readCsvRows(csvPath);
+  const selected = selectColumns(selectRows(allRows, rowStart, rowEnd), options.columns);
+  const format = options.format ?? 'json';
+
+  if (options.summary) {
+    printJson(buildDatasetStats(selected, allRows.length));
+    return;
+  }
+
+  if (format === 'json') {
+    printJson({
+      rows: selected.map((row, index) => ({ __row: rowStart + index, ...row })),
+    });
+    return;
+  }
+
+  if (format === 'csv') {
+    const columns = Object.keys(selected[0] ?? {});
+    process.stdout.write(`${columns.join(',')}\n`);
+    for (const row of selected) {
+      process.stdout.write(`${columns.map((column) => JSON.stringify(row[column] ?? '')).join(',')}\n`);
+    }
+    return;
+  }
+
+  process.stdout.write(`${renderTable(selected, allRows.length, Boolean(options.verbose))}\n`);
+}
+
+export function registerCsvCommands(program: Command): void {
+  const csv = program.command('csv').description('Inspect local CSV files.');
+
+  csv
+    .command('show')
+    .description('Display rows from a CSV file in json, csv, or table form.')
+    .requiredOption('--csv <path>', 'Input CSV path')
+    .option('--format <format>', 'Output format: json, csv, or table', 'json')
+    .option('--rows <range>', 'Row range start:end', '0:19')
+    .option('--columns <names>', 'Comma-separated column names to include')
+    .option('--summary', 'Print a summary payload instead of row output')
+    .option('--verbose', 'Do not truncate long values in table output')
+    .action(handleCsvShow);
+}

package/dist/repo/sdk/src/cli/commands/db.ts

@@ -0,0 +1,119 @@
+import { Command } from 'commander';
+import { DeeplineClient } from '../../client.js';
+import type { CustomerDbQueryResult } from '../../types.js';
+import { argsWantJson } from '../utils.js';
+
+function parsePositiveInteger(value: string, flagName: string): number {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flagName} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+function formatCell(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  const text = typeof value === 'object' ? JSON.stringify(value) : String(value);
+  return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+}
+
+function printTable(result: CustomerDbQueryResult): void {
+  const rows = result.rows.filter(
+    (row): row is Record<string, unknown> =>
+      Boolean(row) && typeof row === 'object' && !Array.isArray(row),
+  );
+  const responseColumns =
+    result.columns.length > 0
+      ? result.columns.map((column) => column.name)
+      : [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  const businessColumns = responseColumns.filter((column) => !column.startsWith('_'));
+  const columns = businessColumns.length > 0 ? businessColumns : responseColumns;
+  const hiddenColumns = responseColumns.filter((column) => !columns.includes(column));
+
+  console.log(
+    `${result.command} returned ${result.row_count_returned} row(s)` +
+      (result.truncated ? ' (truncated)' : ''),
+  );
+  if (hiddenColumns.length > 0) {
+    console.log(
+      `Showing ${columns.length}/${responseColumns.length} columns; hidden metadata: ${hiddenColumns.join(', ')}`,
+    );
+    console.log('Use --json or select metadata columns explicitly when you need run ids/errors/stages.');
+  }
+  if (rows.length === 0) {
+    return;
+  }
+
+  const widths = columns.map((column) =>
+    Math.min(
+      80,
+      Math.max(
+        column.length,
+        ...rows.slice(0, 20).map((row) => formatCell(row[column]).length),
+      ),
+    ),
+  );
+  console.log(columns.map((column, index) => column.padEnd(widths[index]!)).join('  '));
+  console.log(widths.map((width) => '-'.repeat(width)).join('  '));
+  for (const row of rows) {
+    console.log(
+      columns
+        .map((column, index) => formatCell(row[column]).padEnd(widths[index]!))
+        .join('  '),
+    );
+  }
+}
+
+async function handleDbQuery(args: string[]): Promise<number> {
+  const sqlIndex = args.indexOf('--sql');
+  const sql = sqlIndex >= 0 ? args[sqlIndex + 1]?.trim() : '';
+  if (!sql) {
+    console.error('Usage: deepline db query --sql "select * from table limit 20" [--max-rows N] [--json]');
+    return 1;
+  }
+
+  const maxRowsIndex = args.indexOf('--max-rows');
+  const maxRows =
+    maxRowsIndex >= 0 && args[maxRowsIndex + 1]
+      ? parsePositiveInteger(args[maxRowsIndex + 1]!, '--max-rows')
+      : undefined;
+  const jsonOutput = argsWantJson(args);
+  const client = new DeeplineClient();
+  const result = await client.queryCustomerDb({ sql, maxRows });
+
+  if (jsonOutput) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return 0;
+  }
+
+  printTable(result);
+  console.error(
+    `Tool equivalent: deepline tools execute query_customer_db --payload ${JSON.stringify({
+      sql,
+      ...(maxRows ? { max_rows: maxRows } : {}),
+    })} --json`,
+  );
+  return 0;
+}
+
+export function registerDbCommands(program: Command): void {
+  const db = program
+    .command('db')
+    .alias('customer-db')
+    .description('Query the tenant customer database.');
+
+  db.command('query')
+    .alias('psql')
+    .description('Run SQL against the tenant customer database.')
+    .requiredOption('--sql <sql>', 'SQL statement')
+    .option('--max-rows <n>', 'Maximum returned rows')
+    .option('--json', 'Emit raw JSON response')
+    .action(async (options) => {
+      process.exitCode = await handleDbQuery([
+        '--sql',
+        options.sql,
+        ...(options.maxRows ? ['--max-rows', options.maxRows] : []),
+        ...(options.json ? ['--json'] : []),
+      ]);
+    });
+}

package/dist/repo/sdk/src/cli/commands/feedback.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { getAuthedHttpClient, collectLocalEnvInfo, printJson, shouldEmitJson } from '../utils.js';
+
+async function handleFeedback(
+  text: string,
+  options: { command?: string; payload?: string; json?: boolean },
+): Promise<void> {
+  const { http } = getAuthedHttpClient();
+  const response = await http.post('/api/v2/cli/feedback', {
+    text,
+    environment: collectLocalEnvInfo(),
+    ...(options.command ? { command: options.command } : {}),
+    ...(options.payload ? { payload: options.payload } : {}),
+  });
+  if (shouldEmitJson(options.json)) {
+    printJson(response);
+    return;
+  }
+  process.stdout.write('Feedback submitted. Thank you.\n');
+}
+
+export function registerFeedbackCommands(program: Command): void {
+  const feedback = program.command('feedback').description('Submit CLI feedback to Deepline.');
+
+  feedback
+    .argument('<text>', 'Feedback text')
+    .option('--command <command>', 'Command that reproduced the issue')
+    .option('--payload <payload>', 'JSON or plain-text payload for the repro')
+    .option('--json', 'Emit JSON output')
+    .action(handleFeedback);
+
+  program
+    .command('provide-feedback')
+    .description('Legacy alias for `deepline feedback`.')
+    .argument('<text>', 'Feedback text')
+    .option('--command <command>', 'Command that reproduced the issue')
+    .option('--payload <payload>', 'JSON or plain-text payload for the repro')
+    .option('--json', 'Emit JSON output')
+    .action(handleFeedback);
+}

package/dist/repo/sdk/src/cli/commands/org.ts

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import { HttpClient } from '../../http.js';
+import {
+  hostEnvFilePath,
+  resolveConfig,
+  saveHostEnvValues,
+} from '../../config.js';
+import { printJson, shouldEmitJson } from '../utils.js';
+
+type Organization = {
+  org_id: string;
+  name: string;
+  role?: string;
+  is_current?: boolean;
+};
+
+async function fetchOrganizations(http: HttpClient, apiKey: string): Promise<{
+  current_org_id: string | null;
+  organizations: Organization[];
+}> {
+  return http.post('/api/v2/auth/cli/organizations', { api_key: apiKey });
+}
+
+function printOrgList(orgs: Organization[]): void {
+  for (const [index, org] of orgs.entries()) {
+    const current = org.is_current ? ' (current)' : '';
+    const role = org.role ? ` [${org.role}]` : '';
+    process.stdout.write(`  ${index + 1}. ${org.name}${role}${current}\n`);
+  }
+}
+
+async function handleOrgList(options: { json?: boolean }): Promise<void> {
+  const config = resolveConfig();
+  const http = new HttpClient(config);
+  const payload = await fetchOrganizations(http, config.apiKey);
+  if (shouldEmitJson(options.json)) {
+    printJson(payload);
+    return;
+  }
+  process.stdout.write('Your organizations:\n');
+  printOrgList(payload.organizations);
+}
+
+async function handleOrgSwitch(
+  selection: string | undefined,
+  options: { json?: boolean; orgId?: string },
+): Promise<void> {
+  const config = resolveConfig();
+  const http = new HttpClient(config);
+  const payload = await fetchOrganizations(http, config.apiKey);
+  if (!selection && !options.orgId) {
+    if (shouldEmitJson(options.json)) {
+      printJson(payload);
+      return;
+    }
+    process.stdout.write('Your organizations:\n');
+    printOrgList(payload.organizations);
+    process.stdout.write('\nRun: deepline org switch <number>\n');
+    return;
+  }
+
+  let target = payload.organizations.find((org) => org.org_id === options.orgId);
+  if (!target && selection) {
+    const index = Number.parseInt(selection, 10);
+    if (Number.isFinite(index) && index >= 1 && index <= payload.organizations.length) {
+      target = payload.organizations[index - 1];
+    } else {
+      target = payload.organizations.find((org) => org.name === selection || org.org_id === selection);
+    }
+  }
+
+  if (!target) {
+    throw new Error('Could not resolve the selected organization.');
+  }
+  if (target.is_current) {
+    if (shouldEmitJson(options.json)) {
+      printJson({ ok: true, unchanged: true, organization: target });
+      return;
+    }
+    process.stdout.write(`Already on ${target.name}.\n`);
+    return;
+  }
+
+  const switched = await http.post<{ api_key: string; org_id: string; org_name: string }>(
+    '/api/v2/auth/cli/switch',
+    { api_key: config.apiKey, org_id: target.org_id },
+  );
+  saveHostEnvValues(config.baseUrl, {
+    DEEPLINE_API_KEY: switched.api_key,
+    DEEPLINE_ACTIVE_ORG_ID: switched.org_id,
+    DEEPLINE_ACTIVE_ORG_NAME: switched.org_name,
+  });
+
+  if (shouldEmitJson(options.json)) {
+    printJson({ ok: true, host_env_path: hostEnvFilePath(config.baseUrl), ...switched });
+    return;
+  }
+  process.stdout.write(`Switched to ${switched.org_name}.\n`);
+  process.stdout.write(`Saved host auth in ${hostEnvFilePath(config.baseUrl)}\n`);
+}
+
+export function registerOrgCommands(program: Command): void {
+  const org = program.command('org').description('List and switch organizations.');
+
+  org
+    .command('list')
+    .description('List your organizations.')
+    .option('--json', 'Emit JSON output')
+    .action(handleOrgList);
+
+  org
+    .command('switch [selection]')
+    .description('Switch to another organization and save the new API key in the host auth file.')
+    .option('--org-id <id>', 'Switch using an explicit organization id')
+    .option('--json', 'Emit JSON output')
+    .action(handleOrgSwitch);
+}