domain-driver 0.0.4 → 0.1.0

package/dist/commands/repository.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRepository = makeRepository;
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const REPOSITORY_ACTIONS = ['List', 'Create', 'Update', 'Delete', 'Show'];
+function renderRepository(action, name, feature) {
+    const typePath = (0, utils_1.resolveImport)(feature, `types/${name}.types`);
+    const schemaPath = (op) => (0, utils_1.resolveImport)(feature, `schemas/${op}${name}.schema`);
+    switch (action) {
+        case 'List':
+            return `import { ${name} } from '${typePath}';
+
+export class List${name}Repository {
+  async handle(): Promise<${name}[]> {
+    const response = await fetch('/api/${feature}');
+    if (!response.ok) throw new Error('Failed to fetch ${name} list');
+    return response.json();
+  }
+}
+`;
+        case 'Show':
+            return `import { ${name} } from '${typePath}';
+
+export class Show${name}Repository {
+  async handle(id: string): Promise<${name}> {
+    const response = await fetch(\`/api/${feature}/\${id}\`);
+    if (!response.ok) throw new Error('Failed to fetch ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Create':
+            return `import { ${name} } from '${typePath}';
+import { Create${name} } from '${schemaPath('Create')}';
+
+export class Create${name}Repository {
+  async handle(data: Create${name}): Promise<${name}> {
+    const response = await fetch('/api/${feature}', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+    if (!response.ok) throw new Error('Failed to create ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Update':
+            return `import { ${name} } from '${typePath}';
+import { Update${name} } from '${schemaPath('Update')}';
+
+export class Update${name}Repository {
+  async handle(id: string, data: Update${name}): Promise<${name}> {
+    const response = await fetch(\`/api/${feature}/\${id}\`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+    if (!response.ok) throw new Error('Failed to update ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Delete':
+            return `export class Delete${name}Repository {
+  async handle(id: string): Promise<void> {
+    const response = await fetch(\`/api/${feature}/\${id}\`, {
+      method: 'DELETE',
+    });
+    if (!response.ok) throw new Error('Failed to delete ${name}');
+  }
+}
+`;
+    }
+}
+function makeRepository(feature, name) {
+    const base = (0, utils_1.ensureFeatureExists)(feature, 'repositories');
+    for (const action of REPOSITORY_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.repository.ts`);
+        if ((0, utils_1.fileExists)(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.repository.ts" — already exists`);
+            continue;
+        }
+        (0, utils_1.writeFileSafe)(filePath, renderRepository(action, name, feature));
+    }
+    console.log(`✅ Repositories for "${name}" created at ${base}`);
+}

package/dist/commands/schema.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSchema = makeSchema;
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const SCHEMA_ACTIONS = ['Create', 'Update'];
+function renderSchema(action, name) {
+    switch (action) {
+        case 'Create':
+            return `import { z } from 'zod';
+
+export const Create${name}Schema = z.object({
+  // add create fields here
+});
+
+export type Create${name} = z.infer<typeof Create${name}Schema>;
+`;
+        case 'Update':
+            return `import { z } from 'zod';
+
+export const Update${name}Schema = z.object({
+  id: z.string(),
+  // add update fields here
+});
+
+export type Update${name} = z.infer<typeof Update${name}Schema>;
+`;
+    }
+}
+function makeSchema(feature, name) {
+    const base = (0, utils_1.ensureFeatureExists)(feature, 'schemas');
+    for (const action of SCHEMA_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.schema.ts`);
+        if ((0, utils_1.fileExists)(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.schema.ts" — already exists`);
+            continue;
+        }
+        (0, utils_1.writeFileSafe)(filePath, renderSchema(action, name));
+    }
+    console.log(`✅ Schemas for "${name}" created at ${base}`);
+}

package/dist/commands/service.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeService = makeService;
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const SERVICE_ACTIONS = ['List', 'Create', 'Update', 'Delete', 'Show'];
+function renderService(action, name, feature) {
+    const typePath = (0, utils_1.resolveImport)(feature, `types/${name}.types`);
+    const repoPath = (op) => (0, utils_1.resolveImport)(feature, `repositories/${op}${name}.repository`);
+    const schemaPath = (op) => (0, utils_1.resolveImport)(feature, `schemas/${op}${name}.schema`);
+    switch (action) {
+        case 'List':
+            return `import { ${name} } from '${typePath}';
+import { List${name}Repository } from '${repoPath('List')}';
+
+const repository = new List${name}Repository();
+
+export class List${name}Service {
+  async handle(): Promise<${name}[]> {
+    return repository.handle();
+  }
+}
+`;
+        case 'Show':
+            return `import { ${name} } from '${typePath}';
+import { Show${name}Repository } from '${repoPath('Show')}';
+
+const repository = new Show${name}Repository();
+
+export class Show${name}Service {
+  async handle(id: string): Promise<${name}> {
+    return repository.handle(id);
+  }
+}
+`;
+        case 'Create':
+            return `import { ${name} } from '${typePath}';
+import { Create${name} } from '${schemaPath('Create')}';
+import { Create${name}Repository } from '${repoPath('Create')}';
+
+const repository = new Create${name}Repository();
+
+export class Create${name}Service {
+  async handle(data: Create${name}): Promise<${name}> {
+    return repository.handle(data);
+  }
+}
+`;
+        case 'Update':
+            return `import { ${name} } from '${typePath}';
+import { Update${name} } from '${schemaPath('Update')}';
+import { Update${name}Repository } from '${repoPath('Update')}';
+
+const repository = new Update${name}Repository();
+
+export class Update${name}Service {
+  async handle(id: string, data: Update${name}): Promise<${name}> {
+    return repository.handle(id, data);
+  }
+}
+`;
+        case 'Delete':
+            return `import { Delete${name}Repository } from '${repoPath('Delete')}';
+
+const repository = new Delete${name}Repository();
+
+export class Delete${name}Service {
+  async handle(id: string): Promise<void> {
+    return repository.handle(id);
+  }
+}
+`;
+    }
+}
+function makeService(feature, name) {
+    const base = (0, utils_1.ensureFeatureExists)(feature, 'services');
+    for (const action of SERVICE_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.service.ts`);
+        if ((0, utils_1.fileExists)(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.service.ts" — already exists`);
+            continue;
+        }
+        (0, utils_1.writeFileSafe)(filePath, renderService(action, name, feature));
+    }
+    console.log(`✅ Services for "${name}" created at ${base}`);
+}

package/dist/commands/types.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTypes = makeTypes;
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+function renderTypes(name) {
+    return `export interface ${name} {
+  id: string;
+  // add ${name} fields here
+  createdAt: string;
+  updatedAt: string;
+}
+`;
+}
+function makeTypes(feature, name) {
+    const base = (0, utils_1.ensureFeatureExists)(feature, 'types');
+    const filePath = path.join(base, `${name}.types.ts`);
+    if ((0, utils_1.fileExists)(filePath)) {
+        console.warn(`⚠️  Skipping "${name}.types.ts" — already exists`);
+        return;
+    }
+    (0, utils_1.writeFileSafe)(filePath, renderTypes(name));
+    console.log(`✅ Types for "${name}" created at ${filePath}`);
+}

package/dist/index.js

@@ -1,16 +1,125 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
 const feature_1 = require("./commands/feature");
-const [, , command, name] = process.argv;
-if (!command || !name) {
-    console.error('Usage: domain-driver make:feature <name>');
-    process.exit(1);
-}
-if (command === 'make:feature') {
-    (0, feature_1.makeFeature)(name);
-}
-else {
-    console.error(`Unknown command: ${command}`);
-    process.exit(1);
-}
+const component_1 = require("./commands/component");
+const hook_1 = require("./commands/hook");
+const service_1 = require("./commands/service");
+const schema_1 = require("./commands/schema");
+const repository_1 = require("./commands/repository");
+const container_1 = require("./commands/container");
+const types_1 = require("./commands/types");
+const program = new commander_1.Command();
+program
+    .name('domain-driver')
+    .description('CLI scaffolding tool for domain-driven development in Next.js')
+    .version('0.1.0');
+program
+    .command('make:feature <name>')
+    .description('Scaffold a full feature folder structure')
+    .option('-a, --all', 'Scaffold all files inside each folder')
+    .action(async (name, options) => {
+    try {
+        await (0, feature_1.makeFeature)(name, options.all ?? false);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:component <feature> <name>')
+    .description('Scaffold a component inside an existing feature')
+    .argument('[type]', 'Component type: client or server', 'client')
+    .action((feature, name, type) => {
+    try {
+        const componentType = type === 'server' ? 'server' : 'client';
+        (0, component_1.makeComponent)(feature, name, componentType);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:container <feature> <name>')
+    .description('Scaffold a smart container component inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, container_1.makeContainer)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:hook <feature> <name>')
+    .description('Scaffold a custom hook inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, hook_1.makeHook)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:service <feature> <name>')
+    .description('Scaffold single-responsibility service files inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, service_1.makeService)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:repository <feature> <name>')
+    .description('Scaffold single-responsibility repository files inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, repository_1.makeRepository)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:schema <feature> <name>')
+    .description('Scaffold Zod schemas for create and update operations')
+    .action((feature, name) => {
+    try {
+        (0, schema_1.makeSchema)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:types <feature> <name>')
+    .description('Scaffold a types file inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, types_1.makeTypes)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/utils.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPascalCase = toPascalCase;
+exports.featureBasePath = featureBasePath;
+exports.ensureFeatureExists = ensureFeatureExists;
+exports.writeFileSafe = writeFileSafe;
+exports.mkdirSafe = mkdirSafe;
+exports.fileExists = fileExists;
+exports.detectAlias = detectAlias;
+exports.resetAliasCache = resetAliasCache;
+exports.resolveImport = resolveImport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function toPascalCase(name) {
+    return name
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+function featureBasePath(feature) {
+    return path.join(process.cwd(), 'app', feature);
+}
+function ensureFeatureExists(feature, subdir) {
+    const base = path.join(featureBasePath(feature), subdir);
+    if (!fs.existsSync(base)) {
+        throw new Error(`Feature "${feature}" does not exist. Run: domain-driver make:feature ${feature}`);
+    }
+    return base;
+}
+function writeFileSafe(filePath, content) {
+    try {
+        fs.writeFileSync(filePath, content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to write ${filePath}: ${message}`);
+    }
+}
+function mkdirSafe(dirPath) {
+    try {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to create directory ${dirPath}: ${message}`);
+    }
+}
+function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+let cachedAlias;
+function detectAlias() {
+    if (cachedAlias)
+        return cachedAlias;
+    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        cachedAlias = { alias: null, appDir: 'app' };
+        return cachedAlias;
+    }
+    try {
+        const raw = fs.readFileSync(tsconfigPath, 'utf-8');
+        const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const tsconfig = JSON.parse(stripped);
+        const paths = tsconfig?.compilerOptions?.paths;
+        if (paths) {
+            for (const [key, values] of Object.entries(paths)) {
+                const targets = values;
+                const hasAppMapping = targets.some((v) => v === './app/*' || v === 'app/*' || v === './src/app/*' || v === 'src/app/*');
+                if (hasAppMapping && key.endsWith('/*')) {
+                    const prefix = key.slice(0, -1);
+                    const appDir = targets[0].replace('/*', '').replace('./', '');
+                    cachedAlias = { alias: prefix, appDir };
+                    return cachedAlias;
+                }
+                const hasSrcMapping = targets.some((v) => v === './src/*' || v === 'src/*' || v === './*');
+                if (hasSrcMapping && key.endsWith('/*')) {
+                    const prefix = key.slice(0, -1);
+                    cachedAlias = { alias: prefix, appDir: 'app' };
+                    return cachedAlias;
+                }
+            }
+        }
+    }
+    catch {
+        // tsconfig parse failed, fall back to relative imports
+    }
+    cachedAlias = { alias: null, appDir: 'app' };
+    return cachedAlias;
+}
+function resetAliasCache() {
+    cachedAlias = undefined;
+}
+function resolveImport(fromFeature, relativePath, fromRoot = false) {
+    const { alias } = detectAlias();
+    if (alias) {
+        return `${alias}app/${fromFeature}/${relativePath}`;
+    }
+    return fromRoot ? `./${relativePath}` : `../${relativePath}`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "domain-driver",
-  "version": "0.0.4",
-  "description": "",
+  "version": "0.1.0",
+  "description": "CLI scaffolding tool for domain-driven development in Next.js",
   "main": "index.js",
   "bin": {
     "domain-driver": "./dist/index.js"
@@ -11,17 +11,18 @@
     "url": "https://github.com/IsaacHatilima/domain-driver"
   },
   "scripts": {
-    "build": "npx tsc",
-    "dev": "ts-node src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "test": "vitest run"
   },
   "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "author": "Isaac Hatilima",
+  "license": "MIT",
   "devDependencies": {
-    "@types/node": "^25.4.0"
+    "@types/node": "^25.4.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
   },
   "dependencies": {
-    "typescript": "^5.9.3"
+    "commander": "^14.0.3"
   }
 }