@compilr-dev/factory 0.1.10 → 0.1.12

package/dist/factory/list-toolkits-tool.js

@@ -7,7 +7,8 @@ import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev
 export function createListToolkitsTool(registry) {
     return defineTool({
         name: 'factory_list_toolkits',
-        description: 'List all available factory toolkits. Each toolkit generates a different type of application (e.g. React+Node, Next.js, etc.).',
+        // Original: 'List all available factory toolkits. Each toolkit generates a different type of application (e.g. React+Node, Next.js, etc.).'
+        description: 'List all available factory toolkits.',
         inputSchema: {
             type: 'object',
             properties: {},

package/dist/factory/registry.js

@@ -28,7 +28,9 @@ import { reactNodeToolkit } from '../toolkits/react-node/index.js';
 import { nextPrismaToolkit } from '../toolkits/next-prisma/index.js';
 import { staticLandingToolkit } from '../toolkits/static-landing/index.js';
 import { reactFastapiToolkit } from '../toolkits/react-fastapi/index.js';
+import { reactGoToolkit } from '../toolkits/react-go/index.js';
 defaultRegistry.register(reactNodeToolkit);
 defaultRegistry.register(nextPrismaToolkit);
 defaultRegistry.register(staticLandingToolkit);
 defaultRegistry.register(reactFastapiToolkit);
+defaultRegistry.register(reactGoToolkit);

package/dist/factory/scaffold-tool.js

@@ -11,13 +11,15 @@ import { writeFactoryFiles } from './file-writer.js';
 export function createScaffoldTool(config) {
     return defineTool({
         name: 'factory_scaffold',
-        description: 'Generate a full application from the Application Model. Reads the model, validates it, runs the toolkit generators, and writes files to disk. Use dry_run: true to preview without writing.',
+        // Original: 'Generate a full application from the Application Model. Reads the model, validates it, runs the toolkit generators, and writes files to disk. Use dry_run: true to preview without writing.'
+        description: 'Generate a full application from the Application Model and write files to disk.',
         inputSchema: {
             type: 'object',
             properties: {
                 dry_run: {
                     type: 'boolean',
-                    description: 'Preview generated files without writing to disk. Default: false.',
+                    description: 'Preview generated files without writing to disk.',
+                    default: false,
                 },
                 output_dir: {
                     type: 'string',

package/dist/index.d.ts

@@ -22,4 +22,5 @@ export { reactNodeToolkit } from './toolkits/react-node/index.js';
 export { nextPrismaToolkit } from './toolkits/next-prisma/index.js';
 export { staticLandingToolkit } from './toolkits/static-landing/index.js';
 export { reactFastapiToolkit } from './toolkits/react-fastapi/index.js';
+export { reactGoToolkit } from './toolkits/react-go/index.js';
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';

package/dist/index.js

@@ -27,5 +27,7 @@ export { nextPrismaToolkit } from './toolkits/next-prisma/index.js';
 export { staticLandingToolkit } from './toolkits/static-landing/index.js';
 // React + FastAPI Toolkit
 export { reactFastapiToolkit } from './toolkits/react-fastapi/index.js';
+// React + Go Toolkit
+export { reactGoToolkit } from './toolkits/react-go/index.js';
 // Factory skill (Phase 5)
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';

package/dist/model/tools.js

@@ -45,7 +45,8 @@ function createSummary(model) {
 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.',
+        // Original: '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.'
+        description: 'Read the Application Model. Supports scoped reads by section or entity name.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -112,18 +113,8 @@ function createAppModelGetTool(config) {
 function createAppModelUpdateTool(config) {
     return defineTool({
         name: 'app_model_update',
-        description: `Apply a semantic operation to the Application Model. If no model exists, one is created automatically.
-
-EXAMPLES:
-- updateIdentity: { "op": "updateIdentity", "updates": { "name": "My App", "description": "A task manager" } }
-- updateTechStack: { "op": "updateTechStack", "updates": { "toolkit": "react-node" } }
-- addEntity: { "op": "addEntity", "entity": { "name": "Task", "pluralName": "Tasks", "icon": "📋", "fields": [{ "name": "title", "label": "Title", "type": "string", "required": true }], "views": ["list", "detail", "card"], "relationships": [] } }
-- addField: { "op": "addField", "entity": "Task", "field": { "name": "dueDate", "label": "Due Date", "type": "date", "required": false } }
-- addRelationship: { "op": "addRelationship", "entity": "Task", "relationship": { "type": "belongsTo", "target": "Project" } }
-- updateFeatures: { "op": "updateFeatures", "updates": { "dashboard": true, "darkMode": true } }
-- updateTheme: { "op": "updateTheme", "updates": { "primaryColor": "#1976D2" } }
-- updateLayout: { "op": "updateLayout", "updates": { "shell": "sidebar-header" } }
-- removeEntity: { "op": "removeEntity", "entity": "Task", "force": true }`,
+        // Original: long description with 9 inline JSON examples (~1200 chars)
+        description: 'Apply a semantic operation to the Application Model. Auto-creates if none exists.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -402,7 +393,8 @@ function buildOperation(input) {
 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.',
+        // Original: 'Validate the Application Model for the current project. Returns validation errors or confirms the model is valid.'
+        description: 'Validate the Application Model. Returns errors or confirms validity.',
         inputSchema: {
             type: 'object',
             properties: {

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

@@ -0,0 +1,12 @@
+/**
+ * React+Go Toolkit — API Generator
+ *
+ * Generates: server/main.go, server/models.go,
+ * server/data/{entity}.go, server/handlers/{entity}.go
+ *
+ * All files use `package main` so `go run ./server` compiles everything.
+ * Go 1.22+ net/http stdlib with method-based routing.
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateApiFiles(model: ApplicationModel): FactoryFile[];

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

@@ -0,0 +1,523 @@
+/**
+ * React+Go Toolkit — API Generator
+ *
+ * Generates: server/main.go, server/models.go,
+ * server/data/{entity}.go, server/handlers/{entity}.go
+ *
+ * All files use `package main` so `go run ./server` compiles everything.
+ * Go 1.22+ net/http stdlib with method-based routing.
+ */
+import { toCamelCase, toKebabCase, toPascalCase } from '../../model/naming.js';
+import { goType, fkFieldName, belongsToRels, hasManyRels } from './helpers.js';
+import { toSnakeCase } from './helpers.js';
+import { generateSeedData } from './seed.js';
+export function generateApiFiles(model) {
+    return [
+        generateServerMain(model),
+        generateModels(model),
+        ...model.entities.flatMap((entity) => [
+            generateDataStore(model, entity),
+            generateHandlers(model, entity),
+        ]),
+    ];
+}
+// =============================================================================
+// Server Entry Point — server/main.go
+// =============================================================================
+function generateServerMain(model) {
+    const handlerRegistrations = model.entities
+        .map((e) => `\tRegister${e.name}Handlers(mux)`)
+        .join('\n');
+    return {
+        path: 'server/main.go',
+        content: `package main
+
+import (
+\t"fmt"
+\t"log"
+\t"net/http"
+\t"os"
+)
+
+func corsMiddleware(next http.Handler) http.Handler {
+\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+\t\tw.Header().Set("Access-Control-Allow-Origin", "*")
+\t\tw.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+\t\tw.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+\t\tif r.Method == http.MethodOptions {
+\t\t\tw.WriteHeader(http.StatusNoContent)
+\t\t\treturn
+\t\t}
+\t\tnext.ServeHTTP(w, r)
+\t})
+}
+
+func main() {
+\tmux := http.NewServeMux()
+
+${handlerRegistrations}
+
+\tport := os.Getenv("PORT")
+\tif port == "" {
+\t\tport = "8080"
+\t}
+
+\tfmt.Printf("Server listening on :%s\\n", port)
+\tlog.Fatal(http.ListenAndServe(":"+port, corsMiddleware(mux)))
+}
+`,
+    };
+}
+// =============================================================================
+// Models — server/models.go
+// =============================================================================
+function generateModels(model) {
+    const modelBlocks = [];
+    for (const entity of model.entities) {
+        const btoRels = belongsToRels(entity);
+        // Main struct (with json tags)
+        const structFields = [];
+        structFields.push(`\tID        int    \`json:"id"\``);
+        for (const field of entity.fields) {
+            const goT = goType(field);
+            const jsonTag = field.name;
+            const goFieldName = toPascalCase(field.name);
+            structFields.push(`\t${goFieldName} ${goT} \`json:"${jsonTag}"\``);
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            const goFieldName = toPascalCase(fk);
+            structFields.push(`\t${goFieldName} int \`json:"${fk}"\``);
+        }
+        structFields.push(`\tCreatedAt string \`json:"createdAt"\``);
+        structFields.push(`\tUpdatedAt string \`json:"updatedAt"\``);
+        // Input struct (for create/update — pointer fields for optional update detection)
+        const inputFields = [];
+        for (const field of entity.fields) {
+            const goT = goType(field);
+            const jsonTag = field.name;
+            const goFieldName = toPascalCase(field.name);
+            inputFields.push(`\t${goFieldName} *${goT} \`json:"${jsonTag}"\``);
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            const goFieldName = toPascalCase(fk);
+            inputFields.push(`\t${goFieldName} *int \`json:"${fk}"\``);
+        }
+        modelBlocks.push(`type ${entity.name} struct {
+${structFields.join('\n')}
+}
+
+type ${entity.name}Input struct {
+${inputFields.join('\n')}
+}`);
+    }
+    return {
+        path: 'server/models.go',
+        content: `package main
+${modelBlocks.length > 0 ? '\n' + modelBlocks.join('\n\n') + '\n' : ''}`,
+    };
+}
+// =============================================================================
+// Data Store — server/data/{entity}.go
+// =============================================================================
+function generateDataStore(model, entity) {
+    const lowerName = toCamelCase(entity.pluralName);
+    const snakeName = toSnakeCase(entity.pluralName);
+    // Collect searchable fields (string + enum types)
+    const searchableFields = entity.fields
+        .filter((f) => f.type === 'string' || f.type === 'enum')
+        .map((f) => toPascalCase(f.name));
+    let searchLogic;
+    if (searchableFields.length > 0) {
+        const fieldChecks = searchableFields
+            .map((f) => `\t\t\t\tstrings.Contains(strings.ToLower(fmt.Sprintf("%v", item.${f})), q)`)
+            .join(' ||\n');
+        searchLogic = `\t\tq := strings.ToLower(search)
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tif ${fieldChecks.trim()} {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered`;
+    }
+    else {
+        searchLogic = `\t\tq := strings.ToLower(search)
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tif strings.Contains(strings.ToLower(fmt.Sprintf("%v", item)), q) {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered`;
+    }
+    // Filter logic — check field values via reflect-like approach (simple string comparison)
+    const filterableFields = entity.fields.map((f) => ({
+        jsonName: f.name,
+        goName: toPascalCase(f.name),
+    }));
+    const filterChecks = filterableFields
+        .map((f) => `\t\t\t\tcase "${f.jsonName}":\n\t\t\t\t\tif fmt.Sprintf("%v", item.${f.goName}) != value {\n\t\t\t\t\t\tmatch = false\n\t\t\t\t\t}`)
+        .join('\n');
+    const seedData = generateSeedData(model, entity);
+    return {
+        path: `server/data/${snakeName}.go`,
+        content: `package main
+
+import (
+\t"fmt"
+\t"strings"
+\t"sync"
+\t"time"
+)
+
+${seedData}
+
+type ${entity.name}Store struct {
+\tmu     sync.Mutex
+\titems  []${entity.name}
+\tnextID int
+}
+
+var ${lowerName}Store = &${entity.name}Store{
+\titems:  make([]${entity.name}, len(seedData)),
+\tnextID: len(seedData) + 1,
+}
+
+func init() {
+\tcopy(${lowerName}Store.items, seedData)
+}
+
+func (s *${entity.name}Store) GetAll() []${entity.name} {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tresult := make([]${entity.name}, len(s.items))
+\tcopy(result, s.items)
+\treturn result
+}
+
+func (s *${entity.name}Store) GetByID(id int) (${entity.name}, bool) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor _, item := range s.items {
+\t\tif item.ID == id {
+\t\t\treturn item, true
+\t\t}
+\t}
+\treturn ${entity.name}{}, false
+}
+
+func (s *${entity.name}Store) Query(search string, filters map[string]string) ([]${entity.name}, int) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tresult := make([]${entity.name}, len(s.items))
+\tcopy(result, s.items)
+
+\tif search != "" {
+${searchLogic}
+\t}
+
+\tif len(filters) > 0 {
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tmatch := true
+\t\t\tfor field, value := range filters {
+\t\t\t\tswitch field {
+${filterChecks}
+\t\t\t\t}
+\t\t\t}
+\t\t\tif match {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered
+\t}
+
+\treturn result, len(result)
+}
+
+func (s *${entity.name}Store) Create(input ${entity.name}Input) ${entity.name} {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tnow := time.Now().UTC().Format(time.RFC3339)
+\titem := ${entity.name}{
+\t\tID:        s.nextID,
+\t\tCreatedAt: now,
+\t\tUpdatedAt: now,
+\t}
+\ts.nextID++
+${entity.fields.map((f) => `\tif input.${toPascalCase(f.name)} != nil {\n\t\titem.${toPascalCase(f.name)} = *input.${toPascalCase(f.name)}\n\t}`).join('\n')}
+${belongsToRels(entity)
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            return `\tif input.${goField} != nil {\n\t\titem.${goField} = *input.${goField}\n\t}`;
+        })
+            .join('\n')}
+\ts.items = append(s.items, item)
+\treturn item
+}
+
+func (s *${entity.name}Store) Update(id int, input ${entity.name}Input) (${entity.name}, bool) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor i, item := range s.items {
+\t\tif item.ID == id {
+\t\t\tnow := time.Now().UTC().Format(time.RFC3339)
+${entity.fields.map((f) => `\t\t\tif input.${toPascalCase(f.name)} != nil {\n\t\t\t\ts.items[i].${toPascalCase(f.name)} = *input.${toPascalCase(f.name)}\n\t\t\t}`).join('\n')}
+${belongsToRels(entity)
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            return `\t\t\tif input.${goField} != nil {\n\t\t\t\ts.items[i].${goField} = *input.${goField}\n\t\t\t}`;
+        })
+            .join('\n')}
+\t\t\ts.items[i].UpdatedAt = now
+\t\t\treturn s.items[i], true
+\t\t}
+\t}
+\treturn ${entity.name}{}, false
+}
+
+func (s *${entity.name}Store) Remove(id int) bool {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor i, item := range s.items {
+\t\tif item.ID == id {
+\t\t\ts.items = append(s.items[:i], s.items[i+1:]...)
+\t\t\treturn true
+\t\t}
+\t}
+\treturn false
+}
+`,
+    };
+}
+// =============================================================================
+// Handlers — server/handlers/{entity}.go
+// =============================================================================
+function generateHandlers(model, entity) {
+    const snakeName = toSnakeCase(entity.pluralName);
+    const lowerName = toCamelCase(entity.pluralName);
+    const apiRoute = '/api/' + toKebabCase(entity.pluralName).toLowerCase();
+    const btoRels = belongsToRels(entity);
+    const hmRels = hasManyRels(entity);
+    // Populate function for belongsTo
+    let populateType = '';
+    let populateFunc = '';
+    if (btoRels.length > 0) {
+        const populateFields = [];
+        // Original entity fields
+        populateFields.push(`\t${entity.name}`);
+        for (const rel of btoRels) {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                continue;
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            populateFields.push(`\t${toPascalCase(targetVar)} *${rel.target} \`json:"${targetVar}"\``);
+        }
+        populateType = `\ntype ${entity.name}WithRels struct {
+${populateFields.join('\n')}
+}\n`;
+        const populateBody = btoRels
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            const targetStoreName = toCamelCase(targetEntity.pluralName);
+            return `\tif item.${goField} != 0 {
+\t\tif found, ok := ${targetStoreName}Store.GetByID(item.${goField}); ok {
+\t\t\tresult.${toPascalCase(targetVar)} = &found
+\t\t}
+\t}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        populateFunc = `
+func populate${entity.name}(item ${entity.name}) ${entity.name}WithRels {
+\tresult := ${entity.name}WithRels{${entity.name}: item}
+${populateBody}
+\treturn result
+}
+`;
+    }
+    // hasMany include logic
+    let includeLogic = '';
+    let includeType = '';
+    if (hmRels.length > 0) {
+        const includeFields = [];
+        if (btoRels.length > 0) {
+            includeFields.push(`\t${entity.name}WithRels`);
+        }
+        else {
+            includeFields.push(`\t${entity.name}`);
+        }
+        for (const rel of hmRels) {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                continue;
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            includeFields.push(`\t${toPascalCase(targetVar)} []${rel.target} \`json:"${targetVar},omitempty"\``);
+        }
+        includeType = `\ntype ${entity.name}WithIncludes struct {
+${includeFields.join('\n')}
+}\n`;
+        const includeChecks = hmRels
+            .map((rel) => {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            const targetStoreName = toCamelCase(targetEntity.pluralName);
+            const fkRel = targetEntity.relationships.find((r) => r.type === 'belongsTo' && r.target === entity.name) ?? { type: 'belongsTo', target: entity.name };
+            const fk = fkFieldName(fkRel);
+            const goFk = toPascalCase(fk);
+            return `\t\tfor _, inc := range includes {
+\t\t\tif inc == "${targetVar}" {
+\t\t\t\tallItems := ${targetStoreName}Store.GetAll()
+\t\t\t\tvar related []${rel.target}
+\t\t\t\tfor _, r := range allItems {
+\t\t\t\t\tif r.${goFk} == item.ID {
+\t\t\t\t\t\trelated = append(related, r)
+\t\t\t\t\t}
+\t\t\t\t}
+\t\t\t\tresult.${toPascalCase(targetVar)} = related
+\t\t\t}
+\t\t}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        includeLogic = includeChecks;
+    }
+    // GET list handler
+    const listReturnExpr = btoRels.length > 0
+        ? `\tpopulated := make([]${entity.name}WithRels, len(items))
+\tfor i, item := range items {
+\t\tpopulated[i] = populate${entity.name}(item)
+\t}
+\tjson.NewEncoder(w).Encode(map[string]any{"data": populated, "total": total})`
+        : `\tjson.NewEncoder(w).Encode(map[string]any{"data": items, "total": total})`;
+    // GET by ID handler
+    let getByIDBody;
+    if (hmRels.length > 0) {
+        const baseExpr = btoRels.length > 0 ? `populate${entity.name}(item)` : `item`;
+        const innerType = btoRels.length > 0 ? `${entity.name}WithRels` : entity.name;
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tincludeParam := r.URL.Query().Get("include")
+\tincludes := strings.Split(includeParam, ",")
+\tresult := ${entity.name}WithIncludes{${innerType}: ${baseExpr}}
+${includeLogic}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(result)`;
+    }
+    else if (btoRels.length > 0) {
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(populate${entity.name}(item))`;
+    }
+    else {
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(item)`;
+    }
+    // Determine imports needed
+    const needsStrings = hmRels.length > 0;
+    return {
+        path: `server/handlers/${snakeName}.go`,
+        content: `package main
+
+import (
+\t"encoding/json"
+\t"net/http"
+\t"strconv"${needsStrings ? '\n\t"strings"' : ''}
+)
+${populateType}${includeType}${populateFunc}
+func Register${entity.name}Handlers(mux *http.ServeMux) {
+\tmux.HandleFunc("GET ${apiRoute}", func(w http.ResponseWriter, r *http.Request) {
+\t\tsearch := r.URL.Query().Get("search")
+\t\tfilters := make(map[string]string)
+\t\tfor key, values := range r.URL.Query() {
+\t\t\tif len(key) > 7 && key[:7] == "filter[" && key[len(key)-1] == ']' {
+\t\t\t\tfield := key[7 : len(key)-1]
+\t\t\t\tfilters[field] = values[0]
+\t\t\t}
+\t\t}
+\t\titems, total := ${lowerName}Store.Query(search, filters)
+\t\tw.Header().Set("Content-Type", "application/json")
+${listReturnExpr}
+\t})
+
+\tmux.HandleFunc("GET ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+${getByIDBody}
+\t})
+
+\tmux.HandleFunc("POST ${apiRoute}", func(w http.ResponseWriter, r *http.Request) {
+\t\tvar input ${entity.name}Input
+\t\tif err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid json"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\titem := ${lowerName}Store.Create(input)
+\t\tw.Header().Set("Content-Type", "application/json")
+\t\tw.WriteHeader(http.StatusCreated)
+\t\tjson.NewEncoder(w).Encode(item)
+\t})
+
+\tmux.HandleFunc("PUT ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\tvar input ${entity.name}Input
+\t\tif err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid json"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\titem, ok := ${lowerName}Store.Update(id, input)
+\t\tif !ok {
+\t\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\t\treturn
+\t\t}
+\t\tw.Header().Set("Content-Type", "application/json")
+\t\tjson.NewEncoder(w).Encode(item)
+\t})
+
+\tmux.HandleFunc("DELETE ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\tok := ${lowerName}Store.Remove(id)
+\t\tif !ok {
+\t\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\t\treturn
+\t\t}
+\t\tw.WriteHeader(http.StatusNoContent)
+\t})
+}
+`,
+    };
+}

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

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

package/dist/toolkits/react-go/config.js

@@ -0,0 +1,129 @@
+/**
+ * React+Go Toolkit — Configuration Files Generator
+ *
+ * Generates: package.json, vite.config.ts, tailwind.config.js,
+ * tsconfig.json, postcss.config.js, go.mod
+ */
+import { toKebabCase } from '../../model/naming.js';
+import { generateColorShades } from '../shared/color-utils.js';
+export function generateConfigFiles(model) {
+    const appSlug = toKebabCase(model.identity.name);
+    return [
+        generatePackageJson(appSlug),
+        generateViteConfig(),
+        generateTailwindConfig(model),
+        generateTsConfig(),
+        generatePostCssConfig(),
+        generateGoMod(appSlug),
+    ];
+}
+function generatePackageJson(appSlug) {
+    const pkg = {
+        name: appSlug,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'concurrently "vite" "go run ./server"',
+            build: 'vite build',
+            preview: 'vite preview',
+            server: 'go run ./server',
+        },
+        dependencies: {
+            react: '^18.3.1',
+            'react-dom': '^18.3.1',
+            'react-router-dom': '^6.28.0',
+        },
+        devDependencies: {
+            '@types/react': '^18.3.12',
+            '@types/react-dom': '^18.3.1',
+            '@vitejs/plugin-react': '^4.3.4',
+            autoprefixer: '^10.4.20',
+            concurrently: '^9.1.0',
+            postcss: '^8.4.49',
+            '@tailwindcss/forms': '^0.5.9',
+            tailwindcss: '^3.4.15',
+            typescript: '^5.6.3',
+            vite: '^6.0.0',
+        },
+    };
+    return { path: 'package.json', content: JSON.stringify(pkg, null, 2) + '\n' };
+}
+function generateViteConfig() {
+    return {
+        path: 'vite.config.ts',
+        content: `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    proxy: {
+      '/api': 'http://localhost:8080',
+    },
+  },
+});
+`,
+    };
+}
+function generateTailwindConfig(model) {
+    return {
+        path: 'tailwind.config.js',
+        content: `import forms from '@tailwindcss/forms';
+
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./index.html', './src/**/*.{ts,tsx}'],
+  darkMode: 'class',
+  theme: {
+    extend: {
+      colors: {
+        primary: ${generateColorShades(model.theme.primaryColor)},
+      },
+    },
+  },
+  plugins: [forms],
+};
+`,
+    };
+}
+function generateTsConfig() {
+    const config = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            jsx: 'react-jsx',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+        },
+        include: ['src'],
+    };
+    return { path: 'tsconfig.json', content: JSON.stringify(config, null, 2) + '\n' };
+}
+function generatePostCssConfig() {
+    return {
+        path: 'postcss.config.js',
+        content: `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};
+`,
+    };
+}
+function generateGoMod(appSlug) {
+    return {
+        path: 'go.mod',
+        content: `module ${appSlug}
+
+go 1.22
+`,
+    };
+}

package/dist/toolkits/react-go/helpers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * React+Go Toolkit — Helpers
+ *
+ * Go-specific helpers plus re-exports from shared helpers.
+ */
+import type { Field } from '../../model/types.js';
+/** Map a model FieldType to a Go type string. */
+export declare function goType(field: Field): string;
+/** Generate a Go zero value string for a field. */
+export declare function goZeroValue(field: Field): string;
+/** Convert PascalCase or camelCase to snake_case. */
+export declare function toSnakeCase(name: string): string;
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-go/helpers.js

@@ -0,0 +1,49 @@
+/**
+ * React+Go Toolkit — Helpers
+ *
+ * Go-specific helpers plus re-exports from shared helpers.
+ */
+/** Map a model FieldType to a Go type string. */
+export function goType(field) {
+    const lowerName = field.name.toLowerCase();
+    switch (field.type) {
+        case 'string':
+        case 'enum':
+        case 'date':
+            return 'string';
+        case 'number':
+            if (lowerName.includes('price') ||
+                lowerName.includes('cost') ||
+                lowerName.includes('amount')) {
+                return 'float64';
+            }
+            return 'int';
+        case 'boolean':
+            return 'bool';
+        default:
+            return 'string';
+    }
+}
+/** Generate a Go zero value string for a field. */
+export function goZeroValue(field) {
+    switch (field.type) {
+        case 'string':
+        case 'enum':
+        case 'date':
+            return '""';
+        case 'number':
+            return '0';
+        case 'boolean':
+            return 'false';
+        default:
+            return '""';
+    }
+}
+/** Convert PascalCase or camelCase to snake_case. */
+export function toSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-go/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React+Go Toolkit
+ *
+ * Generates a full-stack MVP: React 18 + Vite + Tailwind + Go (net/http).
+ * Deterministic: same ApplicationModel -> same output files.
+ *
+ * Frontend is identical to react-node (same React components, Vite config, Tailwind).
+ * Backend is Go net/http stdlib with in-memory data stores.
+ */
+import type { FactoryToolkit } from '../types.js';
+export declare const reactGoToolkit: FactoryToolkit;

package/dist/toolkits/react-go/index.js

@@ -0,0 +1,55 @@
+/**
+ * React+Go Toolkit
+ *
+ * Generates a full-stack MVP: React 18 + Vite + Tailwind + Go (net/http).
+ * Deterministic: same ApplicationModel -> same output files.
+ *
+ * Frontend is identical to react-node (same React components, Vite config, Tailwind).
+ * Backend is Go net/http stdlib with in-memory data stores.
+ */
+import { generateConfigFiles } from './config.js';
+import { generateStaticFiles } from './static.js';
+import { generateShellFiles } from '../react-node/shell.js';
+import { generateSharedComponents } from './shared.js';
+import { generateDashboard } from '../react-node/dashboard.js';
+import { generateEntityFiles } from '../react-node/entity.js';
+import { generateRouter } from '../react-node/router.js';
+import { generateApiFiles } from './api.js';
+import { generateTypesFile } from '../react-node/types-gen.js';
+export const reactGoToolkit = {
+    id: 'react-go',
+    name: 'React + Go',
+    description: 'React 18 + Vite + Tailwind CSS + Go — full-stack MVP with Go net/http backend',
+    requiredSections: ['identity', 'entities', 'layout', 'features', 'theme'],
+    generate(model) {
+        const warnings = [];
+        const allFiles = [];
+        // Collect files from all generators
+        const generators = [
+            generateConfigFiles(model),
+            generateStaticFiles(model),
+            generateTypesFile(model),
+            generateShellFiles(model),
+            generateSharedComponents(),
+            generateDashboard(model),
+            generateEntityFiles(model),
+            generateRouter(model),
+            generateApiFiles(model),
+        ];
+        for (const files of generators) {
+            allFiles.push(...files);
+        }
+        // Check for potential issues
+        if (model.entities.length === 0) {
+            warnings.push('No entities defined — generated app will have minimal functionality.');
+        }
+        if (model.entities.length > 10) {
+            warnings.push('Large number of entities — generated sidebar may be crowded.');
+        }
+        return {
+            files: allFiles,
+            toolkit: 'react-go',
+            warnings,
+        };
+    },
+};

package/dist/toolkits/react-go/seed.d.ts

@@ -0,0 +1,12 @@
+/**
+ * React+Go Toolkit — Seed Data Generator
+ *
+ * Generates realistic mock data in Go struct literal format.
+ * Uses shared generateFieldValue for deterministic values,
+ * wraps them in Go slice-of-structs format for in-memory data stores.
+ */
+import type { ApplicationModel, Entity } from '../../model/types.js';
+import { SEED_COUNT } from '../shared/seed-data.js';
+/** Generate seed data items for a single entity (Go slice format). */
+export declare function generateSeedData(model: ApplicationModel, entity: Entity): string;
+export { SEED_COUNT };

package/dist/toolkits/react-go/seed.js

@@ -0,0 +1,55 @@
+/**
+ * React+Go Toolkit — Seed Data Generator
+ *
+ * Generates realistic mock data in Go struct literal format.
+ * Uses shared generateFieldValue for deterministic values,
+ * wraps them in Go slice-of-structs format for in-memory data stores.
+ */
+import { belongsToRels, fkFieldName } from './helpers.js';
+import { toPascalCase } from '../../model/naming.js';
+import { generateFieldValue, SEED_COUNT } from '../shared/seed-data.js';
+/** Generate seed data items for a single entity (Go slice format). */
+export function generateSeedData(model, entity) {
+    const rels = belongsToRels(entity);
+    const lines = [];
+    lines.push(`var seedData = []${entity.name}{`);
+    for (let i = 0; i < SEED_COUNT; i++) {
+        const fields = [];
+        fields.push(`ID: ${String(i + 1)}`);
+        for (const field of entity.fields) {
+            const jsValue = generateFieldValue(field, i, entity.name);
+            const goValue = jsToGoValue(jsValue, field.type);
+            fields.push(`${toPascalCase(field.name)}: ${goValue}`);
+        }
+        // FK fields from belongsTo relationships
+        for (const rel of rels) {
+            const fk = fkFieldName(rel);
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            const targetCount = targetEntity ? SEED_COUNT : SEED_COUNT;
+            fields.push(`${toPascalCase(fk)}: ${String((i % targetCount) + 1)}`);
+        }
+        // Implicit timestamps (deterministic)
+        const createdDate = new Date('2025-06-01T10:00:00Z');
+        createdDate.setDate(createdDate.getDate() + i * 2);
+        const updatedDate = new Date(createdDate);
+        updatedDate.setDate(updatedDate.getDate() + i);
+        fields.push(`CreatedAt: "${createdDate.toISOString()}"`);
+        fields.push(`UpdatedAt: "${updatedDate.toISOString()}"`);
+        lines.push(`\t{${fields.join(', ')}},`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+/** Convert a JS seed value string to Go format. */
+function jsToGoValue(jsValue, fieldType) {
+    if (fieldType === 'boolean') {
+        return jsValue; // true/false same in Go
+    }
+    // String/enum/date values come wrapped in single quotes — convert to double quotes
+    if (jsValue.startsWith("'") && jsValue.endsWith("'")) {
+        return `"${jsValue.slice(1, -1)}"`;
+    }
+    // Numbers pass through unchanged
+    return jsValue;
+}
+export { SEED_COUNT };

package/dist/toolkits/react-go/shared.d.ts

@@ -0,0 +1,6 @@
+/**
+ * React+Go Toolkit — Shared Components Generator
+ *
+ * Re-exports from the shared components module.
+ */
+export { generateSharedComponents } from '../shared/components.js';

package/dist/toolkits/react-go/shared.js

@@ -0,0 +1,6 @@
+/**
+ * React+Go Toolkit — Shared Components Generator
+ *
+ * Re-exports from the shared components module.
+ */
+export { generateSharedComponents } from '../shared/components.js';

package/dist/toolkits/react-go/static.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React+Go Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, .env.example, README.md, index.html, src/main.tsx, src/index.css
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateStaticFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/react-go/static.js

@@ -0,0 +1,122 @@
+/**
+ * React+Go Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, .env.example, README.md, index.html, src/main.tsx, src/index.css
+ */
+export function generateStaticFiles(model) {
+    return [
+        generateGitignore(),
+        generateEnvExample(),
+        generateReadme(model),
+        generateIndexHtml(model),
+        generateMainTsx(),
+        generateIndexCss(),
+    ];
+}
+function generateGitignore() {
+    return {
+        path: '.gitignore',
+        content: `node_modules
+dist
+.env
+*.local
+bin/
+*.exe
+`,
+    };
+}
+function generateEnvExample() {
+    return {
+        path: '.env.example',
+        content: `PORT=8080
+VITE_API_URL=http://localhost:8080
+`,
+    };
+}
+function generateReadme(model) {
+    let entitiesSection = '';
+    if (model.entities.length > 0) {
+        const entityLines = model.entities
+            .map((e) => {
+            const relCount = e.relationships.length;
+            const parts = [`${String(e.fields.length)} fields`];
+            if (relCount > 0) {
+                parts.push(`${String(relCount)} relationship${relCount > 1 ? 's' : ''}`);
+            }
+            return `- **${e.name}** (${e.icon}) — ${parts.join(', ')}`;
+        })
+            .join('\n');
+        entitiesSection = `\n## Entities\n\n${entityLines}\n`;
+    }
+    return {
+        path: 'README.md',
+        content: `# ${model.identity.name}
+
+${model.identity.description}
+${entitiesSection}
+## Getting Started
+
+\`\`\`bash
+npm install
+go run ./server
+npm run dev
+\`\`\`
+
+This starts both the Vite dev server and the Go server.
+
+- **Frontend:** http://localhost:5173
+- **API:** http://localhost:8080
+
+## Tech Stack
+
+- React 18 + TypeScript
+- Vite
+- Tailwind CSS
+- Go (net/http)
+- React Router v6
+`,
+    };
+}
+function generateIndexHtml(model) {
+    return {
+        path: 'index.html',
+        content: `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${model.identity.name}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`,
+    };
+}
+function generateMainTsx() {
+    return {
+        path: 'src/main.tsx',
+        content: `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`,
+    };
+}
+function generateIndexCss() {
+    return {
+        path: 'src/index.css',
+        content: `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/factory",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "AI-driven application scaffolder for the compilr-dev ecosystem",
   "type": "module",
   "main": "dist/index.js",