@ductape/cli 0.2.23 → 0.3.1

package/src/commands/db-schema.ts

@@ -1,429 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { findProjectConfig } from '../lib/config.js';
-import { loadSchemaFile, getSchemaPath, parseTableDef } from '../lib/schema-loader.js';
-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,
-  IMigrationOperation,
-  ICreateCollectionOp,
-  IDropCollectionOp,
-  IAddFieldOp,
-  ICreateIndexOp,
-} from '../lib/db-types.js';
-
-interface SchemaGenerateOpts {
-  db?: string;
-  destructive?: boolean;
-}
-
-interface ReconstructedTable {
-  fields: Set<string>;
-}
-
-function replayMigrations(migrations: IMigration[]): Map<string, ReconstructedTable> {
-  const schema = new Map<string, ReconstructedTable>();
-  for (const migration of migrations) {
-    for (const op of migration.up) {
-      if (op.type === 'createCollection') {
-        if (!schema.has(op.name)) {
-          schema.set(op.name, { fields: new Set(op.fields.map((f) => f.name)) });
-        }
-      } else if (op.type === 'dropCollection') {
-        schema.delete(op.name);
-      } else if (op.type === 'addField') {
-        const t = schema.get(op.collection);
-        if (t) t.fields.add(op.field.name);
-      } else if (op.type === 'dropField') {
-        const t = schema.get(op.collection);
-        if (t) t.fields.delete(op.fieldName);
-      }
-    }
-  }
-  return schema;
-}
-
-function columnTypeToMongooseType(raw: string): string {
-  // Normalise: uppercase, collapse whitespace (handles "character varying", "timestamp without time zone", etc.)
-  const t = raw.toUpperCase().replace(/\s+/g, ' ').trim();
-  switch (t) {
-    case 'BIGINT': case 'INT8': return 'bigint';
-    case 'SMALLINT': case 'TINYINT': case 'INT2': return 'smallint';
-    case 'INTEGER': case 'INT': case 'INT4': case 'NUMBER': return 'number';
-    case 'FLOAT': case 'REAL': case 'FLOAT4': case 'FLOAT8': case 'DOUBLE PRECISION': return 'number'; // caller sets float:true
-    case 'DOUBLE': return 'double';
-    case 'DECIMAL': case 'NUMERIC': case 'DECIMAL128': return 'decimal';
-    case 'TEXT': case 'MEDIUMTEXT': case 'LONGTEXT': case 'TINYTEXT': return 'text';
-    case 'STRING': case 'VARCHAR': case 'CHARACTER VARYING': case 'CHAR': case 'CHARACTER': case 'BPCHAR': return 'string';
-    case 'BOOLEAN': case 'BOOL': return 'boolean';
-    case 'DATE': case 'DATETIME': return 'date';
-    case 'TIME': case 'TIME WITHOUT TIME ZONE': case 'TIME WITH TIME ZONE': return 'time';
-    case 'TIMESTAMP': case 'TIMESTAMPTZ': case 'TIMESTAMP WITHOUT TIME ZONE': case 'TIMESTAMP WITH TIME ZONE': return 'timestamp';
-    case 'JSON': case 'JSONB': return 'json';
-    case 'BINARY': case 'VARBINARY': case 'BYTEA': return 'binary';
-    case 'BLOB': case 'MEDIUMBLOB': case 'LONGBLOB': case 'TINYBLOB': return 'blob';
-    case 'UUID': case 'OBJECTID': return 'uuid';
-    case 'OBJECT': case 'MIXED': case 'MAP': case 'HSTORE': return 'mixed';
-    case 'ARRAY': return 'array';
-    default: return 'string';
-  }
-}
-
-function buildMongooseFieldDef(col: Record<string, unknown>): MongooseFieldDef {
-  const rawType = String(col.type ?? 'string');
-  const mongooseType = columnTypeToMongooseType(rawType);
-  const def: MongooseFieldDef = { type: mongooseType };
-
-  const upperType = rawType.toUpperCase().trim();
-  if (upperType === 'FLOAT' || upperType === 'REAL' || upperType === 'FLOAT4' || upperType === 'FLOAT8' || upperType === 'DOUBLE PRECISION') def.float = true;
-
-  // Handle both IColumnDefinition style (primaryKey/unique) and IColumnInfo style (isPrimaryKey/isUnique)
-  if (col.nullable === false || col.required === true) def.required = true;
-  if (col.unique === true || col.isUnique === true) def.unique = true;
-  if (col.primaryKey === true || col.isPrimaryKey === true) def.primaryKey = true;
-  if (col.autoIncrement === true || col.isAutoIncrement === true || col.autoGenerate === true) def.autoGenerate = true;
-
-  // Handle both camelCase (defaultValue) and snake_case (default_value) from different adapters
-  const defVal = col.defaultValue ?? col.default_value;
-  if (defVal !== undefined && defVal !== null) def.default = defVal as unknown;
-
-  // Handle both camelCase (length/maxLength) and snake_case (max_length) from different adapters
-  const len = col.length ?? col.maxLength ?? col.max_length;
-  if (typeof len === 'number') def.maxlength = len;
-
-  if (Array.isArray(col.enumValues) && (col.enumValues as string[]).length > 0) {
-    def.type = 'string';
-    def.enum = col.enumValues as string[];
-  }
-
-  return def;
-}
-
-async function tryHydrateFromCloud(
-  dir: string,
-  schemaPath: string,
-  opts: SchemaGenerateOpts,
-): Promise<SchemaEntry[]> {
-  if (!opts.db) return [];
-
-  let session: ReturnType<typeof requireSession>;
-  try {
-    session = requireSession();
-  } catch {
-    return [];
-  }
-
-  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 };
-
-  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 : typeof (r as Record<string, unknown>).name === 'string' ? String((r as Record<string, unknown>).name) : null,
-      ).filter((n): n is string => n !== null);
-    }
-  } catch {
-    return [];
-  }
-
-  if (tableNames.length === 0) return [];
-
-  const tables: Record<string, Record<string, MongooseFieldDef>> = {};
-
-  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) {
-        tables[tableName] = {};
-        continue;
-      }
-
-      const indexedFields = new Set<string>();
-      const uniqueIndexFields = new Set<string>();
-      const rawIndexes = (tableSchema as Record<string, unknown>)?.indexes;
-      if (Array.isArray(rawIndexes)) {
-        for (const idx of rawIndexes as Record<string, unknown>[]) {
-          const idxCols = Array.isArray(idx.columns) ? (idx.columns as Record<string, unknown>[]) : [];
-          if (idxCols.length === 1) {
-            const fieldName = String(idxCols[0].name ?? idxCols[0]);
-            if (idx.unique) uniqueIndexFields.add(fieldName);
-            else indexedFields.add(fieldName);
-          }
-        }
-      }
-
-      const fieldMap: Record<string, MongooseFieldDef> = {};
-      for (const col of cols as Record<string, unknown>[]) {
-        const name = String(col.name ?? '');
-        if (!name) continue;
-        const def = buildMongooseFieldDef(col);
-        if (uniqueIndexFields.has(name)) { def.unique = true; def.index = true; }
-        else if (indexedFields.has(name)) def.index = true;
-        fieldMap[name] = def;
-      }
-      tables[tableName] = fieldMap;
-    } catch {
-      tables[tableName] = {};
-    }
-  }
-
-  const entry: SchemaEntry = { db: opts.db, tables };
-  const entries = [entry];
-  fs.writeFileSync(schemaPath, JSON.stringify(entries, null, 2), 'utf8');
-  console.log(`[${opts.db}] Hydrated schema.json from cloud (${tableNames.length} collection(s)): ${tableNames.join(', ')}`);
-  return entries;
-}
-
-export async function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<void> {
-  const found = findProjectConfig();
-  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
-
-  const { dir } = found;
-  const schemaPath = getSchemaPath(dir);
-
-  let schemaEntries: SchemaEntry[];
-  let wasScaffolded = false;
-
-  if (!fs.existsSync(schemaPath)) {
-    // Create directory and empty schema.json first
-    fs.mkdirSync(path.dirname(schemaPath), { recursive: true });
-    fs.writeFileSync(schemaPath, '[]', 'utf8');
-    wasScaffolded = true;
-    console.log(`Created ${path.relative(dir, schemaPath)}`);
-
-    // Try to hydrate from the cloud (requires --db and an active session)
-    schemaEntries = await tryHydrateFromCloud(dir, schemaPath, opts);
-
-    if (schemaEntries.length === 0) {
-      const hint = opts.db
-        ? `(no existing collections found in "${opts.db}" for env "${requireSilent()?.project?.env_slug ?? 'default'}")`
-        : '(pass --db <tag> to auto-import existing collections from the cloud)';
-      console.log(`schema.json is empty ${hint}. Add your collection definitions and run \`ductape db schema generate\` again.`);
-      return;
-    }
-  } else {
-    schemaEntries = loadSchemaFile(dir);
-  }
-
-  const targets = opts.db
-    ? schemaEntries.filter((e) => e.db === opts.db)
-    : schemaEntries;
-
-  if (targets.length === 0) {
-    if (wasScaffolded) return; // already printed a message above
-    fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
-  }
-
-  let totalGenerated = 0;
-
-  for (const entry of targets) {
-    const { db, tables } = entry;
-    const existing = loadMigrationFiles(dir, db);
-    const current = replayMigrations(existing);
-    const newMigrations: IMigration[] = [];
-    let counter = existing.length + 1;
-
-    for (const [tableName, fieldDefs] of Object.entries(tables)) {
-      const parsed = parseTableDef(tableName, fieldDefs);
-      const currentTable = current.get(tableName);
-
-      if (!currentTable) {
-        const up: IMigrationOperation[] = [
-          {
-            type: 'createCollection',
-            name: tableName,
-            fields: parsed.fields,
-            ifNotExists: true,
-          } as ICreateCollectionOp,
-        ];
-        for (const { fieldName, unique } of parsed.indexFields) {
-          up.push({
-            type: 'createIndex',
-            collection: tableName,
-            name: `${tableName}_${fieldName}_idx`,
-            fields: [{ name: fieldName }],
-            unique,
-            ifNotExists: true,
-          } as ICreateIndexOp);
-        }
-        const down: IMigrationOperation[] = [
-          { type: 'dropCollection', name: tableName, ifExists: true } as IDropCollectionOp,
-        ];
-
-        newMigrations.push({
-          tag: `create_${tableName}`,
-          name: `Create collection ${tableName}`,
-          up,
-          down,
-          createdAt: new Date().toISOString(),
-        });
-      } else {
-        const addOps: IMigrationOperation[] = [];
-        const dropOps: IMigrationOperation[] = [];
-
-        for (const field of parsed.fields) {
-          if (!currentTable.fields.has(field.name)) {
-            addOps.push({ type: 'addField', collection: tableName, field } as IAddFieldOp);
-          }
-        }
-
-        const desiredFields = new Set(parsed.fields.map((f) => f.name));
-        const removedFields: string[] = [];
-        for (const existingField of currentTable.fields) {
-          if (!desiredFields.has(existingField)) {
-            removedFields.push(existingField);
-            if (opts.destructive) {
-              dropOps.push({ type: 'dropField', collection: tableName, fieldName: existingField });
-            }
-          }
-        }
-        if (!opts.destructive && removedFields.length > 0) {
-          console.warn(
-            `  [${db}] Warning: field(s) removed from schema.json for "${tableName}": ${removedFields.join(', ')}. Pass --destructive to generate drop migrations.`,
-          );
-        }
-
-        const allOps = [...addOps, ...dropOps];
-        if (allOps.length > 0) {
-          const down: IMigrationOperation[] = addOps.map((op) => ({
-            type: 'dropField' as const,
-            collection: tableName,
-            fieldName: (op as IAddFieldOp).field.name,
-          }));
-
-          newMigrations.push({
-            tag: `alter_${tableName}_${Date.now()}`,
-            name: `Alter collection ${tableName}`,
-            up: allOps,
-            down,
-            createdAt: new Date().toISOString(),
-          });
-        }
-      }
-    }
-
-    if (newMigrations.length === 0) {
-      console.log(`[${db}] Schema is up to date. No migrations generated.`);
-      continue;
-    }
-
-    for (const migration of newMigrations) {
-      const filePath = writeMigrationFile(dir, db, migration, counter++);
-      console.log(`[${db}] Generated ${path.basename(filePath)}`);
-      totalGenerated++;
-    }
-  }
-
-  if (totalGenerated > 0) {
-    console.log(`\nGenerated ${totalGenerated} migration file(s). Run \`ductape db migrate\` to apply them.`);
-  }
-}
-
-function requireSilent(): ReturnType<typeof requireSession> | null {
-  try { return requireSession(); } catch { return null; }
-}
-
-interface SchemaPushOpts {
-  db: string;
-  env: 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 = opts.env;
-  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((n) => Boolean(n) && !n.startsWith('_ductape_'));
-    }
-  } 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,
-    env_slug: envSlug,
-    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/commands/db.ts

@@ -1,63 +0,0 @@
-import { readJsonBody } from '../lib/read-body.js';
-import { setDatabaseContext } from '../lib/context-store.js';
-import { DB_PROXY_METHODS } from '../lib/db-methods.js';
-import { getDbContext, getDbProxy, requireSession } from '../lib/proxy/context.js';
-import { loadRuntimeContext } from '../lib/context-store.js';
-import { printJson } from '../lib/output.js';
-
-export async function runDb(
-  method: string,
-  opts: { file?: string; json?: boolean },
-): Promise<void> {
-  const session = requireSession();
-  const proxy = getDbProxy(session);
-  const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
-  const dbContext = runtime?.database_context ?? null;
-  const body = readJsonBody(opts.file) as Record<string, unknown>;
-
-  const m = method.toLowerCase();
-  if (!DB_PROXY_METHODS.includes(m as (typeof DB_PROXY_METHODS)[number]) && !m.includes('.')) {
-    console.warn(`Method "${m}" not in known list; sending anyway.`);
-  }
-
-  let params: unknown[] = [];
-  if (m === 'connect') {
-    const cfg = {
-      product: session.project.product_tag,
-      env: session.project.env_slug,
-      database: body.database ?? body.tag,
-      ...body,
-    };
-    params = [cfg];
-  } else if (m === 'list') {
-    params = [session.project.product_tag];
-  } else if (Object.keys(body).length > 0) {
-    params = [
-      {
-        product: session.project.product_tag,
-        env: session.project.env_slug,
-        ...body,
-      },
-    ];
-  }
-
-  const result = await proxy.execute(m, params, dbContext);
-
-  if (m === 'connect' && params[0] && typeof params[0] === 'object') {
-    const cfg = params[0] as { database: string; env: string; product: string };
-    setDatabaseContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
-      database: String(cfg.database),
-      env: String(cfg.env),
-      product: String(cfg.product),
-    });
-  }
-
-  printJson(result, Boolean(opts.json));
-}
-
-export function runDbContext(json: boolean): void {
-  const session = requireSession();
-  const ctx = getDbContext(session);
-  const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
-  printJson({ database_context: runtime?.database_context ?? ctx }, json);
-}

package/src/commands/generate.ts

@@ -1,74 +0,0 @@
-import fs from 'node:fs';
-import { requireSession } from '../lib/proxy/context.js';
-import { generateExecutablePayload } from '../lib/integrations.js';
-import {
-  buildSnippet,
-  ensureSupportedSnippetOperation,
-} from '../lib/snippets.js';
-import { printJson } from '../lib/output.js';
-
-export async function runGeneratePayload(opts: {
-  family: string;
-  method: string;
-  file?: string;
-  json?: boolean;
-}): Promise<void> {
-  const session = requireSession();
-  let targets: Record<string, unknown> | undefined;
-  if (opts.file) {
-    targets = JSON.parse(fs.readFileSync(opts.file, 'utf8')) as Record<string, unknown>;
-  }
-
-  const result = await generateExecutablePayload(session.apiUrl, session.credentials, {
-    workspace_id: session.project.workspace_id,
-    user_id: session.credentials.user_id,
-    public_key: session.credentials.public_key,
-    product_tag: session.project.product_tag,
-    env_slug: session.project.env_slug,
-    operation_family: opts.family,
-    method: opts.method,
-    targets,
-    include_session: true,
-    include_cache: false,
-    schema_mode: 'best_effort',
-  });
-
-  printJson(result, Boolean(opts.json));
-}
-
-export async function runGenerateSnippet(opts: {
-  family: string;
-  method: string;
-  language: 'typescript' | 'python' | 'go' | 'dotnet';
-  file?: string;
-  json?: boolean;
-  out?: string;
-}): Promise<void> {
-  ensureSupportedSnippetOperation(opts.family, opts.method);
-  const session = requireSession();
-  let targets: Record<string, unknown> | undefined;
-  if (opts.file) {
-    targets = JSON.parse(fs.readFileSync(opts.file, 'utf8')) as Record<string, unknown>;
-  }
-
-  const generated = await generateExecutablePayload(session.apiUrl, session.credentials, {
-    workspace_id: session.project.workspace_id,
-    user_id: session.credentials.user_id,
-    public_key: session.credentials.public_key,
-    product_tag: session.project.product_tag,
-    env_slug: session.project.env_slug,
-    operation_family: opts.family,
-    method: opts.method,
-    targets,
-  });
-
-  const payload = generated.payload ?? {};
-  const snippet = buildSnippet(opts.language, payload, opts.family, opts.method);
-  const output = { payload: generated, snippet };
-
-  if (opts.out) {
-    fs.writeFileSync(opts.out, snippet);
-    console.log(`Wrote snippet to ${opts.out}`);
-  }
-  printJson(output, Boolean(opts.json));
-}

package/src/commands/graph.ts

@@ -1,51 +0,0 @@
-import { readJsonBody } from '../lib/read-body.js';
-import { setGraphContext } from '../lib/context-store.js';
-import { GRAPH_PROXY_METHODS } from '../lib/db-methods.js';
-import { getGraphProxy, requireSession } from '../lib/proxy/context.js';
-import { printJson } from '../lib/output.js';
-
-export async function runGraph(
-  method: string,
-  opts: { file?: string; json?: boolean },
-): Promise<void> {
-  const session = requireSession();
-  const proxy = getGraphProxy(session);
-  const body = readJsonBody(opts.file) as Record<string, unknown>;
-
-  const m = method.includes('.') ? method : method.toLowerCase();
-  if (!GRAPH_PROXY_METHODS.includes(m as (typeof GRAPH_PROXY_METHODS)[number]) && !m.includes('.')) {
-    console.warn(`Method "${m}" not in known list; sending anyway. Known: ${GRAPH_PROXY_METHODS.join(', ')}`);
-  }
-
-  const params: unknown[] = [];
-  if (m === 'connect') {
-    const cfg = {
-      product: session.project.product_tag,
-      env: session.project.env_slug,
-      graph: body.graph ?? body.tag,
-      ...body,
-    };
-    params.push(cfg);
-  } else if (Object.keys(body).length > 0) {
-    params.push({
-      product: session.project.product_tag,
-      env: session.project.env_slug,
-      ...body,
-    });
-  } else if (m === 'fetchAll' || m === 'list') {
-    params.push(session.project.product_tag);
-  }
-
-  const result = await proxy.execute(m === 'list' ? 'fetchAll' : m, params);
-
-  if (m === 'connect' && params[0] && typeof params[0] === 'object') {
-    const cfg = params[0] as { graph: string; env: string; product: string };
-    setGraphContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
-      graph: String(cfg.graph),
-      env: String(cfg.env),
-      product: String(cfg.product),
-    });
-  }
-
-  printJson(result, Boolean(opts.json));
-}

package/src/commands/init.ts

@@ -1,39 +0,0 @@
-import { saveProjectConfig, type ProjectConfig } from '../lib/config.js';
-import { detectLanguage, writeInitArtifacts } from '../lib/templates.js';
-import { success } from '../lib/output.js';
-import { runLink } from './link.js';
-
-export async function runInit(opts: {
-  link?: boolean;
-  workspace?: string;
-  product?: string;
-  env?: string;
-  language?: string;
-}): Promise<void> {
-  const dir = process.cwd();
-  const lang =
-    opts.language && ['typescript', 'python', 'go', 'dotnet'].includes(opts.language)
-      ? (opts.language as 'typescript' | 'python' | 'go' | 'dotnet')
-      : detectLanguage(dir);
-
-  writeInitArtifacts(dir, lang);
-
-  if (!opts.link) {
-    const stub: ProjectConfig = {
-      workspace_tag: '',
-      product_tag: '',
-      env_slug: opts.env ?? 'dev',
-    };
-    saveProjectConfig(dir, stub);
-    success(`Initialized Ductape (${lang}). Run \`ductape link\` to connect workspace/product.`);
-    return;
-  }
-
-  await runLink({
-    workspace: opts.workspace,
-    product: opts.product,
-    env: opts.env,
-    dir,
-  });
-  success(`Initialized and linked Ductape project (${lang})`);
-}