@happyvertical/smrt-core 0.30.0

package/dist/scripts/generate-manifest.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * Build-time manifest generator
+ * Scans TypeScript source files and generates static manifest JSON
+ *
+ * Now uses ManifestBuilder service for consolidated, testable logic
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+
+async function generateManifest() {
+  try {
+    console.log('[smrt] Generating static manifest...');
+
+    const workspaceTsconfigPath = resolve(
+      process.cwd(),
+      '../../tsconfig.package-build.json',
+    );
+    const unregister = register(
+      existsSync(workspaceTsconfigPath)
+        ? { tsconfig: workspaceTsconfigPath }
+        : undefined,
+    );
+
+    try {
+      const { ManifestBuilder } = await import(
+        pathToFileURL(resolve(process.cwd(), 'src/manifest/generator.ts')).href
+      );
+
+      const builder = new ManifestBuilder();
+
+      await builder.generate({
+        // === FILE DISCOVERY ===
+        include: ['src/**/*.ts'],
+        exclude: [
+          'src/**/*.test.ts',
+          'src/**/*.spec.ts',
+          'src/**/__tests__/**/*.ts',
+          'src/**/*.d.ts',
+          'src/scanner/**/*.ts',
+          'src/vite-plugin/**/*.ts',
+          'src/pleb.ts', // Test/prototype class - not a real framework object
+        ],
+
+        // === SCANNER CONFIGURATION ===
+        baseClasses: ['SmrtObject', 'SmrtClass', 'SmrtCollection'],
+        followImports: false,
+        loadViteConfig: false,
+        discoverExternalPackages: true,
+        includeExternalBaseClasses: false, // Build manifest doesn't need external base classes
+
+        // === OUTPUT CONFIGURATION ===
+        outputDir: 'src/manifest',
+        outputName: 'static-manifest.json',
+        generateTypeStub: true,
+        stubName: 'static-manifest.ts',
+
+        // === METADATA ===
+        injectPackageInfo: true,
+        moduleType: 'smrt',
+      });
+
+      const { buildDomainKnowledgeManifest } = await import(
+        pathToFileURL(resolve(process.cwd(), 'src/knowledge.ts')).href
+      );
+      const sourceManifestPath = resolve(
+        process.cwd(),
+        'src/manifest/static-manifest.json',
+      );
+      const distManifestPath = resolve(process.cwd(), 'dist/manifest.json');
+      const manifestPath = existsSync(distManifestPath)
+        ? distManifestPath
+        : sourceManifestPath;
+      const manifest = JSON.parse(readFileSync(sourceManifestPath, 'utf8'));
+      const packageJson = JSON.parse(
+        readFileSync(resolve(process.cwd(), 'package.json'), 'utf8'),
+      );
+      const knowledgePath = resolve(
+        process.cwd(),
+        'src/manifest/smrt-knowledge.json',
+      );
+      const knowledge = preserveGeneratedAtIfUnchanged(
+        knowledgePath,
+        buildDomainKnowledgeManifest({
+          manifest,
+          rootDir: process.cwd(),
+          packageJson,
+          manifestPath,
+          config: {
+            includeDocs: true,
+            includePrompts: true,
+          },
+        }),
+      );
+      writeFileSync(knowledgePath, JSON.stringify(knowledge, null, 2), 'utf8');
+    } finally {
+      await unregister();
+    }
+  } catch (error) {
+    console.error('[smrt] ❌ Failed to generate manifest:', error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  generateManifest();
+}
+
+function preserveGeneratedAtIfUnchanged(path, nextKnowledge) {
+  if (!existsSync(path)) {
+    return nextKnowledge;
+  }
+
+  try {
+    const current = JSON.parse(readFileSync(path, 'utf8'));
+    if (semanticArtifactJson(current) === semanticArtifactJson(nextKnowledge)) {
+      return {
+        ...nextKnowledge,
+        generatedAt: current.generatedAt,
+      };
+    }
+  } catch {
+    // Replace malformed artifacts.
+  }
+
+  return nextKnowledge;
+}
+
+function semanticArtifactJson(artifact) {
+  const { generatedAt: _generatedAt, ...rest } = artifact ?? {};
+  return stableJson(rest);
+}
+
+function stableJson(value) {
+  return JSON.stringify(sortJson(value));
+}
+
+function sortJson(value) {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, entry]) => [key, sortJson(entry)]),
+    );
+  }
+  return value;
+}
+
+export { generateManifest };

package/dist/scripts/generate-test-manifest.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Test manifest generator
+ * Scans test files and generates manifest for runtime field detection
+ *
+ * This allows test files to use TypeScript type annotations (e.g., latitude: number | null)
+ * instead of requiring explicit Field helpers, maintaining consistency with production code.
+ *
+ * Now uses ManifestBuilder service for consolidated, testable logic
+ */
+
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+
+async function generateTestManifest() {
+  try {
+    console.log('[smrt] Generating test manifest...');
+
+    const workspaceTsconfigPath = resolve(
+      process.cwd(),
+      '../../tsconfig.package-build.json',
+    );
+    const unregister = register(
+      existsSync(workspaceTsconfigPath)
+        ? { tsconfig: workspaceTsconfigPath }
+        : undefined,
+    );
+
+    try {
+      const { ManifestBuilder } = await import(
+        pathToFileURL(resolve(process.cwd(), 'src/manifest/generator.ts')).href
+      );
+
+      const builder = new ManifestBuilder();
+
+      await builder.generate({
+        // === FILE DISCOVERY ===
+        // Scan all source files including test files for test manifest
+        // Test classes defined inline need to be in the manifest for proper field detection
+        include: ['src/**/*.ts'],
+        exclude: ['src/**/*.d.ts', 'node_modules/**'],
+
+        // === SCANNER CONFIGURATION ===
+        baseClasses: ['SmrtObject', 'SmrtClass', 'SmrtCollection'],
+        followImports: true, // Needed for multi-package inheritance (e.g., Meeting extends Event from external package)
+        loadViteConfig: true, // Use custom baseClasses from vite.config.ts if present
+        discoverExternalPackages: true,
+        includeExternalBaseClasses: true, // Test manifest needs external base classes
+
+        // === OUTPUT CONFIGURATION ===
+        outputDir: 'src/manifest',
+        outputName: 'test-manifest.json',
+        generateTypeStub: true,
+        stubName: 'test-manifest-stub.ts',
+
+        // === METADATA ===
+        injectPackageInfo: true,
+        moduleType: 'smrt',
+      });
+    } finally {
+      await unregister();
+    }
+  } catch (error) {
+    console.error('[smrt] ❌ Failed to generate test manifest:', error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  generateTestManifest();
+}
+
+export { generateTestManifest };

package/dist/scripts/migrate-datetime-to-timestamp.ts

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+/**
+ * Migration script for Issue #198: DuckDB DATETIME Compatibility
+ *
+ * This script migrates existing databases from DATETIME to TIMESTAMP type
+ * and from datetime('now') to current_timestamp default values.
+ *
+ * Usage:
+ *   npx tsx scripts/migrate-datetime-to-timestamp.ts <database-path>
+ *
+ * Example:
+ *   npx tsx scripts/migrate-datetime-to-timestamp.ts ./data/my-database.db
+ *
+ * What it does:
+ * 1. Backs up the database file
+ * 2. For each table with DATETIME columns:
+ *    - Creates a new table with TIMESTAMP columns
+ *    - Copies all data from old table to new table
+ *    - Drops old table and renames new table
+ * 3. Recreates indexes and triggers with correct syntax
+ *
+ * Note: This migration is safe and reversible via the backup file.
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { Database } from '@happyvertical/sql';
+
+interface MigrationOptions {
+  databasePath: string;
+  dryRun?: boolean;
+  backup?: boolean;
+}
+
+/**
+ * Main migration function
+ */
+async function migrate(options: MigrationOptions) {
+  const { databasePath, dryRun = false, backup = true } = options;
+
+  // Validate database exists
+  if (!existsSync(databasePath)) {
+    throw new Error(`Database not found: ${databasePath}`);
+  }
+
+  console.log(`🔍 Analyzing database: ${databasePath}`);
+
+  // Create backup if requested
+  if (backup && !dryRun) {
+    const backupPath = `${databasePath}.backup-${Date.now()}`;
+    console.log(`📦 Creating backup: ${backupPath}`);
+    const dbContent = await readFile(databasePath);
+    await writeFile(backupPath, dbContent);
+    console.log(`✅ Backup created successfully`);
+  }
+
+  // Connect to database
+  const db = await Database.connect({
+    type: 'sqlite',
+    url: databasePath,
+  });
+
+  try {
+    // Get all tables
+    const tables = await db.all(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_smrt_%'
+    `);
+
+    console.log(`📊 Found ${tables.length} user tables to check`);
+
+    // Process each table
+    for (const table of tables) {
+      const tableName = table.name;
+      console.log(`\n🔧 Processing table: ${tableName}`);
+
+      // Get table schema
+      const columns = await db.all(`PRAGMA table_info("${tableName}")`);
+
+      // Find DATETIME columns
+      const datetimeColumns = columns.filter((col: any) =>
+        col.type.toUpperCase().includes('DATETIME'),
+      );
+
+      if (datetimeColumns.length === 0) {
+        console.log(`  ✓ No DATETIME columns found, skipping`);
+        continue;
+      }
+
+      console.log(
+        `  📋 Found ${datetimeColumns.length} DATETIME column(s): ${datetimeColumns.map((c: any) => c.name).join(', ')}`,
+      );
+
+      if (dryRun) {
+        console.log(`  🔍 [DRY RUN] Would migrate these columns to TIMESTAMP`);
+        continue;
+      }
+
+      // Create new table with TIMESTAMP columns
+      const newTableName = `${tableName}_new`;
+
+      // Build CREATE TABLE statement for new table
+      const createTableSQL = buildCreateTableSQL(
+        tableName,
+        newTableName,
+        columns,
+      );
+      console.log(`  🏗️  Creating new table: ${newTableName}`);
+      await db.run(createTableSQL);
+
+      // Copy data from old table to new table
+      console.log(`  📤 Copying data to new table...`);
+      const columnNames = columns.map((c: any) => `"${c.name}"`).join(', ');
+      await db.run(`
+        INSERT INTO "${newTableName}" (${columnNames})
+        SELECT ${columnNames} FROM "${tableName}"
+      `);
+
+      // Get row counts to verify
+      const oldCount = await db.get(
+        `SELECT COUNT(*) as count FROM "${tableName}"`,
+      );
+      const newCount = await db.get(
+        `SELECT COUNT(*) as count FROM "${newTableName}"`,
+      );
+
+      if (oldCount.count !== newCount.count) {
+        throw new Error(
+          `Data copy verification failed: ${oldCount.count} rows in old table, ${newCount.count} rows in new table`,
+        );
+      }
+
+      console.log(`  ✅ Copied ${oldCount.count} rows successfully`);
+
+      // Drop old table
+      console.log(`  🗑️  Dropping old table: ${tableName}`);
+      await db.run(`DROP TABLE "${tableName}"`);
+
+      // Rename new table to old table name
+      console.log(`  📝 Renaming ${newTableName} to ${tableName}`);
+      await db.run(`ALTER TABLE "${newTableName}" RENAME TO "${tableName}"`);
+
+      // Recreate indexes
+      const indexes = await db.all(`
+        SELECT sql FROM sqlite_master
+        WHERE type='index' AND tbl_name='${tableName}' AND sql IS NOT NULL
+      `);
+
+      if (indexes.length > 0) {
+        console.log(`  🔗 Recreating ${indexes.length} index(es)...`);
+        for (const index of indexes) {
+          // Update index SQL to use new table name and current_timestamp
+          let indexSQL = index.sql;
+          indexSQL = indexSQL.replace(
+            /datetime\('now'\)/gi,
+            'current_timestamp',
+          );
+          indexSQL = indexSQL.replace(/DATETIME/gi, 'TIMESTAMP');
+          await db.run(indexSQL);
+        }
+      }
+
+      // Recreate triggers
+      const triggers = await db.all(`
+        SELECT sql FROM sqlite_master
+        WHERE type='trigger' AND tbl_name='${tableName}' AND sql IS NOT NULL
+      `);
+
+      if (triggers.length > 0) {
+        console.log(`  ⚡ Recreating ${triggers.length} trigger(s)...`);
+        for (const trigger of triggers) {
+          // Update trigger SQL to use current_timestamp
+          let triggerSQL = trigger.sql;
+          triggerSQL = triggerSQL.replace(
+            /datetime\('now'\)/gi,
+            'current_timestamp',
+          );
+          triggerSQL = triggerSQL.replace(/DATETIME/gi, 'TIMESTAMP');
+          await db.run(triggerSQL);
+        }
+      }
+
+      console.log(`  ✅ Migration complete for table: ${tableName}`);
+    }
+
+    console.log(`\n✨ Migration completed successfully!`);
+  } finally {
+    await db.close();
+  }
+}
+
+/**
+ * Build CREATE TABLE SQL for new table with TIMESTAMP columns
+ */
+function buildCreateTableSQL(
+  _oldTableName: string,
+  newTableName: string,
+  columns: any[],
+): string {
+  let sql = `CREATE TABLE "${newTableName}" (\n`;
+
+  const columnDefs = columns.map((col: any) => {
+    const parts: string[] = [];
+
+    // Column name and type
+    let type = col.type.toUpperCase();
+    // Replace DATETIME with TIMESTAMP
+    if (type.includes('DATETIME')) {
+      type = type.replace('DATETIME', 'TIMESTAMP');
+    }
+    parts.push(`  "${col.name}" ${type}`);
+
+    // Primary key
+    if (col.pk) {
+      parts.push('PRIMARY KEY');
+    }
+
+    // Not null
+    if (col.notnull) {
+      parts.push('NOT NULL');
+    }
+
+    // Default value
+    if (col.dflt_value !== null) {
+      let defaultValue = col.dflt_value;
+      // Replace datetime('now') with current_timestamp
+      if (typeof defaultValue === 'string') {
+        defaultValue = defaultValue.replace(
+          /datetime\('now'\)/gi,
+          'current_timestamp',
+        );
+        defaultValue = defaultValue.replace(
+          /CURRENT_TIMESTAMP/gi,
+          'current_timestamp',
+        );
+      }
+      parts.push(`DEFAULT ${defaultValue}`);
+    }
+
+    return parts.join(' ');
+  });
+
+  sql += columnDefs.join(',\n');
+  sql += '\n);';
+
+  return sql;
+}
+
+/**
+ * Parse command line arguments and run migration
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Migration Script for Issue #198: DuckDB DATETIME Compatibility
+
+Usage:
+  npx tsx scripts/migrate-datetime-to-timestamp.ts [options] <database-path>
+
+Options:
+  --dry-run         Show what would be migrated without making changes
+  --no-backup       Skip creating a backup file (not recommended)
+  -h, --help        Show this help message
+
+Examples:
+  # Migrate database with backup
+  npx tsx scripts/migrate-datetime-to-timestamp.ts ./data/my-database.db
+
+  # Preview migration without making changes
+  npx tsx scripts/migrate-datetime-to-timestamp.ts --dry-run ./data/my-database.db
+
+  # Migrate without backup (dangerous!)
+  npx tsx scripts/migrate-datetime-to-timestamp.ts --no-backup ./data/my-database.db
+    `);
+    process.exit(0);
+  }
+
+  // Parse options
+  const dryRun = args.includes('--dry-run');
+  const noBackup = args.includes('--no-backup');
+  const databasePath = resolve(args.find((arg) => !arg.startsWith('--')) || '');
+
+  if (!databasePath) {
+    console.error('❌ Error: Database path is required');
+    process.exit(1);
+  }
+
+  try {
+    await migrate({
+      databasePath,
+      dryRun,
+      backup: !noBackup,
+    });
+    process.exit(0);
+  } catch (error) {
+    console.error(`\n❌ Migration failed:`, error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { migrate, type MigrationOptions };

package/dist/scripts/prepack.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+/**
+ * Core prepack entrypoint.
+ *
+ * In CI the release workflow already performs a clean repo-wide build before
+ * `changeset publish`. Rebuilding core inside `prepack` empties `dist/` again,
+ * which can make sibling package publishes observe a half-missing shared core
+ * build. Reuse the existing artifacts in CI when they are present, but still
+ * recover by rebuilding if a CI job reaches `prepack` before core has been
+ * built.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+function run(script) {
+  execFileSync('npm', ['run', script], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+}
+
+function hasReusableBuildArtifacts() {
+  return [
+    'dist/index.js',
+    'dist/vite-plugin.js',
+    'dist/scanner.js',
+    'dist/consumer-plugin.js',
+  ].every((relativePath) => existsSync(resolve(relativePath)));
+}
+
+const runningInCi = process.env.CI === 'true' || process.env.CI === '1';
+
+if (runningInCi && hasReusableBuildArtifacts()) {
+  console.log(
+    '[smrt-core prepack] Reusing existing CI build artifacts to avoid deleting shared dist/ during publish.',
+  );
+  run('verify:exports');
+  run('verify:consumer-plugin');
+} else {
+  if (runningInCi) {
+    console.log(
+      '[smrt-core prepack] CI build artifacts are incomplete; running build:fresh so packaging can recover.',
+    );
+  }
+  run('build:fresh');
+}

package/dist/signals/bus.d.ts

@@ -0,0 +1,64 @@
+import { Signal, SignalAdapter } from '@happyvertical/smrt-types';
+import { SanitizationConfig } from './sanitizer.js';
+/**
+ * Central signal distribution bus
+ *
+ * SignalBus manages adapter registration and signal distribution
+ * with fire-and-forget error handling.
+ */
+export declare class SignalBus {
+    private adapters;
+    private sanitizer?;
+    /**
+     * Create a new SignalBus
+     *
+     * @param options - Configuration options
+     */
+    constructor(options?: {
+        sanitization?: SanitizationConfig | false;
+    });
+    /**
+     * Register a signal adapter
+     *
+     * @param adapter - Adapter to register
+     */
+    register(adapter: SignalAdapter): void;
+    /**
+     * Unregister a signal adapter
+     *
+     * Removes the adapter from the bus to prevent memory leaks.
+     *
+     * @param adapter - Adapter to unregister
+     * @returns True if adapter was found and removed
+     */
+    unregister(adapter: SignalAdapter): boolean;
+    /**
+     * Clear all registered adapters
+     *
+     * Removes all adapters from the bus. Useful for cleanup or testing.
+     */
+    clear(): void;
+    /**
+     * Emit a signal to all registered adapters
+     *
+     * Signals are sanitized (if configured) before being passed to adapters.
+     * Adapters are called in fire-and-forget mode - errors are logged
+     * but don't interrupt the main execution flow.
+     *
+     * @param signal - Signal to emit
+     */
+    emit(signal: Signal): Promise<void>;
+    /**
+     * Generate unique execution ID for method invocations
+     *
+     * @returns Unique execution ID (CUID2)
+     */
+    generateExecutionId(): string;
+    /**
+     * Get count of registered adapters
+     *
+     * @returns Number of registered adapters
+     */
+    get adapterCount(): number;
+}
+//# sourceMappingURL=bus.d.ts.map

package/dist/signals/bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus.d.ts","sourceRoot":"","sources":["../../src/signals/bus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAEvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAKzD;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,SAAS,CAAC,CAAkB;IAEpC;;;;OAIG;gBACS,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,kBAAkB,GAAG,KAAK,CAAA;KAAE;IAMnE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAItC;;;;;;;OAOG;IACH,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAS3C;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;OAQG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCzC;;;;OAIG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;;;OAIG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;CACF"}