aiex-cli 0.1.0 → 0.1.1-beta.2

package/dist/{generate-drizzle-schema-BqSy0OMm.mjs → generate-drizzle-schema-sZ01QiYJ.mjs}

@@ -11,7 +11,7 @@ import { z } from "zod";
 
 //#region package.json
 var name = "aiex-cli";
-var version = "0.1.0";
+var version = "0.1.1-beta.2";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -405,9 +405,60 @@ function getColumnChecks(prop, colName) {
 			value: prop.maximum
 		});
 	}
+	if (prop.enum?.length) checks.push({
+		name: `${colName}_enum`,
+		column: colName,
+		kind: "enum_value",
+		value: prop.enum
+	});
 	return checks;
 }
-function parseObjectToTable(schema, _warnings) {
+function warnNonDrizzleBackedProperty(warnings, schemaPath, property) {
+	if (property.pattern) warnings.push(`${schemaPath}.pattern is kept for extraction guidance but is not emitted as a SQLite constraint because SQLite has no portable REGEXP support.`);
+	if (property.drizzle?.customType) warnings.push(`${schemaPath}.drizzle.customType is declared but not emitted. AIEX currently supports stable built-in Drizzle SQLite column types only.`);
+}
+function describeColumnType(columnType) {
+	switch (columnType.class) {
+		case "text": return {
+			drizzleType: columnType.mode === "json" ? `text({ mode: 'json' })` : "text()",
+			sqliteType: "text"
+		};
+		case "integer": return {
+			drizzleType: columnType.mode ? `integer({ mode: '${columnType.mode}' })` : "integer()",
+			sqliteType: "integer"
+		};
+		case "real": return {
+			drizzleType: "real()",
+			sqliteType: "real"
+		};
+	}
+}
+function columnNotes(property, column) {
+	const notes = [];
+	if (property.type === "object" || property.type === "array") notes.push("stored_as_json");
+	if (property.format === "date-time") notes.push("date_time_as_timestamp");
+	if (property.drizzle?.mode) notes.push(`drizzle_mode:${property.drizzle.mode}`);
+	if (property.foreignKey) notes.push(`foreign_key:${property.foreignKey.table}.${property.foreignKey.column}`);
+	if (column.default !== void 0) notes.push("default");
+	return notes;
+}
+function mapColumnToReport(schemaPath, table, property, column, relation) {
+	const columnType = describeColumnType(column.columnType);
+	return {
+		schemaPath,
+		table,
+		column: column.name,
+		drizzleType: columnType.drizzleType,
+		sqliteType: columnType.sqliteType,
+		nullable: column.isNullable,
+		primary: column.isPrimary,
+		unique: column.isUnique,
+		relation,
+		constraints: property.enum?.length ? { enumValues: property.enum } : void 0,
+		notes: columnNotes(property, column)
+	};
+}
+function parseObjectToTable(schema, warnings, mapping) {
 	const tableName = schema.table.name;
 	const columns = [];
 	const checks = [];
@@ -426,6 +477,8 @@ function parseObjectToTable(schema, _warnings) {
 		const column = mapPropertyToColumn(propName, prop, requiredFields.has(propName));
 		columns.push(column);
 		checks.push(...getColumnChecks(prop, column.name));
+		warnNonDrizzleBackedProperty(warnings, `$.properties.${propName}`, prop);
+		mapping.push(mapColumnToReport(`$.properties.${propName}`, tableName, prop, column, "root"));
 	}
 	if (schema.table.timestamps) {
 		const tsCol = {
@@ -444,18 +497,36 @@ function parseObjectToTable(schema, _warnings) {
 			...tsCol,
 			name: "updated_at"
 		});
+		mapping.push(mapColumnToReport("$.table.timestamps.createdAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, tsCol, "root"));
+		mapping.push(mapColumnToReport("$.table.timestamps.updatedAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, {
+			...tsCol,
+			name: "updated_at"
+		}, "root"));
+	}
+	if (schema.table.softDelete) {
+		const deletedAt = {
+			name: "deleted_at",
+			columnType: {
+				class: "integer",
+				mode: "timestamp"
+			},
+			isPrimary: false,
+			isAutoIncrement: false,
+			isNullable: true,
+			isUnique: false
+		};
+		columns.push(deletedAt);
+		mapping.push(mapColumnToReport("$.table.softDelete.deletedAt", tableName, {
+			type: "integer",
+			drizzle: { mode: "timestamp" }
+		}, deletedAt, "root"));
 	}
-	if (schema.table.softDelete) columns.push({
-		name: "deleted_at",
-		columnType: {
-			class: "integer",
-			mode: "timestamp"
-		},
-		isPrimary: false,
-		isAutoIncrement: false,
-		isNullable: true,
-		isUnique: false
-	});
 	return checks.length > 0 ? {
 		name: tableName,
 		columns,
@@ -465,7 +536,7 @@ function parseObjectToTable(schema, _warnings) {
 		columns
 	};
 }
-function parseNestedObject(propName, property, parentTableName, warnings) {
+function parseNestedObject(propName, property, parentTableName, warnings, mapping) {
 	const nestedTableName = `${parentTableName}_${toSnakeCase(propName)}`;
 	const columns = [];
 	const checks = [];
@@ -478,6 +549,18 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 		isNullable: false,
 		isUnique: false
 	});
+	mapping.push({
+		schemaPath: `$.properties.${propName}.id`,
+		table: nestedTableName,
+		column: "id",
+		drizzleType: "integer().primaryKey({ autoIncrement: true })",
+		sqliteType: "integer",
+		nullable: false,
+		primary: true,
+		unique: false,
+		relation: relationType,
+		notes: ["generated_nested_primary_key"]
+	});
 	columns.push({
 		name: `${parentTableName}_id`,
 		columnType: { class: "integer" },
@@ -491,6 +574,18 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 			column: "id"
 		}
 	});
+	mapping.push({
+		schemaPath: `$.properties.${propName}.${parentTableName}Id`,
+		table: nestedTableName,
+		column: `${parentTableName}_id`,
+		drizzleType: "integer().references(...)",
+		sqliteType: "integer",
+		nullable: false,
+		primary: false,
+		unique: false,
+		relation: relationType,
+		notes: [`generated_parent_foreign_key:${parentTableName}.id`]
+	});
 	if (property.type === "object" && property.properties) for (const [childName, childProp] of Object.entries(property.properties)) {
 		if (childProp.nested?.enabled) {
 			warnings.push(`Nested property "${childName}" inside "${nestedTableName}" is skipped — only one level of nesting is supported. Remove nested.enabled or use drizzle.mode: 'json' instead.`);
@@ -499,6 +594,8 @@ function parseNestedObject(propName, property, parentTableName, warnings) {
 		const column = mapPropertyToColumn(childName, childProp, false);
 		columns.push(column);
 		checks.push(...getColumnChecks(childProp, column.name));
+		warnNonDrizzleBackedProperty(warnings, `$.properties.${propName}.properties.${childName}`, childProp);
+		mapping.push(mapColumnToReport(`$.properties.${propName}.properties.${childName}`, nestedTableName, childProp, column, relationType));
 	}
 	const relation = {
 		fromTable: nestedTableName,
@@ -531,15 +628,16 @@ function parseJsonSchema(schema) {
 	const relations = [];
 	const reverseRelations = [];
 	const warnings = [];
-	const mainTable = parseObjectToTable(schema, warnings);
+	const mapping = [];
+	const mainTable = parseObjectToTable(schema, warnings, mapping);
 	tables.push(mainTable);
 	for (const [propName, prop] of Object.entries(schema.properties)) if (prop.type === "object" && prop.nested?.enabled) {
-		const nested = parseNestedObject(propName, prop, mainTable.name, warnings);
+		const nested = parseNestedObject(propName, prop, mainTable.name, warnings, mapping);
 		tables.push(nested.table);
 		relations.push(nested.relation);
 		reverseRelations.push(nested.reverseRelation);
 	} else if (prop.type === "array" && prop.items?.nested?.enabled && prop.items?.type === "object" && prop.items.properties) {
-		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings);
+		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings, mapping);
 		tables.push(nested.table);
 		relations.push(nested.relation);
 		reverseRelations.push(nested.reverseRelation);
@@ -548,7 +646,8 @@ function parseJsonSchema(schema) {
 		tables,
 		relations,
 		reverseRelations,
-		warnings
+		warnings,
+		mapping
 	};
 }
 
@@ -810,7 +909,8 @@ const en = {
 			description: "Sync JSON Schema to SQLite database",
 			args: {
 				generate: "Only generate Drizzle schema, skip migrate",
-				name: "Name for the migration"
+				name: "Name for the migration",
+				force: "Allow high-risk schema migrations"
 			},
 			noSchemas: "No schema files found in {{path}}",
 			runWebHint: "Run {{cmd}} to create and configure schemas in the Web UI",
@@ -825,7 +925,9 @@ const en = {
 			databaseMigrated: "Database migrated",
 			migrationsApplied: "Migrations applied",
 			migrationFail: "Migration failed",
-			runWithoutGenerate: "Done! Run without --generate to apply migrations"
+			runWithoutGenerate: "Done! Run without --generate to apply migrations",
+			riskSummary: "Migration risk: {{level}} ({{count}} item(s))",
+			highRiskBlocked: "High-risk schema migration blocked. Review .aiex/drizzle/schema-map.json and rerun with {{flag}} to continue."
 		},
 		extract: {
 			description: "Extract structured data from text, images, or PDFs",
@@ -862,30 +964,6 @@ const en = {
 				fileRequiredSingle: "Please provide a file (-f) to extract from",
 				noSchemas: "No schema files found in {{path}}. Run {{cmd}} to create and configure schemas first."
 			},
-			history: {
-				description: "List extraction audit records",
-				empty: "No extraction history found",
-				errors: {
-					idRequired: "Audit record id is required",
-					recordNotFound: "Extraction record not found: {{id}}"
-				},
-				deleted: "Deleted extraction record: {{id}}"
-			},
-			show: {
-				description: "Show an extraction audit record",
-				args: { id: "Audit record id" }
-			},
-			retry: {
-				description: "Retry an extraction audit record",
-				args: {
-					id: "Audit record id",
-					noInsert: "Extract and save JSON without inserting into SQLite"
-				}
-			},
-			rm: {
-				description: "Delete an extraction audit record and cached upload",
-				args: { id: "Audit record id" }
-			},
 			batch: {
 				scanning: "Scanning {{dir}} for supported files...",
 				found: "Found {{count}} file(s) to process",
@@ -932,6 +1010,14 @@ const en = {
 				model: "AI model to use for extraction (overrides default/auto-selected model)",
 				noInsert: "Extract and save JSON without inserting into SQLite database"
 			},
+			interactive: {
+				selectSchema: "Select a schema to watch with:",
+				enterDirPath: "Enter directory path to watch:",
+				dirPathRequired: "Please enter a directory path",
+				selectModel: "Select an AI model:",
+				autoModel: "Auto-select model",
+				askNoInsert: "Save extracted JSON without inserting into SQLite?"
+			},
 			errors: {
 				schemaRequired: "Schema name (-s) is required",
 				dirRequired: "Watch directory path (-d) is required",
@@ -963,35 +1049,6 @@ const en = {
 				failTitle: "AIEX Watch Failed: {{file}}"
 			}
 		},
-		dump: {
-			description: "Dump SQLite database table to Excel (.xlsx) or CSV (.csv)",
-			args: {
-				table: "SQLite table name to export",
-				schema: "Schema name (without .json extension) to export",
-				format: "Export format: csv or xlsx (default: inferred from output or csv)",
-				output: "Output file path (default: ./<tableName>.<format>)"
-			},
-			errors: {
-				tableOrSchemaRequired: "Either table name (--table / -t) or schema name (--schema / -s) is required",
-				schemaNotFound: "Schema file for \"{{name}}\" not found",
-				noTableName: "Schema \"{{name}}\" does not define a database table name.",
-				tableMismatch: "Specified table name \"{{table}}\" does not match schema table name \"{{schemaTable}}\"",
-				unsupportedFormat: "Unsupported dump format: \"{{format}}\". Supported formats: csv, xlsx",
-				dbNotFound: "Database file not found at {{path}}. Please run \"{{cmd}}\" to create the database first.",
-				tableNotFound: "Table \"{{name}}\" not found in database. Run \"{{cmd}}\" first to migrate.",
-				tableEmpty: "Table \"{{name}}\" is empty. Exporting empty file..."
-			},
-			loading: "Loading data from table \"{{name}}\"...",
-			loaded: "Loaded {{count}} row(s)",
-			emptyTable: "Empty table",
-			formatting: "Formatting data...",
-			formatted: "Data formatted",
-			writing: "Writing {{format}} file to {{path}}...",
-			dumpCompleted: "Dump completed successfully",
-			successMsg: "Successfully dumped {{count}} row(s) to {{path}}",
-			fileWriteFailed: "File write failed",
-			dbQueryFailed: "Database query failed"
-		},
 		doctor: {
 			description: "Print environment and configuration diagnostics",
 			args: { json: "Print diagnostics as JSON" },
@@ -1036,7 +1093,8 @@ const en = {
 			noFiles: "No schema files found",
 			migrationFailed: "Migration failed",
 			migrationHelperInvalidOutput: "Migration helper did not return valid output",
-			migrationHelperFailed: "Migration helper failed"
+			migrationHelperFailed: "Migration helper failed",
+			highRiskMigrationBlocked: "High-risk schema migration blocked"
 		},
 		db: {
 			notFound: "Database not found at {{path}}. Run {{cmd}} first to create the database.",
@@ -1295,7 +1353,7 @@ async function initI18n(lng) {
 			fallbackLng: "en",
 			resources: {
 				"en": { translation: en },
-				"zh-CN": { translation: await import("./zh-CN-B2yrInX9.mjs").then((m) => m.zhCN) }
+				"zh-CN": { translation: await import("./zh-CN-BAGJklRp.mjs").then((m) => m.zhCN) }
 			},
 			interpolation: { escapeValue: false },
 			returnNull: false
@@ -1637,6 +1695,9 @@ function renderColumnType(ct) {
 function renderDefaultValue(value) {
 	return JSON.stringify(value);
 }
+function renderSqlLiteral(value) {
+	return typeof value === "number" ? String(value) : `'${value.replace(/'/g, "''")}'`;
+}
 function generateColumnDefinition(column) {
 	if (column.isPrimary && column.isAutoIncrement) return `  ${column.name}: integer().primaryKey({ autoIncrement: true })`;
 	let def = `  ${column.name}: ${renderColumnType(column.columnType)}`;
@@ -1663,6 +1724,9 @@ function renderCheckToDrizzle(check, tableVar) {
 		case "max_value":
 			expr = `${colRef} <= ${check.value}`;
 			break;
+		case "enum_value":
+			expr = `${colRef} IN (${(Array.isArray(check.value) ? check.value : []).map(renderSqlLiteral).join(", ")})`;
+			break;
 	}
 	return `    ${check.name}: check('${check.name}', sql\`${expr}\`)`;
 }

package/dist/index.d.mts

@@ -305,8 +305,8 @@ type ColumnType = {
 interface CheckConstraint {
   name: string;
   column: string;
-  kind: 'min_length' | 'max_length' | 'min_value' | 'max_value';
-  value: number;
+  kind: 'min_length' | 'max_length' | 'min_value' | 'max_value' | 'enum_value';
+  value: number | (string | number)[];
 }
 interface ParsedColumn {
   name: string;
@@ -322,6 +322,21 @@ interface ParsedColumn {
     column: string;
   };
 }
+interface SchemaMappingEntry {
+  schemaPath: string;
+  table: string;
+  column: string;
+  drizzleType: string;
+  sqliteType: 'text' | 'integer' | 'real';
+  nullable: boolean;
+  primary: boolean;
+  unique: boolean;
+  relation?: 'root' | 'has-one' | 'has-many';
+  constraints?: {
+    enumValues?: (string | number)[];
+  };
+  notes: string[];
+}
 interface ParsedTable {
   name: string;
   columns: ParsedColumn[];
@@ -345,6 +360,7 @@ interface ParseResult {
   relations: ParsedRelation[];
   reverseRelations: ParsedReverseRelation[];
   warnings: string[];
+  mapping?: SchemaMappingEntry[];
 }
 interface MigrationConfig {
   schemaPath: string;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, i as generateDrizzleConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-BqSy0OMm.mjs";
+import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, i as generateDrizzleConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-sZ01QiYJ.mjs";
 
 export { JsonSchemaDefinitionSchema, buildDoctorDiagnostics, collectDoctorDiagnostics, createMigrationConfig, doctorDiagnosticsSeverityRows, doctorDiagnosticsTableRows, formatDoctorDiagnosticsJson, generateDrizzleConfig, generateDrizzleSchema, parseJsonSchema };

package/dist/table-schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://raw.githubusercontent.com/OSpoon/aiex-cli/main/app/cli/schemas/table-schema.json",
   "title": "aiex Table Schema",
-  "description": "Defines a database table and its columns for aiex-cli schema-to-SQLite migration.",
+  "description": "Defines an AIEX Drizzle-backed schema dialect file for schema-to-SQLite migration.",
   "type": "object",
   "required": ["title", "type", "table", "properties"],
   "additionalProperties": false,
@@ -40,6 +40,12 @@
       "items": { "type": "string" },
       "description": "List of property names that are NOT NULL.",
       "default": []
+    },
+    "examples": {
+      "type": "array",
+      "description": "Few-shot examples used by AI extraction prompts.",
+      "items": { "$ref": "#/$defs/examplePair" },
+      "default": []
     }
   },
 
@@ -113,12 +119,17 @@
         },
         "pattern": {
           "type": "string",
-          "description": "Regular expression constraint for string values."
+          "description": "Regular expression guidance for extraction and validation. Not emitted as a SQLite constraint because SQLite has no portable built-in REGEXP support."
         },
         "enum": {
           "type": "array",
-          "items": { "type": "string" },
-          "description": "Enumeration of allowed values for this field."
+          "items": {
+            "oneOf": [
+              { "type": "string" },
+              { "type": "number" }
+            ]
+          },
+          "description": "Enumeration of allowed values for this field. Emitted as a SQLite CHECK constraint."
         },
         "examples": {
           "type": "array",
@@ -132,20 +143,20 @@
         "minLength": {
           "type": "integer",
           "minimum": 0,
-          "description": "Minimum string length (validation only, not a DB constraint)."
+          "description": "Minimum string length. Emitted as a SQLite CHECK constraint."
         },
         "maxLength": {
           "type": "integer",
           "minimum": 1,
-          "description": "Maximum string length (validation only, not a DB constraint)."
+          "description": "Maximum string length. Emitted as a SQLite CHECK constraint."
         },
         "minimum": {
           "type": "number",
-          "description": "Minimum numeric value (validation only, not a DB constraint)."
+          "description": "Minimum numeric value. Emitted as a SQLite CHECK constraint."
         },
         "maximum": {
           "type": "number",
-          "description": "Maximum numeric value (validation only, not a DB constraint)."
+          "description": "Maximum numeric value. Emitted as a SQLite CHECK constraint."
         },
         "drizzle": {
           "$ref": "#/$defs/drizzleConfig",
@@ -198,7 +209,24 @@
         },
         "customType": {
           "type": "string",
-          "description": "Custom Drizzle type name (reserved for future use)."
+          "description": "Custom Drizzle type name. Accepted by the schema shape but not emitted by AIEX; generation reports a warning."
+        }
+      }
+    },
+
+    "examplePair": {
+      "type": "object",
+      "required": ["text", "output"],
+      "additionalProperties": false,
+      "properties": {
+        "text": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Source text example."
+        },
+        "output": {
+          "type": "object",
+          "description": "Expected extracted output for the source text example."
         }
       }
     },