micro-generate 1.3.11 → 1.3.12

package/dist/cli/generators/init-generator.js

@@ -1,6 +1,17 @@
 import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
+import { apiTemplate } from '../templates/project/api.template.js';
+import { sanitizeTemplate } from '../templates/project/sanitize.template.js';
+import { configTemplate } from '../templates/project/config.template.js';
+import { redisTemplate } from '../templates/project/redis.template.js';
+import { mongoTemplate } from '../templates/project/mongo.template.js';
+import { mongoClientTemplate } from '../templates/project/mongoClient.template.js';
+import { mysqlClientTemplate } from '../templates/project/mysqlClient.template.js';
+import { getIndexTemplate } from '../templates/project/index.template.js';
+import { featuresIndexTemplate } from '../templates/project/featuresIndex.template.js';
+import { tsConfigTemplate } from '../templates/project/tsconfig.template.js';
+import { skillTemplate } from '../templates/project/skill.template.js';
 export const generateInit = async (options) => {
     const { name, useMongo = true, useRedis = true, useMySQL = false, dbNames = [], mysqlDbNames = [] } = options;
     const projectPath = path.join(process.cwd(), name);
@@ -27,591 +38,31 @@ export const generateInit = async (options) => {
         await fs.ensureDir(dir);
     }
     // 2. src/services/api.ts
-    const apiContent = `import axios from 'axios';
-
-export default class ApiClient {
-    public baseUrl: string;
-    public timeout: number;
-
-    constructor(url: string) {
-        this.baseUrl = url;
-        this.timeout = 600000; // 10 minutes
-    }
-
-    private getHeaders(token?: string) {
-        const headers: Record<string, string> = {
-            'Content-Type': 'application/json',
-        };
-        if (token) {
-            headers['Authorization'] = token;
-        }
-        return headers;
-    }
-
-    protected async get<T>(endpoint: string, params: Record<string, any> = {}, token?: string): Promise<T> {
-        const response = await axios.get(\`\${this.baseUrl}/\${endpoint}\`, {
-            headers: this.getHeaders(token),
-            params,
-            timeout: this.timeout,
-        });
-        return response.data;
-    }
-
-    protected async post<T>(endpoint: string, data: Record<string, any>, token?: string): Promise<T> {
-        const response = await axios.post(\`\${this.baseUrl}/\${endpoint}\`, data, {
-            headers: this.getHeaders(token),
-            timeout: this.timeout,
-        });
-        return response.data;
-    }
-}
-`;
-    await fs.writeFile(path.join(projectPath, 'src', 'services', 'api.ts'), apiContent);
+    await fs.writeFile(path.join(projectPath, 'src', 'services', 'api.ts'), apiTemplate);
     // 3. src/utils/sanitize.ts
-    const sanitizeContent = `import DOMPurify from 'dompurify';
-import { JSDOM } from 'jsdom';
-
-const window = new JSDOM('').window;
-const purify = DOMPurify(window as any);
-
-export function sanitize(dirty: string): string {
-    return purify.sanitize(dirty, { ALLOWED_TAGS: [], ALLOWED_ATTR: [] });
-}
-`;
-    await fs.writeFile(path.join(projectPath, 'src', 'utils', 'sanitize.ts'), sanitizeContent);
+    await fs.writeFile(path.join(projectPath, 'src', 'utils', 'sanitize.ts'), sanitizeTemplate);
     // 4. src/utils/config.ts
-    const configUtilContent = `import * as dotenv from 'dotenv';
-dotenv.config();
-
-export function getEnv(name: string): string {
-    const value = process.env[name];
-    if (!value) {
-        throw new Error(\`❌ Variable de entorno requerida no definida: \${name}\`);
-    }
-    return value;
-}
-`;
-    await fs.writeFile(path.join(projectPath, 'src', 'utils', 'config.ts'), configUtilContent);
+    await fs.writeFile(path.join(projectPath, 'src', 'utils', 'config.ts'), configTemplate);
     // 5. src/database/redis.ts
     if (useRedis) {
-        const redisContent = `import { Redis, RedisOptions } from 'ioredis';
-import { logger } from 'micro-generate';
-
-export class RedisConnector {
-    private defaultClient: Redis | null = null;
-    private clients: Map<number, Redis> = new Map();
-    private options: RedisOptions = {};
-    private defaultDb: number = 0;
-    private host?: string;
-
-    constructor(optionsOrUrl: RedisOptions | string) {
-        if (typeof optionsOrUrl === 'string') {
-            this.options = {
-                retryStrategy: (times: number) => Math.min(times * 50, 2000)
-            };
-            this.host = undefined; 
-            (this as any).url = optionsOrUrl; 
-        } else {
-            this.options = {
-                retryStrategy: (times: number) => Math.min(times * 50, 2000),
-                ...optionsOrUrl
-            };
-            this.defaultDb = optionsOrUrl.db || 0;
-            this.host = optionsOrUrl.host;
-        }
-    }
-
-    async connect(): Promise<void> {
-        if (this.defaultClient) {
-            logger.info('Redis default client already connected');
-            return;
-        }
-        try {
-            this.defaultClient = this.createClient(this.defaultDb);
-            this.clients.set(this.defaultDb, this.defaultClient);
-            await this.defaultClient.connect();
-        } catch (error) {
-            logger.error(\`Failed to connect to Redis: \${error}\`);
-            throw error;
-        }
-    }
-
-    private createClient(db: number): Redis {
-        let client: Redis;
-        const url = (this as any).url;
-
-        if (url) {
-             client = new Redis(url, { ...this.options, db, lazyConnect: true });
-        } else {
-            client = new Redis({ ...this.options, db, lazyConnect: true });
-        }
-
-        client.on('connect', () => logger.info(\`🔴 Redis connected to db \${db}\`));
-        client.on('error', (err) => logger.error(\`Redis error on db \${db}: \${err}\`));
-        return client;
-    }
-
-    async disconnect(): Promise<void> {
-        const disconnectPromises: Promise<void>[] = [];
-        for (const [db, client] of this.clients.entries()) {
-            disconnectPromises.push(client.quit().then(() => {}).catch(() => client.disconnect()));
-        }
-        await Promise.all(disconnectPromises);
-        this.clients.clear();
-        this.defaultClient = null;
-    }
-
-    getClient(): Redis {
-        if (!this.defaultClient) throw new Error('Redis not connected');
-        return this.defaultClient;
-    }
-
-    async getConnection(db: number): Promise<Redis> {
-        if (db === this.defaultDb) {
-            if (!this.defaultClient) await this.connect();
-            return this.defaultClient!;
-        }
-        if (this.clients.has(db)) {
-            const client = this.clients.get(db)!;
-            if (client.status === 'wait') await client.connect();
-            return client;
-        }
-        const newClient = this.createClient(db);
-        this.clients.set(db, newClient);
-        await newClient.connect();
-        return newClient;
-    }
-}
-
-export let redisConnectorInstance: RedisConnector | null = null;
-
-export const setRedisConnectorInstance = (connector: RedisConnector) => {
-    redisConnectorInstance = connector;
-};
-
-export const getRedisConnector = (): RedisConnector => {
-    if (!redisConnectorInstance) {
-        throw new Error('Redis connector not initialized.');
-    }
-    return redisConnectorInstance;
-};
-
-export const createRedisRepository = (getDb: () => (Redis | Promise<Redis>), keyPrefix: string) => {
-    const promiseFunct = (err: any, response: any, resolve: (value: any) => void, reject: (reason?: any) => void) => {
-        if (err) reject(err);
-        else resolve(response);
-    };
-
-    const resolveDb = async (): Promise<Redis> => {
-        const dbOrPromise = getDb();
-        return dbOrPromise instanceof Promise ? await dbOrPromise : dbOrPromise;
-    };
-
-    return {
-        find: async (_id: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.get(_id, (err, response) => promiseFunct(err, response, resolve, reject));
-            });
-        },
-        saveTTL: async (_id: string, _data: any, ttl: number) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.set(_id, _data, (err, response) => {
-                    if (err) reject(err);
-                    else {
-                        db.expire(_id, ttl);
-                        resolve(response);
-                    }
-                });
-            });
-        },
-        findKeys: async (_id: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.keys(_id, (err, response) => {
-                    if (response && response.length > 0) {
-                        promiseFunct(err, response, resolve, reject);
-                    } else {
-                        promiseFunct(null, ['No genero datos'], resolve, reject);
-                    }
-                });
-            });
-        },
-
-        findAll: async () => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.keys(keyPrefix + '*', (err, response) => {
-                    if (response && response.length > 0) {
-                        db.mget(response, (err, response2) => {
-                            promiseFunct(err, response2, resolve, reject);
-                        });
-                    } else {
-                        promiseFunct(null, ['No genero datos'], resolve, reject);
-                    }
-                });
-            });
-        },
-
-        save: async (_id: string, _data: any) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.set(_id, _data, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        addTTL: async (_id: string, ttl: number) => {
-            const db = await resolveDb();
-            return db.expire(_id, ttl);
-        },
-
-        getTTL: async (_id: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.ttl(_id, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        incr: async (_id: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.incr(_id, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        sadd: async (_id: string, _data: any) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.sadd(_id, _data, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        sismember: async (_id: string, _data: any) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.sismember(_id, _data, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        sisremove: async (_id: string, _data: any) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.srem(_id, _data, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        smembers: async (_id: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.smembers(_id, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        },
-
-        sdiff: async (_id: string) => {
-            return new Promise((resolve, reject) => {
-                 console.log('sdiff called with', _id);
-                 resolve([]); 
-            });
-        },
-
-        clear: async (key: string) => {
-            const db = await resolveDb();
-            return new Promise((resolve, reject) => {
-                db.del(key, (err, response) => {
-                    promiseFunct(err, response, resolve, reject);
-                });
-            });
-        }
-    };
-};
-
-export function createRedisConnector(urlOrOptions: string | RedisOptions): RedisConnector {
-    const connector = typeof urlOrOptions === 'string' 
-        ? new RedisConnector(urlOrOptions) 
-        : new RedisConnector(urlOrOptions);
-    setRedisConnectorInstance(connector);
-    return connector;
-}
-`;
-        await fs.writeFile(path.join(projectPath, 'src', 'database', 'redis.ts'), redisContent);
+        await fs.writeFile(path.join(projectPath, 'src', 'database', 'redis.ts'), redisTemplate);
     }
     // src/database/mongo.ts
     if (useMongo) {
-        const mongoContent = `import mongoose from 'mongoose';
-
-export interface MongoDBOptions {
-    uri: string;
-    options?: mongoose.ConnectOptions;
-    secondaryConnections?: Record<string, string>;
-}
-
-export class MongoDBConnector {
-    private uri: string;
-    private options: mongoose.ConnectOptions;
-    private secondaryConnectionsConfig: Record<string, string> = {};
-    private isConnected = false;
-    private secondaryConnections: Map<string, mongoose.Connection> = new Map();
-
-    constructor(config: MongoDBOptions) {
-        this.uri = config.uri;
-        this.options = config.options || {};
-        this.secondaryConnectionsConfig = config.secondaryConnections || {};
-    }
-
-    async connect(): Promise<void> {
-        if (this.isConnected) return;
-        try {
-            await mongoose.connect(this.uri, this.options);
-            this.isConnected = true;
-            console.log('✅ Primary MongoDB connected');
-
-            const secondaryPromises = Object.entries(this.secondaryConnectionsConfig).map(async ([name, uri]) => {
-                const conn = mongoose.createConnection(uri, this.options);
-                await conn.asPromise();
-                this.secondaryConnections.set(name, conn);
-                console.log(\`✅ Secondary MongoDB '\${name}' connected\`);
-            });
-            await Promise.all(secondaryPromises);
-        } catch (error) {
-            console.error('MongoDB connection error:', error);
-            throw error;
-        }
-    }
-
-    getSecondaryConnection(name: string): mongoose.Connection | undefined {
-        return this.secondaryConnections.get(name);
-    }
-}
-
-export function createMongoDBConnector(uri: string, secondaryConnections?: Record<string, string>): MongoDBConnector {
-    return new MongoDBConnector({ uri, secondaryConnections });
-}
-`;
-        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mongo.ts'), mongoContent);
+        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mongo.ts'), mongoTemplate);
         // src/database/mongo/client.ts (Legacy/Helper for Feature Generator)
-        const mongoClientContent = `import { MongoDBConnector } from '../mongo.js';
-import mongoose from 'mongoose';
-
-let mongoConnector: MongoDBConnector | null = null;
-
-export function setMongoDBConnector(connector: MongoDBConnector): void {
-    mongoConnector = connector;
-}
-
-export function getMongoDBConnector(): MongoDBConnector {
-    if (!mongoConnector) {
-        throw new Error('MongoDB connector not initialized. Make sure to connect in main.ts');
-    }
-    return mongoConnector;
-}
-
-export function getSecondaryConnection(name: string): mongoose.Connection | undefined {
-    return getMongoDBConnector().getSecondaryConnection(name);
-}
-`;
         await fs.ensureDir(path.join(projectPath, 'src', 'database', 'mongo'));
-        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mongo', 'client.ts'), mongoClientContent);
+        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mongo', 'client.ts'), mongoClientTemplate);
     }
     // 5.2 src/database/mysql/client.ts (Only if MySQL is enabled)
     if (useMySQL) {
-        const mysqlClientContent = `import { Sequelize } from 'sequelize';
-
-export interface MySQLConfig {
-    name?: string; // 'default' or others
-    database: string;
-    user: string;
-    password?: string;
-    host: string;
-    port: number;
-}
-
-export class MySQLConnector {
-    private connections: Map<string, Sequelize> = new Map();
-    private configs: MySQLConfig[];
-
-    constructor(configs: MySQLConfig[]) {
-        this.configs = configs;
-    }
-
-    public async connect(): Promise<void> {
-        for (const config of this.configs) {
-            const sequelize = new Sequelize(config.database, config.user, config.password, {
-                host: config.host,
-                port: config.port,
-                dialect: 'mysql',
-                logging: process.env.NODE_ENV === 'development' ? console.log : false,
-            });
-
-            try {
-                await sequelize.authenticate();
-                console.log(\`MySQL Connection (\${config.name || 'default'}) established successfully.\`);
-                this.connections.set(config.name || 'default', sequelize);
-            } catch (error) {
-                console.error(\`Unable to connect to the MySQL database (\${config.name || 'default'}):\`, error);
-            }
-        }
-    }
-
-    public getConnection(name: string = 'default'): Sequelize | undefined {
-        return this.connections.get(name);
-    }
-
-    public getSecondaryConnection(name: string): Sequelize | undefined {
-        return this.connections.get(name);
-    }
-}
-
-let mysqlConnector: MySQLConnector | null = null;
-
-export const setMySQLConnector = (connector: MySQLConnector) => {
-    mysqlConnector = connector;
-};
-
-export const getMySQLConnector = (): MySQLConnector => {
-    if (!mysqlConnector) throw new Error('MySQL Connector not initialized');
-    return mysqlConnector;
-};
-
-export const getSecondaryMySQLConnection = (name: string): Sequelize | undefined => {
-    return getMySQLConnector().getSecondaryConnection(name);
-};
-
-export default () => {
-    try {
-        return getMySQLConnector().getConnection('default');
-    } catch (e) {
-        // Fallback for single DB scenarios or before init
-        return null;
-    }
-};
-`;
-        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mysql', 'client.ts'), mysqlClientContent);
+        await fs.writeFile(path.join(projectPath, 'src', 'database', 'mysql', 'client.ts'), mysqlClientTemplate);
     }
     // 6. src/index.ts (Entry Point)
-    let indexImports = `import { MicroserviceServer } from 'micro-generate';
-import { typeDefs, resolvers } from './features/index.js';
-import * as dotenv from 'dotenv';\n`;
-    if (useMongo) {
-        indexImports += `import { createMongoDBConnector } from './database/mongo.js';\n`;
-        indexImports += `import { setMongoDBConnector } from './database/mongo/client.js';\n`;
-    }
-    if (useRedis) {
-        indexImports += `import { createRedisConnector } from './database/redis.js';\n`;
-    }
-    if (useMySQL) {
-        indexImports += `import { MySQLConnector, setMySQLConnector } from './database/mysql/client.js';\n`;
-    }
-    const indexConfig = [];
-    indexConfig.push(`port: parseInt(process.env.PORT || '4000')`);
-    if (useMongo) {
-        indexConfig.push(`mongoUri: process.env.MONGO_URI || ''`);
-    }
-    let redisConnectorInit = '';
-    if (useRedis) {
-        redisConnectorInit = `
-const redisConnector = createRedisConnector({
-    host: process.env.REDIS_HOST || 'localhost',
-    port: parseInt(process.env.REDIS_PORT || '6379'),
-    password: process.env.REDIS_PASSWORD,
-    db: parseInt(process.env.REDIS_DB || '0')
-});
-`;
-        indexConfig.push(`redisConnector: redisConnector`);
-    }
-    if (useMongo && dbNames.length > 0) {
-        const secondaryConfig = dbNames.map(name => {
-            const envVar = `MONGODB_URI_${name.toUpperCase().replace(/-/g, '_')}`;
-            return `${name}: process.env.${envVar} || ''`;
-        }).join(',\\n    ');
-        indexConfig.push(`secondaryConnections: {
-    ${secondaryConfig}
-  }`);
-    }
-    indexConfig.push(`playground: process.env.GRAPHQL_PLAYGROUND === 'true'`);
-    indexConfig.push(`introspection: process.env.GRAPHQL_INTROSPECTION === 'true'`);
-    indexConfig.push(`graphqlPath: process.env.GRAPHQL_PATH || '/graphql'`);
-    const indexContent = `${indexImports}
-dotenv.config();
-
-${redisConnectorInit}
-
-const server = new MicroserviceServer({
-  ${indexConfig.join(',\n  ')},
-  typeDefs,
-  resolvers,
-});
-
-${useMySQL ? `
-// MySQL Configuration
-const mysqlConfigs = [
-    {
-        name: 'default',
-        database: process.env.MYSQL_DB || '',
-        user: process.env.MYSQL_USER || '',
-        password: process.env.MYSQL_PASSWORD,
-        host: process.env.MYSQL_HOST || 'localhost',
-        port: parseInt(process.env.MYSQL_PORT || '3306'),
-    },
-    ${mysqlDbNames.map(name => {
-        const upper = name.toUpperCase().replace(/-/g, '_');
-        return `{
-        name: '${name}',
-        database: process.env.MYSQL_DB_${upper} || '',
-        user: process.env.MYSQL_USER_${upper} || '',
-        password: process.env.MYSQL_PASSWORD_${upper},
-        host: process.env.MYSQL_HOST_${upper} || 'localhost',
-        port: parseInt(process.env.MYSQL_PORT_${upper} || '3306'),
-    }`;
-    }).join(',\n    ')}
-];
-
-const mysqlConnector = new MySQLConnector(mysqlConfigs);
-setMySQLConnector(mysqlConnector);
-` : ''}
-
-server.start().then(async () => {
-    ${useMongo ? `if (server.getMongoDBConnector()) {
-        setMongoDBConnector(server.getMongoDBConnector()! as any);
-    }` : ''}
-    
-    ${useRedis ? `await redisConnector.connect();` : ''}
-    
-    ${useMySQL ? `await mysqlConnector.connect();` : ''}
-
-    console.log('Server initialized');
-});
-
-const gracefulShutdown = async () => {
-    console.log('Starting graceful shutdown...');
-    await server.stop();
-    console.log('Graceful shutdown complete.');
-    process.exit(0);
-};
-
-process.on('SIGINT', gracefulShutdown);
-process.on('SIGTERM', gracefulShutdown);
-`;
+    const indexContent = getIndexTemplate({ useMongo, useRedis, useMySQL, dbNames, mysqlDbNames });
     await fs.writeFile(path.join(projectPath, 'src', 'index.ts'), indexContent);
     // 7. src/features/index.ts
-    const featuresIndexContent = `export const typeDefs = ['type Query { status: String }'];
-export const resolvers = [{ Query: { status: () => 'Functioning' } }];
-`;
-    await fs.writeFile(path.join(projectPath, 'src', 'features', 'index.ts'), featuresIndexContent);
+    await fs.writeFile(path.join(projectPath, 'src', 'features', 'index.ts'), featuresIndexTemplate);
     // 8. .env
     let envContent = `PORT=4000
 NODE_ENV=development
@@ -668,16 +119,20 @@ LOG_LEVEL=info
         'jsdom': '^24.0.0',
         'zod': '^3.22.4',
         'graphql': '^16.12.0',
+        "express": "^4.18.2",
         '@apollo/server': '^5.2.0',
         '@as-integrations/express4': '^1.0.0',
         'pino': '^10.2.0',
         'pino-pretty': '^10.3.1'
     };
+    if (useMongo) {
+        dependencies['mongoose'] = '^8.1.1';
+    }
     if (useRedis) {
         dependencies['ioredis'] = '^5.3.2';
     }
     if (useMySQL) {
-        dependencies['sequelize'] = '^6.37.0';
+        dependencies['sequelize'] = '^6.37.8';
         dependencies['mysql2'] = '^3.9.0';
     }
     const packageJson = {
@@ -696,95 +151,22 @@ LOG_LEVEL=info
             '@types/dompurify': '^3.0.0',
             '@types/jsdom': '^21.1.0',
             '@types/node': '^20.11.0',
+            "@types/express": "^4.17.21",
             'tsx': '^4.7.0',
             'typescript': '^5.3.3',
             'pino-pretty': '^10.3.1'
+        },
+        "overrides": {
+            "uuid": "^11.1.1"
         }
     };
     await fs.writeFile(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2));
     // 10. tsconfig.json
-    const tsConfigContent = `{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.spec.ts"]
-}
-`;
-    await fs.writeFile(path.join(projectPath, 'tsconfig.json'), tsConfigContent);
+    await fs.writeFile(path.join(projectPath, 'tsconfig.json'), tsConfigTemplate);
     // 11. Add Antigravity Skill
     const skillPath = path.join(projectPath, '.agent', 'skills', 'micro-generate');
     await fs.ensureDir(skillPath);
-    const skillContent = `---
-name: micro-generate-helper
-description: Use the micro-generate CLI non-interactively to generate features, queries, and mutations.
----
-
-# Micro-Generate Skill
-
-This skill allows you to programmatically invoke the \`micro-generate\` CLI tools to create features, GraphQL operations, and initialize projects without user interaction.
-
-## Usage
-
-You should use the \`run_command\` tool to execute the \`npx micro-generate\` command directly. The CLI has been updated to support headless execution via flags.
-
-### 1. Generate Feature (\`feature\`)
-
-Creates a new feature (Vertical Slice) with optional database support.
-
-**Options:**
-- \`--name <string>\`: (Required) Name of the feature (e.g., "users", "orders").
-- \`--mongo\`: Enable MongoDB support.
-- \`--no-mongo\`: Disable MongoDB support.
-- \`--mysql\`: Enable MySQL support.
-- \`--no-mysql\`: Disable MySQL support.
-- \`--redis\`: Enable Redis support.
-- \`--no-redis\`: Disable Redis support.
-- \`--db-connection <string>\`: (Optional) Name of the specific MongoDB connection to use (for Multi-DB).
-- \`--mysql-connection <string>\`: (Optional) Name of the specific MySQL connection to use (for Multi-DB).
-
-**Example:**
-\`\`\`bash
-npx micro-generate feature --name "notifications" --mongo --redis --db-connection "logs_db"
-\`\`\`
-
-### 2. Generate GraphQL Query (\`query\`)
-
-Adds a new Query to an existing feature.
-
-**Options:**
-- \`--feature <string>\`: (Required) Name of the existing feature to add the query to.
-- \`--name <string>\`: (Required) Name of the query (e.g., "getUser").
-- \`--return-type <string>\`: (Optional) GraphQL return type (default: "String").
-
-**Example:**
-\`\`\`bash
-npx micro-generate query --feature "users" --name "getUserByEmail" --return-type "User"
-\`\`\`
-
-### 3. Generate GraphQL Mutation (\`mutation\`)
-
-Adds a new Mutation to an existing feature.
-
-**Options:**
-- \`--feature <string>\`: (Required) Name of the existing feature.
-- \`--name <string>\`: (Required) Name of the mutation (e.g., "updateUser").
-- \`--return-type <string>\`: (Optional) GraphQL return type (default: "String").
-
-**Example:**
-\`\`\`bash
-npx micro-generate mutation --feature "users" --name "banUser" --return-type "UserResponse"
-\`\`\`
-`;
-    await fs.writeFile(path.join(skillPath, 'SKILL.md'), skillContent);
+    await fs.writeFile(path.join(skillPath, 'SKILL.md'), skillTemplate);
     console.log(chalk.green("Project " + name + " initialized successfully in " + projectPath + "!"));
     if (useMongo)
         console.log(chalk.blue("- MongoDB: Enabled"));