@ductape/cli 0.2.9 → 0.2.11

package/dist/commands/db-migrate.js

@@ -6,9 +6,9 @@ import { fail, printJson } from '../lib/output.js';
 function buildDbContext(dbTag, envSlug, productTag) {
     return { database: dbTag, env: envSlug, product: productTag };
 }
-async function getAppliedTags(proxy, dbContext, productTag, envSlug) {
+async function getAppliedTags(proxy, dbContext) {
     try {
-        const result = await proxy.execute('migration.list', [{ product: productTag, env: envSlug, database: dbContext.database }], dbContext);
+        const result = await proxy.execute('migration.history', [], dbContext);
         const list = Array.isArray(result)
             ? result
             : Array.isArray(result.data)
@@ -44,7 +44,7 @@ export async function runDbMigrate(opts) {
             console.log(`[${db}] No migration files found. Run \`ductape db schema generate\` first.`);
             continue;
         }
-        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const appliedTags = await getAppliedTags(proxy, dbContext);
         const pending = migrations.filter((m) => !appliedTags.includes(m.tag));
         if (pending.length === 0) {
             console.log(`[${db}] Already up to date.`);
@@ -92,7 +92,7 @@ export async function runDbMigrateStatus(opts) {
         const { db } = entry;
         const dbContext = buildDbContext(db, envSlug, productTag);
         const migrations = loadMigrationFiles(dir, db);
-        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const appliedTags = await getAppliedTags(proxy, dbContext);
         const applied = migrations.filter((m) => appliedTags.includes(m.tag)).map((m) => m.tag);
         const pending = migrations.filter((m) => !appliedTags.includes(m.tag)).map((m) => m.tag);
         statusReport[db] = { applied, pending };
@@ -132,7 +132,7 @@ export async function runDbMigrateRollback(opts) {
         const { db } = entry;
         const dbContext = buildDbContext(db, envSlug, productTag);
         const migrations = loadMigrationFiles(dir, db);
-        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const appliedTags = await getAppliedTags(proxy, dbContext);
         const applied = migrations.filter((m) => appliedTags.includes(m.tag));
         const toRollback = applied.slice(-rollbackCount).reverse();
         if (toRollback.length === 0) {

package/dist/commands/db-schema.d.ts

@@ -3,4 +3,8 @@ interface SchemaGenerateOpts {
     destructive?: boolean;
 }
 export declare function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<void>;
+interface SchemaPushOpts {
+    db: string;
+}
+export declare function runDbSchemaPush(opts: SchemaPushOpts): Promise<void>;
 export {};

package/dist/commands/db-schema.js

@@ -5,6 +5,7 @@ import { loadSchemaFile, getSchemaPath, parseTableDef } from '../lib/schema-load
 import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
 import { fail } from '../lib/output.js';
 import { getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { pushDatabaseSchema } from '../lib/integrations.js';
 function replayMigrations(migrations) {
     const schema = new Map();
     for (const migration of migrations) {
@@ -338,3 +339,72 @@ function requireSilent() {
         return null;
     }
 }
+function adaptColumn(col) {
+    return {
+        name: String(col.name ?? ''),
+        type: String(col.type ?? 'string'),
+        nullable: col.nullable !== false && col.nullable !== 'NO',
+        primaryKey: Boolean(col.primaryKey ?? col.isPrimaryKey),
+        unique: Boolean(col.unique ?? col.isUnique),
+        autoIncrement: Boolean(col.autoIncrement ?? col.isAutoIncrement ?? col.autoGenerate),
+        ...(col.defaultValue != null ? { defaultValue: col.defaultValue } : {}),
+    };
+}
+export async function runDbSchemaPush(opts) {
+    const session = requireSession();
+    const proxy = getDbProxy(session);
+    const envSlug = session.project.env_slug;
+    const productTag = session.project.product_tag;
+    const dbContext = { database: opts.db, env: envSlug, product: productTag };
+    console.log(`Connecting to database "${opts.db}" (env: ${envSlug})...`);
+    let tableNames = [];
+    try {
+        const raw = await proxy.execute('schema.list', [null], dbContext);
+        if (Array.isArray(raw)) {
+            tableNames = raw.map((r) => typeof r === 'string' ? r : String(r.name ?? '')).filter(Boolean);
+        }
+    }
+    catch (e) {
+        throw new Error(`Failed to list tables: ${e.message}. Make sure the database is connected.`);
+    }
+    if (tableNames.length === 0) {
+        console.log('No tables found in the database. Nothing to push.');
+        return;
+    }
+    console.log(`Found ${tableNames.length} table(s): ${tableNames.join(', ')}`);
+    const now = new Date().toISOString();
+    const tableSchemas = [];
+    for (const tableName of tableNames) {
+        try {
+            const tableSchema = await proxy.execute('schema.describe', [tableName], dbContext);
+            const cols = Array.isArray(tableSchema?.columns)
+                ? tableSchema.columns
+                : Array.isArray(tableSchema) ? tableSchema : [];
+            if (cols.length === 0) {
+                console.warn(`  [skip] ${tableName}: no columns returned`);
+                continue;
+            }
+            const columns = cols
+                .filter((c) => c.name)
+                .map(adaptColumn);
+            tableSchemas.push({ table: tableName, columns, updated_at: now });
+            console.log(`  ${tableName}: ${columns.length} column(s)`);
+        }
+        catch (e) {
+            console.warn(`  [skip] ${tableName}: ${e.message}`);
+        }
+    }
+    if (tableSchemas.length === 0) {
+        console.log('No schema data collected. Nothing pushed.');
+        return;
+    }
+    console.log(`\nPushing schema for ${tableSchemas.length} table(s) to Ductape...`);
+    const result = await pushDatabaseSchema(session.apiUrl, session.credentials, {
+        workspace_id: session.project.workspace_id,
+        product_tag: productTag,
+        database_tag: opts.db,
+        table_schemas: tableSchemas,
+    });
+    console.log(`Done. Synced ${result.synced} table(s): ${result.tables.join(', ')}`);
+    console.log('The AI payload generator will now use this schema for field guidance.');
+}

package/dist/index.js

@@ -16,7 +16,7 @@ import { runResourceCrud, runResourcesList } from './commands/resources.js';
 import { runCloud } from './commands/cloud.js';
 import { runDb, runDbContext } from './commands/db.js';
 import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
-import { runDbSchemaGenerate } from './commands/db-schema.js';
+import { runDbSchemaGenerate, runDbSchemaPush } from './commands/db-schema.js';
 import { runGraph } from './commands/graph.js';
 import { runSecrets } from './commands/secrets.js';
 import { runWorkspacesCurrent, runWorkspacesList, runWorkspacesRefresh, runWorkspacesUse, } from './commands/workspaces.js';
@@ -305,6 +305,11 @@ dbSchema
     .option('--db <tag>', 'Limit to one db entry from schema.json')
     .option('--destructive', 'Also generate drop migrations for removed fields/tables')
     .action(wrap((opts) => runDbSchemaGenerate({ db: opts.db, destructive: Boolean(opts.destructive) })));
+dbSchema
+    .command('push')
+    .description('Read live table schema from the database and sync it to the Ductape server (enables AI field guidance)')
+    .requiredOption('--db <tag>', 'Database tag to sync')
+    .action(wrap((opts) => runDbSchemaPush({ db: opts.db })));
 db
     .argument('[verb]', 'connect | query | …')
     .option('-f, --file <path>')

package/dist/lib/integrations.d.ts

@@ -1,4 +1,18 @@
 import type { Credentials } from './config.js';
+export interface TableColumnRecord {
+    name: string;
+    type: string;
+    nullable: boolean;
+    primaryKey: boolean;
+    unique: boolean;
+    autoIncrement: boolean;
+    defaultValue?: unknown;
+}
+export interface TableSchemaRecord {
+    table: string;
+    columns: TableColumnRecord[];
+    updated_at: string;
+}
 export interface GeneratePayloadRequest {
     workspace_id: string;
     user_id: string;
@@ -18,3 +32,12 @@ export interface GeneratePayloadResponse {
     meta: Record<string, unknown>;
 }
 export declare function generateExecutablePayload(apiUrl: string, creds: Credentials, request: GeneratePayloadRequest): Promise<GeneratePayloadResponse>;
+export declare function pushDatabaseSchema(apiUrl: string, creds: Credentials, opts: {
+    workspace_id: string;
+    product_tag: string;
+    database_tag: string;
+    table_schemas: TableSchemaRecord[];
+}): Promise<{
+    synced: number;
+    tables: string[];
+}>;

package/dist/lib/integrations.js

@@ -18,3 +18,30 @@ export async function generateExecutablePayload(apiUrl, creds, request) {
     }
     return (body.data ?? body);
 }
+export async function pushDatabaseSchema(apiUrl, creds, opts) {
+    const url = `${apiUrl}/integrations/v1/databases/schema-sync`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${creds.auth_token}`,
+            'x-access-key': creds.public_key,
+        },
+        body: JSON.stringify({
+            workspace_id: opts.workspace_id,
+            product_tag: opts.product_tag,
+            database_tag: opts.database_tag,
+            table_schemas: opts.table_schemas,
+        }),
+    });
+    const body = await res.json();
+    if (!res.ok) {
+        const msg = body.errors ?? body.message;
+        throw new Error(typeof msg === 'string' ? msg : `Schema sync failed (${res.status})`);
+    }
+    if (body.status === false) {
+        const msg = body.errors ?? body.message;
+        throw new Error(typeof msg === 'string' ? msg : 'Schema sync failed');
+    }
+    return (body.data ?? body);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/db-migrate.ts

@@ -30,13 +30,11 @@ function buildDbContext(dbTag: string, envSlug: string, productTag: string): Dat
 async function getAppliedTags(
   proxy: ReturnType<typeof getDbProxy>,
   dbContext: DatabaseContext,
-  productTag: string,
-  envSlug: string,
 ): Promise<string[]> {
   try {
     const result = await proxy.execute<unknown>(
-      'migration.list',
-      [{ product: productTag, env: envSlug, database: dbContext.database }],
+      'migration.history',
+      [],
       dbContext,
     );
     const list = Array.isArray(result)
@@ -80,7 +78,7 @@ export async function runDbMigrate(opts: MigrateOpts): Promise<void> {
       continue;
     }
 
-    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+    const appliedTags = await getAppliedTags(proxy, dbContext);
     const pending = migrations.filter((m) => !appliedTags.includes(m.tag));
 
     if (pending.length === 0) {
@@ -139,7 +137,7 @@ export async function runDbMigrateStatus(opts: MigrateStatusOpts): Promise<void>
     const { db } = entry;
     const dbContext = buildDbContext(db, envSlug, productTag);
     const migrations = loadMigrationFiles(dir, db);
-    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+    const appliedTags = await getAppliedTags(proxy, dbContext);
 
     const applied = migrations.filter((m) => appliedTags.includes(m.tag)).map((m) => m.tag);
     const pending = migrations.filter((m) => !appliedTags.includes(m.tag)).map((m) => m.tag);
@@ -183,7 +181,7 @@ export async function runDbMigrateRollback(opts: MigrateRollbackOpts): Promise<v
     const { db } = entry;
     const dbContext = buildDbContext(db, envSlug, productTag);
     const migrations = loadMigrationFiles(dir, db);
-    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+    const appliedTags = await getAppliedTags(proxy, dbContext);
 
     const applied = migrations.filter((m) => appliedTags.includes(m.tag));
     const toRollback = applied.slice(-rollbackCount).reverse();

package/src/commands/db-schema.ts

@@ -5,6 +5,8 @@ import { loadSchemaFile, getSchemaPath, parseTableDef } from '../lib/schema-load
 import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
 import { fail } from '../lib/output.js';
 import { getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { pushDatabaseSchema } from '../lib/integrations.js';
+import type { TableSchemaRecord, TableColumnRecord } from '../lib/integrations.js';
 import type { SchemaEntry, MongooseFieldDef } from '../lib/schema-loader.js';
 import type {
   IMigration,
@@ -335,3 +337,91 @@ export async function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<voi
 function requireSilent(): ReturnType<typeof requireSession> | null {
   try { return requireSession(); } catch { return null; }
 }
+
+interface SchemaPushOpts {
+  db: string;
+}
+
+function adaptColumn(col: Record<string, unknown>): TableColumnRecord {
+  return {
+    name: String(col.name ?? ''),
+    type: String(col.type ?? 'string'),
+    nullable: col.nullable !== false && col.nullable !== 'NO',
+    primaryKey: Boolean(col.primaryKey ?? col.isPrimaryKey),
+    unique: Boolean(col.unique ?? col.isUnique),
+    autoIncrement: Boolean(col.autoIncrement ?? col.isAutoIncrement ?? col.autoGenerate),
+    ...(col.defaultValue != null ? { defaultValue: col.defaultValue } : {}),
+  };
+}
+
+export async function runDbSchemaPush(opts: SchemaPushOpts): Promise<void> {
+  const session = requireSession();
+  const proxy = getDbProxy(session);
+  const envSlug = session.project.env_slug;
+  const productTag = session.project.product_tag;
+  const dbContext = { database: opts.db, env: envSlug, product: productTag };
+
+  console.log(`Connecting to database "${opts.db}" (env: ${envSlug})...`);
+
+  let tableNames: string[] = [];
+  try {
+    const raw = await proxy.execute<unknown>('schema.list', [null], dbContext);
+    if (Array.isArray(raw)) {
+      tableNames = (raw as unknown[]).map((r) =>
+        typeof r === 'string' ? r : String((r as Record<string, unknown>).name ?? ''),
+      ).filter(Boolean);
+    }
+  } catch (e) {
+    throw new Error(`Failed to list tables: ${(e as Error).message}. Make sure the database is connected.`);
+  }
+
+  if (tableNames.length === 0) {
+    console.log('No tables found in the database. Nothing to push.');
+    return;
+  }
+
+  console.log(`Found ${tableNames.length} table(s): ${tableNames.join(', ')}`);
+
+  const now = new Date().toISOString();
+  const tableSchemas: TableSchemaRecord[] = [];
+
+  for (const tableName of tableNames) {
+    try {
+      const tableSchema = await proxy.execute<unknown>('schema.describe', [tableName], dbContext);
+      const cols: unknown[] = Array.isArray((tableSchema as Record<string, unknown>)?.columns)
+        ? ((tableSchema as Record<string, unknown>).columns as unknown[])
+        : Array.isArray(tableSchema) ? (tableSchema as unknown[]) : [];
+
+      if (cols.length === 0) {
+        console.warn(`  [skip] ${tableName}: no columns returned`);
+        continue;
+      }
+
+      const columns = (cols as Record<string, unknown>[])
+        .filter((c) => c.name)
+        .map(adaptColumn);
+
+      tableSchemas.push({ table: tableName, columns, updated_at: now });
+      console.log(`  ${tableName}: ${columns.length} column(s)`);
+    } catch (e) {
+      console.warn(`  [skip] ${tableName}: ${(e as Error).message}`);
+    }
+  }
+
+  if (tableSchemas.length === 0) {
+    console.log('No schema data collected. Nothing pushed.');
+    return;
+  }
+
+  console.log(`\nPushing schema for ${tableSchemas.length} table(s) to Ductape...`);
+
+  const result = await pushDatabaseSchema(session.apiUrl, session.credentials, {
+    workspace_id: session.project.workspace_id,
+    product_tag: productTag,
+    database_tag: opts.db,
+    table_schemas: tableSchemas,
+  });
+
+  console.log(`Done. Synced ${result.synced} table(s): ${result.tables.join(', ')}`);
+  console.log('The AI payload generator will now use this schema for field guidance.');
+}

package/src/index.ts

@@ -16,7 +16,7 @@ import { runResourceCrud, runResourcesList } from './commands/resources.js';
 import { runCloud } from './commands/cloud.js';
 import { runDb, runDbContext } from './commands/db.js';
 import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
-import { runDbSchemaGenerate } from './commands/db-schema.js';
+import { runDbSchemaGenerate, runDbSchemaPush } from './commands/db-schema.js';
 import { runGraph } from './commands/graph.js';
 import { runSecrets } from './commands/secrets.js';
 import {
@@ -398,6 +398,12 @@ dbSchema
   .option('--destructive', 'Also generate drop migrations for removed fields/tables')
   .action(wrap((opts) => runDbSchemaGenerate({ db: opts.db, destructive: Boolean(opts.destructive) })));
 
+dbSchema
+  .command('push')
+  .description('Read live table schema from the database and sync it to the Ductape server (enables AI field guidance)')
+  .requiredOption('--db <tag>', 'Database tag to sync')
+  .action(wrap((opts) => runDbSchemaPush({ db: opts.db })));
+
 db
   .argument('[verb]', 'connect | query | …')
   .option('-f, --file <path>')

package/src/lib/integrations.ts

@@ -1,5 +1,21 @@
 import type { Credentials } from './config.js';
 
+export interface TableColumnRecord {
+  name: string;
+  type: string;
+  nullable: boolean;
+  primaryKey: boolean;
+  unique: boolean;
+  autoIncrement: boolean;
+  defaultValue?: unknown;
+}
+
+export interface TableSchemaRecord {
+  table: string;
+  columns: TableColumnRecord[];
+  updated_at: string;
+}
+
 export interface GeneratePayloadRequest {
   workspace_id: string;
   user_id: string;
@@ -45,3 +61,41 @@ export async function generateExecutablePayload(
   }
   return (body.data ?? body) as GeneratePayloadResponse;
 }
+
+export async function pushDatabaseSchema(
+  apiUrl: string,
+  creds: Credentials,
+  opts: {
+    workspace_id: string;
+    product_tag: string;
+    database_tag: string;
+    table_schemas: TableSchemaRecord[];
+  },
+): Promise<{ synced: number; tables: string[] }> {
+  const url = `${apiUrl}/integrations/v1/databases/schema-sync`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${creds.auth_token}`,
+      'x-access-key': creds.public_key,
+    },
+    body: JSON.stringify({
+      workspace_id: opts.workspace_id,
+      product_tag: opts.product_tag,
+      database_tag: opts.database_tag,
+      table_schemas: opts.table_schemas,
+    }),
+  });
+
+  const body = await res.json() as Record<string, unknown>;
+  if (!res.ok) {
+    const msg = (body as any).errors ?? (body as any).message;
+    throw new Error(typeof msg === 'string' ? msg : `Schema sync failed (${res.status})`);
+  }
+  if (body.status === false) {
+    const msg = (body as any).errors ?? (body as any).message;
+    throw new Error(typeof msg === 'string' ? msg : 'Schema sync failed');
+  }
+  return (body.data ?? body) as { synced: number; tables: string[] };
+}