@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js

@@ -0,0 +1,30 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+const DEFAULT_UPLOAD_EXPIRY = 2 * 60 * 60; // 2 hours
+const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
+/**
+ * Generate a presigned URL for uploading a file to S3.
+ * The client can PUT directly to this URL without AWS credentials.
+ */
+export function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
+    const s3Client = new S3Client({});
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+        ContentType: contentType,
+    });
+    return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}
+/**
+ * Generate a presigned URL for downloading a file from S3.
+ * Anyone with this URL can GET the file without AWS credentials.
+ */
+export function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
+    const s3Client = new S3Client({});
+    const command = new GetObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+    });
+    return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}
+//# sourceMappingURL=getPresignedUrl.js.map

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}

package/analyzer-template/packages/aws/package.json

@@ -11,14 +11,15 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws-sdk/client-codebuild": "^3.940.0",
+    "@aws-sdk/client-codebuild": "^3.948.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
-    "@aws-sdk/client-dynamodb": "^3.899.0",
-    "@aws-sdk/client-ecr": "^3.946.0",
-    "@aws-sdk/client-ecs": "^3.937.0",
-    "@aws-sdk/client-s3": "^3.899.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
-    "@aws-sdk/lib-storage": "^3.899.0",
+    "@aws-sdk/client-dynamodb": "^3.956.0",
+    "@aws-sdk/client-ecr": "^3.948.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
+    "@aws-sdk/client-s3": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.0",
+    "@aws-sdk/lib-storage": "^3.940.0",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.902.0"
   }
 }

package/analyzer-template/packages/aws/s3/index.ts

@@ -1,2 +1,6 @@
 // Direct export for s3 functions only
 export { default as s3UploadFile } from '../src/lib/s3/uploadFileToS3';
+export {
+  getPresignedUploadUrl,
+  getPresignedDownloadUrl,
+} from '../src/lib/s3/getPresignedUrl';

package/analyzer-template/packages/aws/src/lib/s3/getPresignedUrl.ts

@@ -0,0 +1,62 @@
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+interface GetPresignedUploadUrlArgs {
+  bucketName: string;
+  key: string;
+  contentType?: string;
+  expiresInSeconds?: number;
+}
+
+interface GetPresignedDownloadUrlArgs {
+  bucketName: string;
+  key: string;
+  expiresInSeconds?: number;
+}
+
+const DEFAULT_UPLOAD_EXPIRY = 2 * 60 * 60; // 2 hours
+const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
+
+/**
+ * Generate a presigned URL for uploading a file to S3.
+ * The client can PUT directly to this URL without AWS credentials.
+ */
+export function getPresignedUploadUrl({
+  bucketName,
+  key,
+  contentType = 'application/gzip',
+  expiresInSeconds = DEFAULT_UPLOAD_EXPIRY,
+}: GetPresignedUploadUrlArgs): Promise<string> {
+  const s3Client = new S3Client({});
+
+  const command = new PutObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+    ContentType: contentType,
+  });
+
+  return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}
+
+/**
+ * Generate a presigned URL for downloading a file from S3.
+ * Anyone with this URL can GET the file without AWS credentials.
+ */
+export function getPresignedDownloadUrl({
+  bucketName,
+  key,
+  expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY,
+}: GetPresignedDownloadUrlArgs): Promise<string> {
+  const s3Client = new S3Client({});
+
+  const command = new GetObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}

package/analyzer-template/packages/database/client.ts

@@ -0,0 +1,35 @@
+/**
+ * This index file re-exports modules which are safe to use in a browser
+ * environment with our current set of polyfills. Two considerations:
+ * - It must compile: it can't rely on node modules we don't polyfill
+ * - It must use Supabase for its REST capabilities. None of the db.ts
+ *   infrastructure must be invoked in this file or any of its imports.
+ *
+ *   Kysely itself is fine.
+ */
+
+export { getSupabase, getAdminSupabase } from './src/lib/supabase';
+
+export type { SupabaseClient } from '@supabase/supabase-js';
+export { default as upsertFiles_Client } from './src/lib/client/upsertFiles_Client';
+export { default as loadAnalyses_Client } from './src/lib/client/loadAnalysesInClient';
+export { default as loadBranches_Client } from './src/lib/client/loadBranches_Client';
+export { default as loadAnalysis_Client } from './src/lib/client/loadAnalysis_Client';
+
+export { default as listenForCommits_Client } from './src/lib/client/listenForCommits_Client';
+
+export { default as dbToAnalysis } from './src/lib/dbToAnalysis';
+export { default as dbToBranch } from './src/lib/dbToBranch';
+export { default as dbToCommit } from './src/lib/dbToCommit';
+export { default as dbToEntity } from './src/lib/dbToEntity';
+export { default as dbToFile } from './src/lib/dbToFile';
+export { default as dbToProject } from './src/lib/dbToProject';
+export { default as dbToScenario } from './src/lib/dbToScenario';
+export { default as dbToUserScenario } from './src/lib/dbToUserScenario';
+export { default as dbToScenarioComment } from './src/lib/dbToScenarioComment';
+
+// NOTE: generateSha is NOT exported here because it uses Node's crypto module
+// which is server-only. Import from '~codeyam/database' (server) instead.
+
+// Export ONLY types from tableRelations (no runtime code that imports Kysely)
+export type * from './src/lib/kysely/tableRelationsTypes';

package/analyzer-template/packages/database/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codeyam/supabase",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest --watchAll --verbose"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@supabase/supabase-js": "2.88.0",
+    "better-sqlite3": "^12.4.1",
+    "fetch-retry": "^6.0.0",
+    "kysely": "^0.28.5",
+    "pg": "^8.16.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/jest": "^30.0.0",
+    "@types/pg": "^8.15.5",
+    "@types/ws": "^8.18.1"
+  }
+}

package/analyzer-template/packages/database/src/lib/kysely/db.ts

@@ -0,0 +1,482 @@
+import SQLiteDatabase from 'better-sqlite3';
+import { Pool, PoolClient } from 'pg';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  Kysely,
+  LogEvent,
+  ParseJSONResultsPlugin,
+  PostgresDialect,
+  sql,
+  SqliteDialect,
+} from 'kysely';
+
+import * as sqliteHelper from 'kysely/helpers/sqlite';
+import * as pgHelper from 'kysely/helpers/postgres';
+
+import { SqliteBooleanPlugin } from './sqliteBooleanPlugin';
+
+import { createProjectsTable, ProjectsTable } from './tables/projectsTable';
+import { AnalysesTable, createAnalysesTable } from './tables/analysesTable';
+import {
+  AnalysisBranchesTable,
+  createAnalysisBranchesTable,
+} from './tables/analysisBranchesTable';
+import {
+  BackgroundJobsTable,
+  createBackgroundJobsTable,
+} from './tables/backgroundJobsTable';
+import { BranchesTable, createBranchesTable } from './tables/branchesTable';
+import {
+  CommitBranchesTable,
+  createCommitBranchesTable,
+} from './tables/commitBranchesTable';
+import { CommitsTable, createCommitsTable } from './tables/commitsTable';
+import {
+  createDebugReportsTable,
+  DebugReportsTable,
+} from './tables/debugReportsTable';
+import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
+import {
+  createEntityBranchesTable,
+  EntityBranchesTable,
+} from './tables/entityBranchesTable';
+import {
+  createEntityStatementsTable,
+  EntityStatementsTable,
+} from './tables/entityStatementsTable';
+import { createFilesTable, FilesTable } from './tables/filesTable';
+import {
+  createGithubPayloadsTable,
+  GithubPayloadsTable,
+} from './tables/githubPayloadsTable';
+import {
+  createGithubUsersTable,
+  GithubUsersTable,
+} from './tables/githubUsersTable';
+import {
+  createScenarioCommentsTable,
+  ScenarioCommentsTable,
+} from './tables/scenarioCommentsTable';
+import { createScenariosTable, ScenariosTable } from './tables/scenariosTable';
+import {
+  createStatementsTable,
+  StatementsTable,
+} from './tables/statementsTable';
+import { createTeamsTable, TeamsTable } from './tables/teamsTable';
+import {
+  createUserScenariosTable,
+  UserScenariosTable,
+} from './tables/userScenariosTable';
+import { createUserTeamsTable, UserTeamsTable } from './tables/userTeamsTable';
+import { createUsersTable, UsersTable } from './tables/usersTable';
+
+import { schemaField } from './schemaHelpers';
+
+// import { loadEnv } from '~codeyam/utils/server';
+
+// loadEnv(); // Commented out - causing Vite SSR issues, and it's just a placeholder anyway
+
+const ENABLE_QUERY_LOGGING = !!getEnvVar('ENABLE_QUERY_LOGGING');
+const ENABLE_QUERY_ERROR_LOGGING = !!getEnvVar('ENABLE_QUERY_ERROR_LOGGING');
+
+// PostgreSQL testing mode:
+// - uses a dedicated 'codeyam_tests' schema
+//   - run scripts/create-local-psql-test-schema.sh to set that up
+// - requires jest to be invoked with --runInBand, to avoid tests clobbering
+//   each other's data – it's a single shared database
+const USE_LOCAL_POSTGRESQL_FOR_TESTING =
+  getEnvVar('USE_LOCAL_POSTGRESQL_FOR_TESTING') === 'true';
+
+const CODEYAM_TESTS_SCHEMA_NAME = 'codeyam_tests';
+
+// define the Kysely database as an object instance so we can enumerate
+// our tables in runtime, while still creating the Database type for Kysely
+// using type inference flow (below).
+const databaseSchema = {
+  projects: schemaField<ProjectsTable>(),
+  analyses: schemaField<AnalysesTable>(),
+  analysis_branches: schemaField<AnalysisBranchesTable>(),
+  background_jobs: schemaField<BackgroundJobsTable>(),
+  branches: schemaField<BranchesTable>(),
+  commit_branches: schemaField<CommitBranchesTable>(),
+  commits: schemaField<CommitsTable>(),
+  debug_reports: schemaField<DebugReportsTable>(),
+  entities: schemaField<EntitiesTable>(),
+  entity_branches: schemaField<EntityBranchesTable>(),
+  entity_statements: schemaField<EntityStatementsTable>(),
+  files: schemaField<FilesTable>(),
+  github_payloads: schemaField<GithubPayloadsTable>(),
+  github_users: schemaField<GithubUsersTable>(),
+  scenario_comments: schemaField<ScenarioCommentsTable>(),
+  scenarios: schemaField<ScenariosTable>(),
+  statements: schemaField<StatementsTable>(),
+  teams: schemaField<TeamsTable>(),
+  user_scenarios: schemaField<UserScenariosTable>(),
+  user_teams: schemaField<UserTeamsTable>(),
+  users: schemaField<UsersTable>(),
+} as const;
+
+// This is the core Database type used by Kysely everywhere
+export type Database = {
+  [K in keyof typeof databaseSchema]: (typeof databaseSchema)[K];
+};
+
+// Get columns at runtime
+export const databaseTableNames = Object.keys(
+  databaseSchema,
+) as (keyof Database)[];
+
+let db: Kysely<Database> | undefined;
+
+export function getDatabase(): Kysely<Database> {
+  if (!db) {
+    const dbType = determineDatabaseType();
+
+    if (dbType === 'sqlite') {
+      db = getSqliteDatabase();
+    } else if (dbType === 'postgresql') {
+      db = getPostgreDatabase();
+    } else {
+      throw new Error(`Unknown database type: ${dbType}`);
+    }
+  }
+  return db;
+}
+
+/**
+ * Sets the SQLite database path and resets the database singleton.
+ * Useful for testing/benchmarking scenarios where you need to switch databases.
+ */
+export async function setSqlitePath(path: string): Promise<void> {
+  if (db) {
+    await db.destroy();
+    db = undefined;
+  }
+  process.env.SQLITE_PATH = path;
+}
+
+/**
+ * Closes the current database connection and resets the singleton.
+ * Useful for cleanup in testing/benchmarking scenarios.
+ */
+export async function closeDatabase(): Promise<void> {
+  if (db) {
+    await db.destroy();
+    db = undefined;
+  }
+}
+
+let warnedAboutTestDb = false;
+
+export function getSqliteDatabase(sqlitePath?: string) {
+  if (!sqlitePath) {
+    sqlitePath = getEnvVar('SQLITE_PATH');
+  }
+  if (sqlitePath === ':memory:' || sqlitePath === 'memory') {
+    throw new Error(
+      'In-memory SQLite not supported in getDatabase(). Use getDatabaseForTesting() instead.',
+    );
+  }
+
+  const dbFileExistsBeforeOpen = fs.existsSync(sqlitePath);
+
+  // Ensure the parent directory exists and has proper permissions
+  // This prevents SQLITE_READONLY_DBMOVED errors when creating new databases
+  const dbDir = path.dirname(sqlitePath);
+
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true, mode: 0o755 });
+  } else {
+    // Ensure directory is writable (needed for SQLite journal files)
+    try {
+      fs.chmodSync(dbDir, 0o755);
+    } catch (error) {
+      console.warn(
+        `Warning: Could not set permissions on database directory: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  // Explicitly open database in readwrite mode to prevent "attempt to write a readonly database" errors
+  // This can happen when copying databases between directories or when file permissions are ambiguous
+  const sqlite = new SQLiteDatabase(sqlitePath, {
+    readonly: false,
+    fileMustExist: false,
+  });
+  sqlite.pragma('journal_mode = WAL');
+  sqlite.pragma('synchronous = FULL');
+
+  // Verify the database has the expected schema
+  // If fileMustExist=false and the file didn't exist or was corrupted, SQLite creates a new empty database
+  if (!process.env.CLAUDE_CODE_MODE) {
+    try {
+      const tableCheck = sqlite
+        .prepare(
+          "SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name='projects'",
+        )
+        .get() as { count: number };
+
+      if (dbFileExistsBeforeOpen && tableCheck.count === 0) {
+        console.error(
+          'CodeYam DB ERROR: Database file existed but projects table is missing!',
+        );
+        console.error(
+          'This likely means SQLite created a new empty database instead of opening the existing one.',
+        );
+        console.error(
+          'Possible causes: corruption, WAL file issues, or file locking problems.',
+        );
+      }
+    } catch (error) {
+      console.error(
+        'CodeYam DB ERROR: Failed to verify database schema:',
+        error,
+      );
+    }
+  }
+  return new Kysely<Database>({
+    dialect: new SqliteDialect({ database: sqlite }),
+    plugins: [new ParseJSONResultsPlugin(), new SqliteBooleanPlugin()],
+    log: onQueryLogEvent,
+  });
+}
+
+export function getPostgreDatabase() {
+  const connectionString = getPostgresConnectionString();
+  console.log(`CodeYam: Using PostgreSQL database at: ${connectionString}`);
+  const pool = new Pool({ connectionString });
+  pool.on('error', (err: Error, _client: PoolClient) => {
+    console.error('CodeYam: Unexpected error on idle PostgreSQL client', err);
+  });
+  return new Kysely<Database>({
+    dialect: new PostgresDialect({ pool }),
+    log: onQueryLogEvent,
+  });
+}
+// Async database creation for testing only
+export async function getDatabaseForTesting(
+  dbPath = ':memory:',
+): Promise<Kysely<Database>> {
+  if (USE_LOCAL_POSTGRESQL_FOR_TESTING) {
+    if (!warnedAboutTestDb) {
+      console.log(
+        `ℹ️  Using PostgreSQL for tests (schema: ${CODEYAM_TESTS_SCHEMA_NAME})`,
+      );
+      warnedAboutTestDb = true;
+    }
+
+    const connectionString = getPostgresConnectionString();
+    validateLocalhostOnly(connectionString);
+
+    const pool = new Pool({
+      connectionString,
+      max: 1, // Single connection for tests
+      // Set search_path to use test schema
+      options: `-c search_path=${CODEYAM_TESTS_SCHEMA_NAME}`,
+    });
+    pool.on('error', (err: Error, _client: PoolClient) => {
+      console.error(
+        'CodeYam: Unexpected error on idle PostgreSQL client in test pool',
+        err,
+      );
+    });
+    const kyselyDb = new Kysely<Database>({
+      dialect: new PostgresDialect({ pool }),
+      plugins: [new ParseJSONResultsPlugin()], // No SQLite boolean plugin for PostgreSQL
+      log: onQueryLogEvent,
+    });
+
+    await clearPostgreSQLData(kyselyDb);
+    return kyselyDb;
+  } else {
+    // Standard SQLite testing path
+    const sqlite = new SQLiteDatabase(dbPath);
+    sqlite.pragma('journal_mode = WAL');
+    sqlite.pragma('synchronous = FULL');
+    const kyselyDb = new Kysely<Database>({
+      dialect: new SqliteDialect({ database: sqlite }),
+      plugins: [new ParseJSONResultsPlugin(), new SqliteBooleanPlugin()],
+      log: onQueryLogEvent,
+    });
+
+    await createSqliteSchema(kyselyDb);
+    return kyselyDb;
+  }
+}
+
+let jsonHelper: ReturnType<typeof createJsonHelper> | null = null;
+
+export function getJsonHelper() {
+  if (!jsonHelper) {
+    jsonHelper = createJsonHelper(determineDatabaseType());
+  }
+  return jsonHelper;
+}
+
+export function getJsonHelperForTesting() {
+  return createJsonHelper(
+    USE_LOCAL_POSTGRESQL_FOR_TESTING ? 'postgresql' : 'sqlite',
+  );
+}
+
+function onQueryLogEvent(event: LogEvent) {
+  if (event.level === 'error') {
+    if (ENABLE_QUERY_ERROR_LOGGING) {
+      console.error('Query failed : ', {
+        durationMs: event.queryDurationMillis,
+        error: event.error,
+        sql: event.query.sql,
+        params: event.query.parameters,
+      });
+    }
+  } else if (ENABLE_QUERY_LOGGING) {
+    // `'query'`
+    console.log('Query executed : ', {
+      durationMs: event.queryDurationMillis,
+      sql: event.query.sql,
+      params: event.query.parameters,
+    });
+  }
+}
+
+function createJsonHelper(dbType: 'postgresql' | 'sqlite') {
+  if (dbType === 'sqlite') {
+    return sqliteHelper;
+  } else if (dbType === 'postgresql') {
+    return pgHelper;
+  } else {
+    throw new Error(`Unknown database type: ${dbType}`);
+  }
+}
+
+function determineDatabaseType(): 'postgresql' | 'sqlite' {
+  const sqlitePath = getEnvVar('SQLITE_PATH');
+  if (sqlitePath) {
+    return 'sqlite';
+  }
+
+  // Check for PostgreSQL connection strings
+  const postgresUrl = getEnvVar('POSTGRESQL_URL');
+  if (postgresUrl) {
+    return 'postgresql';
+  }
+
+  throw new Error(
+    'No database configuration found. Set SQLITE_PATH for SQLite or POSTGRESQL_URL for PostgreSQL',
+  );
+}
+
+export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
+  // Create all tables needed for testing
+  // TODO: If this takes non-trivial time, we can maybe do it concurrently?
+  await createProjectsTable(db);
+  await createAnalysesTable(db);
+  await createAnalysisBranchesTable(db);
+  await createBackgroundJobsTable(db);
+  await createBranchesTable(db);
+  await createCommitBranchesTable(db);
+  await createCommitsTable(db);
+  await createDebugReportsTable(db);
+  await createEntitiesTable(db);
+  await createEntityBranchesTable(db);
+  await createEntityStatementsTable(db);
+  await createFilesTable(db);
+  await createGithubPayloadsTable(db);
+  await createGithubUsersTable(db);
+  await createScenarioCommentsTable(db);
+  await createScenariosTable(db);
+  await createStatementsTable(db);
+  await createTeamsTable(db);
+  await createUserScenariosTable(db);
+  await createUserTeamsTable(db);
+  await createUsersTable(db);
+}
+
+let warnedAboutClear = false;
+
+// Clears all data from the test schema (codeyam_tests) tables
+// Tables must already exist (created by scripts/create-local-psql-test-schema.sh)
+async function clearPostgreSQLData(db: Kysely<Database>): Promise<void> {
+  if (!warnedAboutClear) {
+    console.log(`🗑️  Clearing test schema (${CODEYAM_TESTS_SCHEMA_NAME})...`);
+  }
+
+  // Delete in reverse dependency order (child tables first)
+  // Using the dynamically generated table names from schema
+  const tablesToClear = [...databaseTableNames].reverse();
+
+  // For testing, we can use TRUNCATE for better performance and to reset sequences
+  // But fallback to DELETE if TRUNCATE fails due to foreign key constraints
+  for (const tableName of tablesToClear) {
+    try {
+      // Try TRUNCATE first for better performance
+      await sql`TRUNCATE TABLE ${sql.ref(tableName)} CASCADE`.execute(db);
+    } catch (error) {
+      console.warn(
+        `TRUNCATE failed for ${tableName}, falling back to DELETE:`,
+        error,
+      );
+      try {
+        // Fallback to DELETE FROM if TRUNCATE fails
+        await db.deleteFrom(tableName as any).execute();
+      } catch (deleteError) {
+        console.error(`Failed to clear table ${tableName}:`, deleteError);
+        // Continue with other tables - don't fail the entire test setup
+      }
+    }
+  }
+
+  if (!warnedAboutClear) {
+    console.log('✅ Test schema cleared.');
+    warnedAboutClear = true;
+  }
+}
+
+// Safety check to ensure we're only wiping localhost databases
+function validateLocalhostOnly(connectionString: string): void {
+  try {
+    const url = new URL(connectionString.replace('postgresql://', 'http://'));
+    const allowedHosts = ['localhost', '127.0.0.1', '::1'];
+
+    if (!allowedHosts.some((host) => url.hostname.includes(host))) {
+      throw new Error(
+        `🚨 SAFETY ERROR: PostgreSQL testing is only allowed on localhost!\n` +
+          `Current host: ${url.hostname}\n` +
+          `Set USE_LOCAL_POSTGRESQL_FOR_TESTING=false to disable PostgreSQL testing.\n` +
+          `If you need to test against a remote database, please review the safety implications.`,
+      );
+    }
+
+    // console.warn(`🔒 Validated localhost connection: ${url.hostname}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('SAFETY ERROR')) {
+      throw error; // Re-throw our safety errors
+    }
+
+    // If URL parsing fails, be extra cautious and block
+    throw new Error(
+      `🚨 SAFETY ERROR: Could not validate connection string format.\n` +
+        `For safety, PostgreSQL testing is blocked.\n` +
+        `Connection string: ${connectionString}\n` +
+        `Error: ${error}`,
+    );
+  }
+}
+
+function getPostgresConnectionString(): string {
+  // Check for direct PostgreSQL connection strings first
+  const postgresUrl = getEnvVar('POSTGRESQL_URL');
+  if (!postgresUrl) {
+    throw new Error(
+      'No PostgreSQL connection string found. Set POSTGRESQL_URL environment variable.',
+    );
+  }
+  return postgresUrl;
+}
+
+function getEnvVar(key: string): string | undefined {
+  return typeof window !== 'undefined'
+    ? (window as any).env?.[key]
+    : process.env[key];
+}