@compilr-dev/factory 0.1.1

package/dist/model/tools.js

@@ -0,0 +1,380 @@
+/**
+ * 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 { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { ModelStore } from './persistence.js';
+import { applyOperation } from './operations.js';
+import { validateModel } from './schema.js';
+import { createDefaultModel } from './defaults.js';
+// =============================================================================
+// Helpers
+// =============================================================================
+function getProjectId(config, inputProjectId) {
+    const projectId = inputProjectId ?? config.context.currentProjectId;
+    if (!projectId) {
+        throw new Error('No active project. Use project_create or project_get first.');
+    }
+    return projectId;
+}
+function createStore(config, projectId) {
+    return new ModelStore({
+        documents: config.context.documents,
+        projectId,
+    });
+}
+function createSummary(model) {
+    return {
+        name: model.identity.name,
+        description: model.identity.description,
+        entityCount: model.entities.length,
+        entities: model.entities.map((e) => ({
+            name: e.name,
+            fieldCount: e.fields.length,
+            views: e.views,
+            relationshipCount: e.relationships.length,
+        })),
+        features: model.features,
+        toolkit: model.techStack.toolkit,
+        revision: model.meta.revision,
+    };
+}
+function createAppModelGetTool(config) {
+    return defineTool({
+        name: 'app_model_get',
+        description: 'Read the Application Model for the current project. Supports scoped reads: no params = full model, scope="summary" for overview, scope="identity"/"features"/"layout"/"theme"/"techStack" for sections, entity="Name" for a single entity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scope: {
+                    type: 'string',
+                    enum: ['identity', 'summary', 'features', 'layout', 'theme', 'techStack'],
+                    description: 'Which section to return. Omit for full model. Use "summary" for a lightweight overview.',
+                },
+                entity: {
+                    type: 'string',
+                    description: 'Return only this entity (by PascalCase name). Overrides scope.',
+                },
+                project_id: {
+                    type: 'number',
+                    description: 'Project ID. Uses active project if omitted.',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const store = createStore(config, projectId);
+                const model = await store.get();
+                if (!model) {
+                    return createSuccessResult({
+                        exists: false,
+                        message: 'No Application Model found. Use app_model_update with op: "addEntity" to start building one, or use the factory-scaffold skill.',
+                    });
+                }
+                // Entity-scoped read
+                if (input.entity) {
+                    const entity = model.entities.find((e) => e.name === input.entity);
+                    if (!entity) {
+                        return createErrorResult(`Entity "${input.entity}" not found`);
+                    }
+                    return createSuccessResult({ entity, meta: model.meta });
+                }
+                // Section-scoped read
+                switch (input.scope) {
+                    case 'identity':
+                        return createSuccessResult({ identity: model.identity, meta: model.meta });
+                    case 'summary':
+                        return createSuccessResult(createSummary(model));
+                    case 'features':
+                        return createSuccessResult({ features: model.features, meta: model.meta });
+                    case 'layout':
+                        return createSuccessResult({ layout: model.layout, meta: model.meta });
+                    case 'theme':
+                        return createSuccessResult({ theme: model.theme, meta: model.meta });
+                    case 'techStack':
+                        return createSuccessResult({ techStack: model.techStack, meta: model.meta });
+                    default:
+                        return createSuccessResult(model);
+                }
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+        readonly: true,
+    });
+}
+function createAppModelUpdateTool(config) {
+    return defineTool({
+        name: 'app_model_update',
+        description: `Apply a semantic operation to the Application Model. Operations: addEntity, updateEntity, removeEntity, renameEntity, reorderEntities, addField, updateField, removeField, renameField, addRelationship, removeRelationship, updateIdentity, updateLayout, updateFeatures, updateTheme, updateTechStack. If no model exists, one is created automatically with the first addEntity.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                op: {
+                    type: 'string',
+                    enum: [
+                        'addEntity',
+                        'updateEntity',
+                        'removeEntity',
+                        'renameEntity',
+                        'reorderEntities',
+                        'addField',
+                        'updateField',
+                        'removeField',
+                        'renameField',
+                        'addRelationship',
+                        'removeRelationship',
+                        'updateIdentity',
+                        'updateLayout',
+                        'updateFeatures',
+                        'updateTheme',
+                        'updateTechStack',
+                    ],
+                    description: 'The operation to perform.',
+                },
+                revision: {
+                    type: 'number',
+                    description: 'Expected current revision for optimistic locking. Optional.',
+                },
+                entity: {
+                    description: 'Entity name (string) or full entity object (for addEntity).',
+                },
+                field: {
+                    description: 'Field name (string) or full field object (for addField).',
+                },
+                relationship: {
+                    type: 'object',
+                    description: 'Relationship object for addRelationship.',
+                    properties: {
+                        type: { type: 'string', enum: ['belongsTo', 'hasMany'] },
+                        target: { type: 'string' },
+                        fieldName: { type: 'string' },
+                    },
+                },
+                updates: {
+                    type: 'object',
+                    description: 'Partial updates for update operations.',
+                },
+                newName: {
+                    type: 'string',
+                    description: 'New name for renameEntity or renameField.',
+                },
+                order: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Entity name order for reorderEntities.',
+                },
+                target: {
+                    type: 'string',
+                    description: 'Relationship target entity name for removeRelationship.',
+                },
+                force: {
+                    type: 'boolean',
+                    description: 'Force removal with cascading cleanup.',
+                },
+                project_id: {
+                    type: 'number',
+                    description: 'Project ID. Uses active project if omitted.',
+                },
+            },
+            required: ['op'],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const store = createStore(config, projectId);
+                // Load current model or create default
+                let model = await store.get();
+                if (!model) {
+                    model = createDefaultModel();
+                }
+                // Optimistic locking
+                if (input.revision !== undefined && input.revision !== model.meta.revision) {
+                    return createErrorResult(`Revision conflict: expected ${String(input.revision)}, current is ${String(model.meta.revision)}. Re-read the model and retry.`);
+                }
+                // Build the operation from the flat input
+                const operation = buildOperation(input);
+                // Apply
+                const updated = applyOperation(model, operation);
+                // Validate result
+                const validation = validateModel(updated);
+                if (!validation.valid) {
+                    const msgs = validation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
+                    return createErrorResult(`Operation would produce invalid model: ${msgs}`);
+                }
+                // Save
+                await store.save(updated);
+                return createSuccessResult({
+                    op: input.op,
+                    revision: updated.meta.revision,
+                    message: `Operation "${input.op}" applied successfully.`,
+                });
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+    });
+}
+function buildOperation(input) {
+    switch (input.op) {
+        case 'addEntity': {
+            if (!input.entity || typeof input.entity !== 'object') {
+                throw new Error('addEntity requires entity object');
+            }
+            const entity = input.entity;
+            return { op: 'addEntity', entity };
+        }
+        case 'updateEntity':
+            if (typeof input.entity !== 'string')
+                throw new Error('updateEntity requires entity name (string)');
+            if (!input.updates)
+                throw new Error('updateEntity requires updates object');
+            return { op: 'updateEntity', entity: input.entity, updates: input.updates };
+        case 'removeEntity':
+            if (typeof input.entity !== 'string')
+                throw new Error('removeEntity requires entity name (string)');
+            return { op: 'removeEntity', entity: input.entity, force: input.force };
+        case 'renameEntity':
+            if (typeof input.entity !== 'string')
+                throw new Error('renameEntity requires entity name (string)');
+            if (!input.newName)
+                throw new Error('renameEntity requires newName');
+            return { op: 'renameEntity', entity: input.entity, newName: input.newName };
+        case 'reorderEntities':
+            if (!input.order)
+                throw new Error('reorderEntities requires order array');
+            return { op: 'reorderEntities', order: input.order };
+        case 'addField': {
+            if (typeof input.entity !== 'string')
+                throw new Error('addField requires entity name (string)');
+            if (!input.field || typeof input.field !== 'object')
+                throw new Error('addField requires field object');
+            const field = input.field;
+            return { op: 'addField', entity: input.entity, field };
+        }
+        case 'updateField':
+            if (typeof input.entity !== 'string')
+                throw new Error('updateField requires entity name (string)');
+            if (typeof input.field !== 'string')
+                throw new Error('updateField requires field name (string)');
+            if (!input.updates)
+                throw new Error('updateField requires updates object');
+            return {
+                op: 'updateField',
+                entity: input.entity,
+                field: input.field,
+                updates: input.updates,
+            };
+        case 'removeField':
+            if (typeof input.entity !== 'string')
+                throw new Error('removeField requires entity name (string)');
+            if (typeof input.field !== 'string')
+                throw new Error('removeField requires field name (string)');
+            return { op: 'removeField', entity: input.entity, field: input.field };
+        case 'renameField':
+            if (typeof input.entity !== 'string')
+                throw new Error('renameField requires entity name (string)');
+            if (typeof input.field !== 'string')
+                throw new Error('renameField requires field name (string)');
+            if (!input.newName)
+                throw new Error('renameField requires newName');
+            return {
+                op: 'renameField',
+                entity: input.entity,
+                field: input.field,
+                newName: input.newName,
+            };
+        case 'addRelationship': {
+            if (typeof input.entity !== 'string')
+                throw new Error('addRelationship requires entity name (string)');
+            if (!input.relationship)
+                throw new Error('addRelationship requires relationship object');
+            const relationship = input.relationship;
+            return { op: 'addRelationship', entity: input.entity, relationship };
+        }
+        case 'removeRelationship':
+            if (typeof input.entity !== 'string')
+                throw new Error('removeRelationship requires entity name (string)');
+            if (!input.target)
+                throw new Error('removeRelationship requires target');
+            return { op: 'removeRelationship', entity: input.entity, target: input.target };
+        case 'updateIdentity':
+            if (!input.updates)
+                throw new Error('updateIdentity requires updates object');
+            return { op: 'updateIdentity', updates: input.updates };
+        case 'updateLayout':
+            if (!input.updates)
+                throw new Error('updateLayout requires updates object');
+            return { op: 'updateLayout', updates: input.updates };
+        case 'updateFeatures':
+            if (!input.updates)
+                throw new Error('updateFeatures requires updates object');
+            return { op: 'updateFeatures', updates: input.updates };
+        case 'updateTheme':
+            if (!input.updates)
+                throw new Error('updateTheme requires updates object');
+            return { op: 'updateTheme', updates: input.updates };
+        case 'updateTechStack':
+            if (!input.updates)
+                throw new Error('updateTechStack requires updates object');
+            return { op: 'updateTechStack', updates: input.updates };
+        default:
+            throw new Error(`Unknown operation: ${input.op}`);
+    }
+}
+function createAppModelValidateTool(config) {
+    return defineTool({
+        name: 'app_model_validate',
+        description: 'Validate the Application Model for the current project. Returns validation errors or confirms the model is valid.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: {
+                    type: 'number',
+                    description: 'Project ID. Uses active project if omitted.',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const store = createStore(config, projectId);
+                const model = await store.get();
+                if (!model) {
+                    return createSuccessResult({
+                        valid: false,
+                        errors: [{ path: '', message: 'No Application Model found' }],
+                    });
+                }
+                const result = validateModel(model);
+                return createSuccessResult({
+                    valid: result.valid,
+                    errors: result.errors,
+                    revision: model.meta.revision,
+                });
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+        readonly: true,
+    });
+}
+// =============================================================================
+// Public API
+// =============================================================================
+export function createModelTools(config) {
+    return [
+        createAppModelGetTool(config),
+        createAppModelUpdateTool(config),
+        createAppModelValidateTool(config),
+    ];
+}

package/dist/model/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Application Model Types
+ *
+ * The Application Model is the central data structure of the factory system.
+ * It describes WHAT an application is — entities, fields, relationships,
+ * layout, features, theme — independently of how it's built.
+ */
+export interface ApplicationModel {
+    readonly identity: Identity;
+    readonly entities: readonly Entity[];
+    readonly layout: Layout;
+    readonly features: Features;
+    readonly theme: Theme;
+    readonly techStack: TechStack;
+    readonly meta: Meta;
+}
+export interface Identity {
+    readonly name: string;
+    readonly description: string;
+    readonly version: string;
+}
+export interface Entity {
+    readonly name: string;
+    readonly pluralName: string;
+    readonly description?: string;
+    readonly icon: string;
+    readonly fields: readonly Field[];
+    readonly views: readonly View[];
+    readonly relationships: readonly Relationship[];
+}
+export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'enum';
+export interface Field {
+    readonly name: string;
+    readonly label: string;
+    readonly type: FieldType;
+    readonly required: boolean;
+    readonly enumValues?: readonly string[];
+    readonly defaultValue?: string | number | boolean;
+}
+export type View = 'card' | 'list' | 'detail';
+export type RelationshipType = 'belongsTo' | 'hasMany';
+export interface Relationship {
+    readonly type: RelationshipType;
+    readonly target: string;
+    readonly fieldName?: string;
+}
+export type ShellType = 'sidebar-header' | 'header-only';
+export interface Layout {
+    readonly shell: ShellType;
+}
+export interface Features {
+    readonly dashboard: boolean;
+    readonly auth: boolean;
+    readonly userProfiles: boolean;
+    readonly settings: boolean;
+    readonly darkMode: boolean;
+}
+export interface Theme {
+    readonly primaryColor: string;
+}
+export interface TechStack {
+    readonly toolkit: string;
+}
+export interface Meta {
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly factoryVersion: string;
+    readonly generatedAt?: string;
+}

package/dist/model/types.js

@@ -0,0 +1,8 @@
+/**
+ * Application Model Types
+ *
+ * The Application Model is the central data structure of the factory system.
+ * It describes WHAT an application is — entities, fields, relationships,
+ * layout, features, theme — independently of how it's built.
+ */
+export {};

package/dist/toolkits/react-node/api.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React+Node Toolkit — API Generator
+ *
+ * Generates: server/index.ts, server/routes/{entity}.ts, server/data/{entity}.ts
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateApiFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/react-node/api.js

@@ -0,0 +1,198 @@
+/**
+ * React+Node Toolkit — API Generator
+ *
+ * Generates: server/index.ts, server/routes/{entity}.ts, server/data/{entity}.ts
+ */
+import { toCamelCase, toKebabCase } from '../../model/naming.js';
+import { tsType, fkFieldName, belongsToRels } from './helpers.js';
+import { generateSeedData } from './seed.js';
+export function generateApiFiles(model) {
+    return [
+        generateServerIndex(model),
+        ...model.entities.flatMap((entity) => [
+            generateDataStore(model, entity),
+            generateRoutes(model, entity),
+        ]),
+    ];
+}
+// =============================================================================
+// Server Entry Point
+// =============================================================================
+function generateServerIndex(model) {
+    const routeImports = model.entities
+        .map((e) => {
+        const varName = toCamelCase(e.pluralName) + 'Router';
+        const fileName = toKebabCase(e.pluralName).toLowerCase();
+        return `import { ${varName} } from './routes/${fileName}.js';`;
+    })
+        .join('\n');
+    const routeMounts = model.entities
+        .map((e) => {
+        const varName = toCamelCase(e.pluralName) + 'Router';
+        const apiRoute = '/api/' + toKebabCase(e.pluralName).toLowerCase();
+        return `app.use('${apiRoute}', ${varName});`;
+    })
+        .join('\n');
+    return {
+        path: 'server/index.ts',
+        content: `import express from 'express';
+import cors from 'cors';
+${routeImports}
+
+const app = express();
+const PORT = process.env.PORT ?? 3001;
+
+app.use(cors());
+app.use(express.json());
+
+${routeMounts}
+
+app.listen(PORT, () => {
+  console.log(\`API server running on http://localhost:\${String(PORT)}\`);
+});
+`,
+    };
+}
+// =============================================================================
+// Data Store
+// =============================================================================
+function generateDataStore(model, entity) {
+    const fileName = toKebabCase(entity.pluralName).toLowerCase();
+    const varName = toCamelCase(entity.pluralName);
+    const typeName = entity.name;
+    // Generate type definition for the store
+    const typeFields = ['  id: number;'];
+    for (const field of entity.fields) {
+        const optional = field.required ? '' : '?';
+        typeFields.push(`  ${field.name}${optional}: ${tsType(field)};`);
+    }
+    for (const rel of belongsToRels(entity)) {
+        typeFields.push(`  ${fkFieldName(rel)}: number;`);
+    }
+    const seedData = generateSeedData(model, entity);
+    return {
+        path: `server/data/${fileName}.ts`,
+        content: `// In-memory data store for ${entity.pluralName}
+
+export interface ${typeName}Record {
+${typeFields.join('\n')}
+}
+
+${seedData}
+
+let items: ${typeName}Record[] = [...${varName}SeedData];
+let nextId = items.length + 1;
+
+export function getAll(): ${typeName}Record[] {
+  return items;
+}
+
+export function getById(id: number): ${typeName}Record | undefined {
+  return items.find((item) => item.id === id);
+}
+
+export function create(data: Omit<${typeName}Record, 'id'>): ${typeName}Record {
+  const item = { ...data, id: nextId++ };
+  items.push(item);
+  return item;
+}
+
+export function update(id: number, data: Partial<${typeName}Record>): ${typeName}Record | undefined {
+  const index = items.findIndex((item) => item.id === id);
+  if (index === -1) return undefined;
+  items[index] = { ...items[index], ...data, id };
+  return items[index];
+}
+
+export function remove(id: number): boolean {
+  const index = items.findIndex((item) => item.id === id);
+  if (index === -1) return false;
+  items.splice(index, 1);
+  return true;
+}
+`,
+    };
+}
+// =============================================================================
+// Routes
+// =============================================================================
+function generateRoutes(model, entity) {
+    const fileName = toKebabCase(entity.pluralName).toLowerCase();
+    const varName = toCamelCase(entity.pluralName) + 'Router';
+    const dataImport = fileName;
+    const btoRels = belongsToRels(entity);
+    // Populate belongsTo entities
+    const populateImports = btoRels
+        .map((rel) => {
+        const targetEntity = model.entities.find((e) => e.name === rel.target);
+        if (!targetEntity)
+            return '';
+        const targetFile = toKebabCase(targetEntity.pluralName).toLowerCase();
+        return `import { getById as get${rel.target}ById } from '../data/${targetFile}.js';`;
+    })
+        .filter(Boolean)
+        .join('\n');
+    const populateLogic = btoRels.length > 0
+        ? `
+function populate(item: Record<string, unknown>): Record<string, unknown> {
+  const result = { ...item };
+${btoRels
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            return `  if (result.${fk}) result.${targetVar} = get${rel.target}ById(result.${fk} as number);`;
+        })
+            .join('\n')}
+  return result;
+}
+`
+        : '';
+    const getListReturn = btoRels.length > 0
+        ? 'res.json(items.map((item) => populate(item as unknown as Record<string, unknown>)));'
+        : 'res.json(items);';
+    const getByIdReturn = btoRels.length > 0
+        ? 'res.json(populate(item as unknown as Record<string, unknown>));'
+        : 'res.json(item);';
+    return {
+        path: `server/routes/${fileName}.ts`,
+        content: `import { Router } from 'express';
+import { getAll, getById, create, update, remove } from '../data/${dataImport}.js';
+${populateImports}
+
+export const ${varName} = Router();
+${populateLogic}
+// GET all
+${varName}.get('/', (_req, res) => {
+  const items = getAll();
+  ${getListReturn}
+});
+
+// GET by ID
+${varName}.get('/:id', (req, res) => {
+  const item = getById(Number(req.params.id));
+  if (!item) return res.status(404).json({ error: 'Not found' });
+  ${getByIdReturn}
+});
+
+// POST create
+${varName}.post('/', (req, res) => {
+  const item = create(req.body);
+  res.status(201).json(item);
+});
+
+// PUT update
+${varName}.put('/:id', (req, res) => {
+  const item = update(Number(req.params.id), req.body);
+  if (!item) return res.status(404).json({ error: 'Not found' });
+  res.json(item);
+});
+
+// DELETE
+${varName}.delete('/:id', (req, res) => {
+  const success = remove(Number(req.params.id));
+  if (!success) return res.status(404).json({ error: 'Not found' });
+  res.status(204).send();
+});
+`,
+    };
+}

package/dist/toolkits/react-node/config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * React+Node Toolkit — Configuration Files Generator
+ *
+ * Generates: package.json, vite.config.ts, tailwind.config.js,
+ * tsconfig.json, postcss.config.js
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateConfigFiles(model: ApplicationModel): FactoryFile[];