@compilr-dev/factory 0.1.1

package/dist/model/operations.js

@@ -0,0 +1,63 @@
+/**
+ * Operation Dispatcher
+ *
+ * Routes op → handler, manages revision + updatedAt.
+ */
+import { addEntity, updateEntity, removeEntity, renameEntity, reorderEntities, } from './operations-entity.js';
+import { addField, updateField, removeField, renameField, } from './operations-field.js';
+import { addRelationship, removeRelationship, } from './operations-relationship.js';
+import { updateIdentity, updateLayout, updateFeatures, updateTheme, updateTechStack, } from './operations-section.js';
+function dispatchOperation(model, operation) {
+    switch (operation.op) {
+        // Entity operations
+        case 'addEntity':
+            return addEntity(model, operation);
+        case 'updateEntity':
+            return updateEntity(model, operation);
+        case 'removeEntity':
+            return removeEntity(model, operation);
+        case 'renameEntity':
+            return renameEntity(model, operation);
+        case 'reorderEntities':
+            return reorderEntities(model, operation);
+        // Field operations
+        case 'addField':
+            return addField(model, operation);
+        case 'updateField':
+            return updateField(model, operation);
+        case 'removeField':
+            return removeField(model, operation);
+        case 'renameField':
+            return renameField(model, operation);
+        // Relationship operations
+        case 'addRelationship':
+            return addRelationship(model, operation);
+        case 'removeRelationship':
+            return removeRelationship(model, operation);
+        // Section operations
+        case 'updateIdentity':
+            return updateIdentity(model, operation);
+        case 'updateLayout':
+            return updateLayout(model, operation);
+        case 'updateFeatures':
+            return updateFeatures(model, operation);
+        case 'updateTheme':
+            return updateTheme(model, operation);
+        case 'updateTechStack':
+            return updateTechStack(model, operation);
+        default:
+            throw new Error(`Unknown operation: ${operation.op}`);
+    }
+}
+export function applyOperation(model, operation) {
+    const result = dispatchOperation(model, operation);
+    // Increment revision and update timestamp
+    return {
+        ...result,
+        meta: {
+            ...result.meta,
+            revision: result.meta.revision + 1,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+}

package/dist/model/persistence.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Model Store — Persistence Layer
+ *
+ * Reads and writes the ApplicationModel as a project document
+ * with doc_type: 'app-model' via IDocumentRepository.
+ */
+import type { IDocumentRepository } from '@compilr-dev/sdk';
+import type { ApplicationModel } from './types.js';
+export declare class ModelStore {
+    private readonly documents;
+    private readonly projectId;
+    constructor(config: {
+        documents: IDocumentRepository;
+        projectId: number;
+    });
+    get(): Promise<ApplicationModel | null>;
+    save(model: ApplicationModel): Promise<void>;
+    exists(): Promise<boolean>;
+}

package/dist/model/persistence.js

@@ -0,0 +1,40 @@
+/**
+ * Model Store — Persistence Layer
+ *
+ * Reads and writes the ApplicationModel as a project document
+ * with doc_type: 'app-model' via IDocumentRepository.
+ */
+const APP_MODEL_DOC_TYPE = 'app-model';
+const APP_MODEL_TITLE = 'Application Model';
+export class ModelStore {
+    documents;
+    projectId;
+    constructor(config) {
+        this.documents = config.documents;
+        this.projectId = config.projectId;
+    }
+    async get() {
+        const doc = await this.documents.getByType(this.projectId, APP_MODEL_DOC_TYPE);
+        if (!doc)
+            return null;
+        try {
+            return JSON.parse(doc.content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(model) {
+        const content = JSON.stringify(model, null, 2);
+        await this.documents.upsert({
+            project_id: this.projectId,
+            doc_type: APP_MODEL_DOC_TYPE,
+            title: APP_MODEL_TITLE,
+            content,
+        });
+    }
+    async exists() {
+        const doc = await this.documents.getByType(this.projectId, APP_MODEL_DOC_TYPE);
+        return doc !== null;
+    }
+}

package/dist/model/schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Application Model Validation
+ *
+ * Structural validation + business rule validation for referential integrity.
+ */
+import type { ApplicationModel } from './types.js';
+export interface ValidationError {
+    readonly path: string;
+    readonly message: string;
+}
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ValidationError[];
+}
+export declare function validateModel(model: ApplicationModel): ValidationResult;

package/dist/model/schema.js

@@ -0,0 +1,269 @@
+/**
+ * Application Model Validation
+ *
+ * Structural validation + business rule validation for referential integrity.
+ */
+import { isCamelCase, isPascalCase, isValidHexColor } from './naming.js';
+// =============================================================================
+// Structural Validation
+// =============================================================================
+function validateIdentity(model) {
+    const errors = [];
+    const { identity } = model;
+    if (identity.name.trim().length === 0) {
+        errors.push({ path: 'identity.name', message: 'Name is required' });
+    }
+    if (identity.description.trim().length === 0) {
+        errors.push({ path: 'identity.description', message: 'Description is required' });
+    }
+    if (identity.version.trim().length === 0) {
+        errors.push({ path: 'identity.version', message: 'Version is required' });
+    }
+    return errors;
+}
+function validateField(field, entityName, fieldIndex) {
+    const errors = [];
+    const prefix = `entities[${entityName}].fields[${String(fieldIndex)}]`;
+    if (field.name.trim().length === 0) {
+        errors.push({ path: `${prefix}.name`, message: 'Field name is required' });
+    }
+    else if (!isCamelCase(field.name)) {
+        errors.push({
+            path: `${prefix}.name`,
+            message: `Field name "${field.name}" must be camelCase`,
+        });
+    }
+    if (field.label.trim().length === 0) {
+        errors.push({ path: `${prefix}.label`, message: 'Field label is required' });
+    }
+    const validTypes = ['string', 'number', 'boolean', 'date', 'enum'];
+    if (!validTypes.includes(field.type)) {
+        errors.push({ path: `${prefix}.type`, message: `Invalid field type "${field.type}"` });
+    }
+    if (field.type === 'enum') {
+        if (!field.enumValues || field.enumValues.length === 0) {
+            errors.push({
+                path: `${prefix}.enumValues`,
+                message: 'enumValues required for enum type',
+            });
+        }
+    }
+    else if (field.enumValues && field.enumValues.length > 0) {
+        errors.push({
+            path: `${prefix}.enumValues`,
+            message: 'enumValues only allowed for enum type',
+        });
+    }
+    if (field.defaultValue !== undefined) {
+        const valid = validateDefaultValue(field);
+        if (!valid) {
+            errors.push({
+                path: `${prefix}.defaultValue`,
+                message: `Default value type does not match field type "${field.type}"`,
+            });
+        }
+    }
+    return errors;
+}
+function validateDefaultValue(field) {
+    const { type, defaultValue } = field;
+    if (defaultValue === undefined)
+        return true;
+    switch (type) {
+        case 'string':
+        case 'date':
+            return typeof defaultValue === 'string';
+        case 'number':
+            return typeof defaultValue === 'number';
+        case 'boolean':
+            return typeof defaultValue === 'boolean';
+        case 'enum':
+            return (typeof defaultValue === 'string' && (field.enumValues?.includes(defaultValue) ?? false));
+        default:
+            return false;
+    }
+}
+function validateEntity(entity, index, allEntityNames) {
+    const errors = [];
+    const prefix = `entities[${entity.name.length > 0 ? entity.name : String(index)}]`;
+    if (entity.name.trim().length === 0) {
+        errors.push({ path: `${prefix}.name`, message: 'Entity name is required' });
+    }
+    else if (!isPascalCase(entity.name)) {
+        errors.push({
+            path: `${prefix}.name`,
+            message: `Entity name "${entity.name}" must be PascalCase`,
+        });
+    }
+    if (entity.pluralName.trim().length === 0) {
+        errors.push({ path: `${prefix}.pluralName`, message: 'Plural name is required' });
+    }
+    if (entity.icon.trim().length === 0) {
+        errors.push({ path: `${prefix}.icon`, message: 'Icon is required' });
+    }
+    if (entity.fields.length === 0) {
+        errors.push({ path: `${prefix}.fields`, message: 'Entity must have at least one field' });
+    }
+    else {
+        const fieldNames = new Set();
+        entity.fields.forEach((field, fi) => {
+            if (fieldNames.has(field.name)) {
+                errors.push({
+                    path: `${prefix}.fields[${String(fi)}].name`,
+                    message: `Duplicate field name "${field.name}"`,
+                });
+            }
+            fieldNames.add(field.name);
+            errors.push(...validateField(field, entity.name, fi));
+        });
+    }
+    if (entity.views.length === 0) {
+        errors.push({ path: `${prefix}.views`, message: 'Entity must have at least one view' });
+    }
+    else {
+        const validViews = ['card', 'list', 'detail'];
+        for (const view of entity.views) {
+            if (!validViews.includes(view)) {
+                errors.push({ path: `${prefix}.views`, message: `Invalid view "${view}"` });
+            }
+        }
+    }
+    const relKeys = new Set();
+    for (const rel of entity.relationships) {
+        const validTypes = ['belongsTo', 'hasMany'];
+        if (!validTypes.includes(rel.type)) {
+            errors.push({
+                path: `${prefix}.relationships`,
+                message: `Invalid relationship type "${rel.type}"`,
+            });
+        }
+        if (rel.target.trim().length === 0) {
+            errors.push({
+                path: `${prefix}.relationships`,
+                message: 'Relationship target is required',
+            });
+        }
+        else if (!allEntityNames.includes(rel.target)) {
+            errors.push({
+                path: `${prefix}.relationships`,
+                message: `Relationship target "${rel.target}" does not exist`,
+            });
+        }
+        if (rel.target === entity.name) {
+            errors.push({
+                path: `${prefix}.relationships`,
+                message: 'Self-referential relationships are not supported',
+            });
+        }
+        const key = `${rel.type}:${rel.target}`;
+        if (relKeys.has(key)) {
+            errors.push({
+                path: `${prefix}.relationships`,
+                message: `Duplicate relationship ${rel.type} → ${rel.target}`,
+            });
+        }
+        relKeys.add(key);
+    }
+    return errors;
+}
+function validateLayout(model) {
+    const errors = [];
+    const validShells = ['sidebar-header', 'header-only'];
+    if (!validShells.includes(model.layout.shell)) {
+        errors.push({
+            path: 'layout.shell',
+            message: `Invalid shell type "${model.layout.shell}"`,
+        });
+    }
+    return errors;
+}
+function validateFeatures(model) {
+    const errors = [];
+    const featureKeys = [
+        'dashboard',
+        'auth',
+        'userProfiles',
+        'settings',
+        'darkMode',
+    ];
+    for (const key of featureKeys) {
+        if (typeof model.features[key] !== 'boolean') {
+            errors.push({
+                path: `features.${key}`,
+                message: `Feature "${key}" must be a boolean`,
+            });
+        }
+    }
+    return errors;
+}
+function validateTheme(model) {
+    const errors = [];
+    if (!isValidHexColor(model.theme.primaryColor)) {
+        errors.push({
+            path: 'theme.primaryColor',
+            message: `Invalid hex color "${model.theme.primaryColor}" (expected #RRGGBB)`,
+        });
+    }
+    return errors;
+}
+function validateTechStack(model) {
+    const errors = [];
+    if (model.techStack.toolkit.trim().length === 0) {
+        errors.push({
+            path: 'techStack.toolkit',
+            message: 'Toolkit is required',
+        });
+    }
+    return errors;
+}
+function validateMeta(model) {
+    const errors = [];
+    if (model.meta.revision < 1) {
+        errors.push({
+            path: 'meta.revision',
+            message: 'Revision must be a positive number',
+        });
+    }
+    if (model.meta.createdAt.length === 0) {
+        errors.push({ path: 'meta.createdAt', message: 'createdAt is required' });
+    }
+    if (model.meta.updatedAt.length === 0) {
+        errors.push({ path: 'meta.updatedAt', message: 'updatedAt is required' });
+    }
+    if (model.meta.factoryVersion.length === 0) {
+        errors.push({ path: 'meta.factoryVersion', message: 'factoryVersion is required' });
+    }
+    return errors;
+}
+// =============================================================================
+// Public API
+// =============================================================================
+export function validateModel(model) {
+    const errors = [];
+    errors.push(...validateIdentity(model));
+    // Entity uniqueness
+    const entityNames = model.entities.map((e) => e.name);
+    const entityNameSet = new Set();
+    for (const name of entityNames) {
+        if (entityNameSet.has(name)) {
+            errors.push({
+                path: 'entities',
+                message: `Duplicate entity name "${name}"`,
+            });
+        }
+        entityNameSet.add(name);
+    }
+    // Per-entity validation
+    model.entities.forEach((entity, i) => {
+        errors.push(...validateEntity(entity, i, entityNames));
+    });
+    errors.push(...validateLayout(model));
+    errors.push(...validateFeatures(model));
+    errors.push(...validateTheme(model));
+    errors.push(...validateTechStack(model));
+    errors.push(...validateMeta(model));
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/model/tools.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Model Tools
+ *
+ * app_model_get — scoped reads of the Application Model
+ * app_model_update — semantic operations on the model
+ * app_model_validate — check model health
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { PlatformContext } from '@compilr-dev/sdk';
+export interface ModelToolsConfig {
+    readonly context: PlatformContext;
+    readonly cwd?: string;
+}
+export declare function createModelTools(config: ModelToolsConfig): Tool<never>[];