@ronaldjdevfs/forge 1.0.1

package/skills/forge/templates/platform/di.ts.md

@@ -0,0 +1,18 @@
+```typescript
+// src/platform/di/Tokens.ts
+
+export const TOKENS = {
+  Logger: Symbol("Logger"),
+  Database: Symbol("Database"),
+  Cache: Symbol("Cache"),
+  EventBus: Symbol("EventBus"),
+} as const;
+```
+
+```typescript
+// src/platform/di/Container.ts
+// Configuración del contenedor de DI según el perfil activo
+// tsyringe: import { container } from "tsyringe";
+// awilix: import { createContainer } from "awilix";
+// manual: mantener un Map de registros
+```

package/skills/forge/templates/platform/http.ts.md

@@ -0,0 +1,29 @@
+```typescript
+// src/platform/http/Router.ts
+import { Router as ExpressRouter } from "express";
+
+const router = ExpressRouter();
+
+// registrar rutas globales (health, metrics, etc.)
+router.get("/health", (_req, res) => {
+  res.json({ status: "ok", timestamp: new Date().toISOString() });
+});
+
+export { router };
+```
+
+```typescript
+// src/platform/http/Error.middleware.ts
+import type { Request, Response, NextFunction } from "express";
+
+export function errorHandler(
+  err: Error,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+): void {
+  const status = (err as any).statusCode || 500;
+  const message = err.message || "Internal Server Error";
+  res.status(status).json({ error: message });
+}
+```

package/skills/forge/templates/platform/logger.ts.md

@@ -0,0 +1,38 @@
+```typescript
+// src/platform/logger/Logger.config.ts
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LoggerConfig {
+  level: LogLevel;
+  prettyPrint: boolean;
+}
+
+export function loadLoggerConfig(): LoggerConfig {
+  return {
+    level: (process.env.LOG_LEVEL as LogLevel) || "info",
+    prettyPrint: process.env.NODE_ENV !== "production",
+  };
+}
+```
+
+```typescript
+// src/platform/logger/Logger.service.ts
+import { loadLoggerConfig, type LogLevel } from "./Logger.config.js";
+
+const config = loadLoggerConfig();
+
+export const logger = {
+  debug: (msg: string, ...args: unknown[]) => log("debug", msg, ...args),
+  info: (msg: string, ...args: unknown[]) => log("info", msg, ...args),
+  warn: (msg: string, ...args: unknown[]) => log("warn", msg, ...args),
+  error: (msg: string, ...args: unknown[]) => log("error", msg, ...args),
+};
+
+function log(level: LogLevel, msg: string, ...args: unknown[]): void {
+  const levels: LogLevel[] = ["debug", "info", "warn", "error"];
+  if (levels.indexOf(level) < levels.indexOf(config.level)) return;
+  const timestamp = new Date().toISOString();
+  console[level](`[${timestamp}] [${level.toUpperCase()}] ${msg}`, ...args);
+}
+```

package/skills/forge/templates/platform/server.ts.md

@@ -0,0 +1,25 @@
+```typescript
+// src/platform/server/App.ts
+import "reflect-metadata";
+import express from "express";
+import { loadAppConfig } from "../config/App.config.js";
+
+const app = express();
+const config = loadAppConfig();
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+export { app, config };
+```
+
+```typescript
+// src/platform/server/Server.ts
+import { app, config } from "./App.js";
+
+export async function startServer(): Promise<void> {
+  app.listen(config.port, () => {
+    console.log(`Server running on port ${config.port}`);
+  });
+}
+```

package/skills/forge/templates/shared/contract.ts.md

@@ -0,0 +1,20 @@
+```typescript
+// src/shared/contracts/IPaginatedResponse.ts
+
+export interface IPaginatedResponse<T> {
+  data: T[];
+  total: number;
+  page: number;
+  limit: number;
+  totalPages: number;
+}
+```
+
+```typescript
+// src/shared/contracts/IResponse.ts
+
+export interface IResponse<T> {
+  data: T;
+  message?: string;
+}
+```

package/skills/forge/templates/shared/error.ts.md

@@ -0,0 +1,27 @@
+```typescript
+// src/shared/errors/NotFoundError.ts
+
+export class NotFoundError extends Error {
+  public readonly statusCode = 404;
+
+  constructor(message = "Resource not found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+```
+
+```typescript
+// src/shared/errors/ValidationError.ts
+
+export class ValidationError extends Error {
+  public readonly statusCode = 400;
+  public readonly details: Record<string, string[]>;
+
+  constructor(details: Record<string, string[]>) {
+    super("Validation failed");
+    this.name = "ValidationError";
+    this.details = details;
+  }
+}
+```

package/skills/forge/templates/shared/type.ts.md

@@ -0,0 +1,18 @@
+```typescript
+// src/shared/types/api.types.ts
+
+export type SortOrder = "asc" | "desc";
+
+export interface PaginationQuery {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  order?: SortOrder;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+```

package/skills/forge/templates/shared/util.ts.md

@@ -0,0 +1,23 @@
+```typescript
+// src/shared/utils/formatDate.ts
+
+export function formatDate(date: Date, locale = "es-ES"): string {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).format(date);
+}
+```
+
+```typescript
+// src/shared/utils/pagination.ts
+import type { PaginationQuery } from "../types/api.types.js";
+
+export function buildPagination(query: PaginationQuery) {
+  const page = Math.max(1, query.page || 1);
+  const limit = Math.min(100, Math.max(1, query.limit || 10));
+  const skip = (page - 1) * limit;
+  return { page, limit, skip };
+}
+```

package/src/cli.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+import { copyFileSync, mkdirSync, existsSync, readdirSync, statSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname, relative } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_DIR = join(__dirname, "..");
+const SKILL_SRC = join(PKG_DIR, "skills", "forge");
+
+function getTargetDir(global) {
+  if (global) {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home) {
+      console.error("[ERROR] No se pudo determinar el HOME del usuario");
+      process.exit(1);
+    }
+    return join(home, ".config", "opencode", "skills", "forge");
+  }
+  return join(process.cwd(), ".opencode", "skills", "forge");
+}
+
+function getConfigDir(global) {
+  if (global) {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    return join(home, ".config", "opencode");
+  }
+  return join(process.cwd(), ".opencode");
+}
+
+function copyRecursive(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function detectPM(configDir) {
+  if (existsSync(join(configDir, "pnpm-lock.yaml")) || existsSync(join(process.cwd(), "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(configDir, "bun.lock")) || existsSync(join(configDir, "bun.lockb"))) return "bun";
+  return "npm";
+}
+
+function ensureDependencies(configDir) {
+  const pkgPath = join(configDir, "package.json");
+  let pkg = {};
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    } catch {
+      pkg = {};
+    }
+  }
+  if (!pkg.dependencies) pkg.dependencies = {};
+  if (!pkg.dependencies["@opencode-ai/plugin"]) {
+    pkg.dependencies["@opencode-ai/plugin"] = "1.17.9";
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    console.log(`  ✓ Actualizado ${relative(process.cwd(), pkgPath)}`);
+  }
+
+  const pm = detectPM(configDir);
+  const order = { pnpm: ["npm", "bun"], npm: ["bun", "pnpm"], bun: ["npm", "pnpm"] };
+
+  function runPM(bin) {
+    execSync(`${bin} install`, { cwd: configDir, stdio: "pipe" });
+  }
+
+  try {
+    runPM(pm);
+    console.log(`  ✓ Dependencias instaladas (${pm})`);
+  } catch {
+    for (const fallback of order[pm]) {
+      try {
+        runPM(fallback);
+        console.log(`  ✓ Dependencias instaladas (${fallback})`);
+        return;
+      } catch {}
+    }
+    console.warn("  ⚠ No se pudieron instalar dependencias. Ejecuta 'pnpm install' | 'npm install' manualmente en " + configDir);
+  }
+}
+
+const COMMANDS = [
+  { name: "forge-forge",   desc: "Forge — inicializar proyecto arquitectónicamente" },
+  { name: "forge-cast",    desc: "Cast — crear un nuevo feature hexagonal desde cero" },
+  { name: "forge-inspect", desc: "Inspect — inspeccionar la conformidad arquitectónica" },
+  { name: "forge-relocate",desc: "Relocate — migrar feature legacy a la nueva estructura" },
+  { name: "forge-reforge", desc: "Reforge — refactorizar la arquitectura de un feature" },
+  { name: "forge-quench",  desc: "Quench — verificar reglas arquitectónicas del proyecto" },
+  { name: "forge-temper",  desc: "Temper — endurecer la arquitectura (DI, seguridad)" },
+  { name: "forge-chain",   desc: "Chain — analizar cadena de dependencias entre features" },
+  { name: "forge-inscribe",desc: "Inscribe — generar y mantener ARCHITECTURE.md" },
+  { name: "forge-smelt",   desc: "Smelt — extraer código reutilizable a shared/" },
+];
+
+function generateCommands(configDir) {
+  const cmdsDir = join(configDir, "commands");
+  mkdirSync(cmdsDir, { recursive: true });
+  for (const cmd of COMMANDS) {
+    const sub = cmd.name.replace("forge-", "");
+    const content = [
+      "---",
+      `description: ${cmd.desc}`,
+      "agent: build",
+      "---",
+      "",
+      `Ejecuta el subcomando ${sub} de Forge con los argumentos: $ARGUMENTS`,
+      "",
+    ].join("\n");
+    writeFileSync(join(cmdsDir, `${cmd.name}.md`), content);
+  }
+  console.log(`  ✓ Comandos /forge-* generados en .opencode/commands/`);
+}
+
+function printHelp() {
+  console.log(`
+Forge — Architecture OS
+
+USO
+  forge install                    Instalar skill en el proyecto actual
+  forge install --global           Instalar globalmente (~/.config/opencode/)
+  forge skills install             (alias del comando install)
+
+OPCIONES
+  -g, --global                     Instalar en ~/.config/opencode/skills/forge/
+  -h, --help                       Mostrar esta ayuda
+`);
+}
+
+function install(global) {
+  if (!existsSync(SKILL_SRC)) {
+    console.error("[ERROR] No se encuentra skills/forge/ en el paquete. ¿Corrupto?");
+    process.exit(1);
+  }
+
+  const target = getTargetDir(global);
+  const configDir = getConfigDir(global);
+
+  console.log(`\n  Forge — Architecture OS`);
+  console.log(`  ${"=".repeat(40)}`);
+  console.log(`  Destino: ${target}\n`);
+
+  copyRecursive(SKILL_SRC, target);
+  console.log(`  ✓ Skill copiada a ${relative(process.cwd(), target)}`);
+  generateCommands(configDir);
+  ensureDependencies(configDir);
+  console.log(`\n  ✓ Forge instalado correctamente`);
+  console.log(`  ${"=".repeat(40)}\n`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const isHelp = args.includes("-h") || args.includes("--help");
+  const isGlobal = args.includes("-g") || args.includes("--global");
+
+  if (isHelp) {
+    printHelp();
+    return;
+  }
+
+  const subcommandIndex = args.indexOf("skills");
+  const command = subcommandIndex !== -1 ? args[subcommandIndex + 1] : args[0];
+
+  if (command === "install") {
+    install(isGlobal);
+  } else {
+    printHelp();
+    process.exit(1);
+  }
+}
+
+main();