@vitongovisk/forge 1.0.0

package/README.md

@@ -0,0 +1 @@
+"# forge" 

package/dist/cli.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+
+// src/bin/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import path4 from "path";
+import readline from "readline";
+import { execSync } from "child_process";
+
+// src/utils/file.ts
+import fs from "fs-extra";
+import path from "path";
+function fileExists(path11) {
+  return fs.existsSync(path11);
+}
+function readJson(path11) {
+  return fs.readJSONSync(path11);
+}
+async function writeFileSafe(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content);
+}
+
+// src/utils/template.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function loadTemplate(templateName) {
+  const cliPath = process.argv[1];
+  const distDir = path2.dirname(cliPath);
+  const templatePath = path2.join(distDir, "templates", templateName);
+  if (!fs2.existsSync(templatePath)) {
+    throw new Error(`Template n\xE3o encontrado: ${templatePath}`);
+  }
+  return fs2.readFileSync(templatePath, "utf-8");
+}
+
+// src/utils/config.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+var CONFIG_NAME = ".forge.json";
+var DATA_NAME = "forge.data.json";
+var STATE_NAME = "forge.state.json";
+function getConfigPath() {
+  return path3.join(process.cwd(), CONFIG_NAME);
+}
+function getDataPath() {
+  return path3.join(process.cwd(), DATA_NAME);
+}
+function getStatePath() {
+  return path3.join(process.cwd(), STATE_NAME);
+}
+function ensureForgeInitialized() {
+  const configPath = getConfigPath();
+  if (!fs3.existsSync(configPath)) {
+    console.error("\u274C Forge n\xE3o foi inicializado. Rode 'forge init'.");
+    process.exit(1);
+  }
+  return fs3.readJSONSync(configPath);
+}
+function ensureForgeData() {
+  const dataPath = getDataPath();
+  if (!fs3.existsSync(dataPath)) {
+    return { resources: [] };
+  }
+  return fs3.readJSONSync(dataPath);
+}
+function ensureForgeState() {
+  const statePath = getStatePath();
+  if (!fs3.existsSync(statePath)) {
+    return {
+      project: { architecture: "", lastSync: "" },
+      sync: { mode: "", lastRun: "" },
+      resources: []
+    };
+  }
+  return fs3.readJSONSync(statePath);
+}
+async function saveConfig(config) {
+  await fs3.writeJSON(getConfigPath(), config, { spaces: 2 });
+}
+async function saveData(data) {
+  await fs3.writeJSON(getDataPath(), data, { spaces: 2 });
+}
+async function saveState(state) {
+  await fs3.writeJSON(getStatePath(), state, { spaces: 2 });
+}
+
+// src/commands/init.ts
+function askUser(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const configPath = getConfigPath();
+  if (fileExists(configPath) && !options.overwrite) {
+    console.log("\u26A0\uFE0F Forge j\xE1 foi inicializado neste projeto.");
+    console.log("\u{1F449} Use --overwrite para reconfigurar.\n");
+    return;
+  }
+  if (fileExists(configPath) && options.overwrite) {
+    console.log("\u267B\uFE0F Reconfigurando projeto Forge...\n");
+  }
+  const packagePath = path4.join(cwd, "package.json");
+  if (!fileExists(packagePath)) {
+    console.error("\u274C package.json n\xE3o encontrado.");
+    process.exit(1);
+  }
+  const pkg = readJson(packagePath);
+  const hasAxios = !!pkg.dependencies?.axios;
+  const hasTanstack = !!pkg.dependencies?.["@tanstack/react-query"];
+  if (!hasAxios || !hasTanstack) {
+    console.log("\u274C Depend\xEAncias obrigat\xF3rias n\xE3o encontradas:\n");
+    if (!hasAxios) console.log("- axios");
+    if (!hasTanstack) console.log("- @tanstack/react-query");
+    console.log("\n\u26A0\uFE0F Essas depend\xEAncias s\xE3o obrigat\xF3rias para o Forge.");
+    const answer = await askUser("\nDeseja instalar automaticamente? (Y/N): ");
+    if (answer.toLowerCase() !== "y") {
+      console.log("\n\u274C Instala\xE7\xE3o cancelada.");
+      process.exit(1);
+    }
+    try {
+      console.log("\n\u{1F4E6} Instalando depend\xEAncias...\n");
+      execSync("npm install axios @tanstack/react-query", {
+        stdio: "inherit"
+      });
+      console.log("\n\u2705 Depend\xEAncias instaladas!\n");
+    } catch {
+      console.error("\n\u274C Erro ao instalar depend\xEAncias.");
+      process.exit(1);
+    }
+  }
+  const structureAnswer = await askUser(
+    "\nQual estrutura deseja usar?\n1 - Por camada\n2 - Por m\xF3dulo\nEscolha (1/2): "
+  );
+  const syncAnswer = await askUser(
+    "\nQual o modo de sincroniza\xE7\xE3o?\n1 - Autom\xE1tico (auto)\n2 - Manual (manual)\nEscolha (1/2): "
+  );
+  let config;
+  const syncMode = syncAnswer === "2" ? "manual" : "auto";
+  if (structureAnswer === "2") {
+    config = {
+      project: {
+        architecture: "module",
+        paths: {
+          api: "",
+          service: "",
+          types: "",
+          hooks: ""
+        },
+        modulePath: "src/modules",
+        apiFile: "src/modules/api/api-client.ts"
+      },
+      sync: {
+        mode: syncMode
+      }
+    };
+  } else {
+    config = {
+      project: {
+        architecture: "layer",
+        paths: {
+          api: "src/api",
+          service: "src/services",
+          types: "src/types",
+          hooks: "src/hooks"
+        },
+        modulePath: "",
+        apiFile: "src/api/api-client.ts"
+      },
+      sync: {
+        mode: syncMode
+      }
+    };
+  }
+  await saveConfig(config);
+  await saveData({ resources: [] });
+  await saveState({
+    project: {
+      architecture: config.project.architecture,
+      lastSync: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    sync: {
+      mode: config.sync.mode,
+      lastRun: ""
+    },
+    resources: []
+  });
+  let apiClientPath = "";
+  let apiTypesPath = "";
+  if (config.project.architecture === "module") {
+    apiClientPath = path4.join(cwd, "src/modules/api/api-client.ts");
+    apiTypesPath = path4.join(cwd, "src/modules/api/api.types.ts");
+  } else {
+    apiClientPath = path4.join(cwd, "src/api/api-client.ts");
+    apiTypesPath = path4.join(cwd, "src/types/api.types.ts");
+  }
+  if (fileExists(apiClientPath) && !options.overwrite) {
+    console.log("\u2139\uFE0F api-client.ts j\xE1 existe.");
+  } else {
+    const template = loadTemplate("api-client.ts.tpl");
+    await writeFileSafe(apiClientPath, template);
+    console.log(
+      fileExists(apiClientPath) ? "\u267B\uFE0F api-client.ts sobrescrito." : "\u{1F4E1} api-client.ts criado."
+    );
+  }
+  const globalTypesPath = path4.join(cwd, "src/types/global.types.ts");
+  const sharedTypesPath = path4.join(cwd, "src/types/shared.types.ts");
+  const globalTemplate = loadTemplate("global.types.tpl");
+  const apiTemplate = loadTemplate("api.types.tpl");
+  const sharedTemplate = loadTemplate("shared.types.tpl");
+  if (!fileExists(globalTypesPath) || options.overwrite) {
+    await writeFileSafe(globalTypesPath, globalTemplate);
+    console.log("\u{1F4E6} global.types criado.");
+  }
+  if (!fileExists(apiTypesPath) || options.overwrite) {
+    await writeFileSafe(apiTypesPath, apiTemplate);
+    console.log("\u{1F4E6} api.types criado.");
+  }
+  if (!fileExists(sharedTypesPath) || options.overwrite) {
+    await writeFileSafe(sharedTypesPath, sharedTemplate);
+    console.log("\u{1F4E6} shared.types criado.");
+  }
+  const apiUtilsPath = path4.join(cwd, "src/utils/api.utils.ts");
+  const apiUtilsTemplate = loadTemplate("api.utils.tpl");
+  if (!fileExists(apiUtilsPath) || options.overwrite) {
+    await writeFileSafe(apiUtilsPath, apiUtilsTemplate);
+    console.log("\u{1F9E0} api.utils criado.");
+  }
+  console.log("\n\u2705 Forge inicializado com sucesso!");
+}
+
+// src/commands/make-client.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+
+// src/utils/string.ts
+function toCamelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function toPascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toUpperSnake(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase();
+}
+
+// src/commands/make-client.ts
+async function makeClientCommand(name, options) {
+  const cwd = process.cwd();
+  const config = ensureForgeInitialized();
+  const apiClientPath = path5.join(cwd, config.project.apiFile);
+  if (!fs4.existsSync(apiClientPath)) {
+    console.error("\u274C api-client.ts n\xE3o encontrado.");
+    process.exit(1);
+  }
+  const camelName = toCamelCase(name);
+  const upperName = toUpperSnake(name);
+  const fileContent = await fs4.readFile(apiClientPath, "utf-8");
+  const alreadyExists = fileContent.includes(
+    `export const ${camelName}Api`
+  );
+  if (alreadyExists && !options.overwrite) {
+    console.log(
+      `\u26A0\uFE0F ${camelName}Api j\xE1 existe. Use --overwrite para recriar.`
+    );
+    return;
+  }
+  const templateRaw = loadTemplate("api-client-instance.tpl");
+  const template = templateRaw.replace(/{{camelName}}/g, camelName).replace(/{{upperName}}/g, upperName);
+  let newContent = fileContent;
+  if (alreadyExists) {
+    const regex = new RegExp(
+      `export const ${camelName}Api[\\s\\S]*?setupInterceptors\\(${camelName}Api.*?\\);`,
+      "g"
+    );
+    newContent = newContent.replace(regex, template);
+  } else {
+    newContent += `
+
+${template}
+`;
+  }
+  await writeFileSafe(apiClientPath, newContent);
+  console.log(
+    alreadyExists ? `\u267B\uFE0F ${camelName}Api sobrescrito.` : `\u2705 ${camelName}Api criado.`
+  );
+}
+
+// src/commands/make-api.ts
+import fs6 from "fs-extra";
+import path7 from "path";
+
+// src/commands/sync.ts
+import fs5 from "fs-extra";
+import path6 from "path";
+async function syncCommand() {
+  console.log("\u{1F504} Sincronizando projeto...");
+  const config = ensureForgeInitialized();
+  const data = ensureForgeData();
+  const state = ensureForgeState();
+  const cwd = process.cwd();
+  state.project.architecture = config.project.architecture;
+  state.project.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  state.sync.mode = config.sync.mode;
+  state.sync.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+  const observedResources = [];
+  for (const intendedResource of data.resources) {
+    const name = intendedResource.name;
+    let resourcePath = "";
+    if (config.project.architecture === "module") {
+      resourcePath = path6.join(config.project.modulePath, name);
+    }
+    const files = {
+      api: { exists: false, path: "" },
+      service: { exists: false, path: "" },
+      type: { exists: false, path: "" },
+      hooks: { exists: false, path: "" }
+    };
+    if (config.project.architecture === "module") {
+      files.api.path = path6.join(resourcePath, `${name}.api.ts`);
+      files.service.path = path6.join(resourcePath, `${name}.service.ts`);
+      files.type.path = path6.join(resourcePath, `${name}.type.ts`);
+      files.hooks.path = path6.join(resourcePath, `${name}.hooks.ts`);
+    } else {
+      files.api.path = path6.join(config.project.paths.api, `${name}.api.ts`);
+      files.service.path = path6.join(config.project.paths.service, `${name}.service.ts`);
+      files.type.path = path6.join(config.project.paths.types, `${name}.type.ts`);
+      files.hooks.path = path6.join(config.project.paths.hooks, `${name}.hooks.ts`);
+    }
+    files.api.exists = fileExists(path6.join(cwd, files.api.path));
+    files.service.exists = fileExists(path6.join(cwd, files.service.path));
+    files.type.exists = fileExists(path6.join(cwd, files.type.path));
+    files.hooks.exists = fileExists(path6.join(cwd, files.hooks.path));
+    const isMissingCritical = !files.api.exists || !files.service.exists;
+    const status = isMissingCritical ? "missing" : "active";
+    observedResources.push({
+      name,
+      status,
+      files,
+      methods: {}
+      // TODO: Implementar scan de métodos no futuro
+    });
+  }
+  const foundResources = /* @__PURE__ */ new Set();
+  if (config.project.architecture === "module") {
+    const moduleDir = path6.join(cwd, config.project.modulePath);
+    if (fs5.existsSync(moduleDir)) {
+      const dirs = fs5.readdirSync(moduleDir, { withFileTypes: true });
+      for (const dir of dirs) {
+        if (dir.isDirectory() && dir.name !== "api") {
+          foundResources.add(dir.name);
+        }
+      }
+    }
+  } else {
+    const pathsToScan = [
+      config.project.paths.api,
+      config.project.paths.service,
+      config.project.paths.types,
+      config.project.paths.hooks
+    ];
+    for (const p of pathsToScan) {
+      if (!p) continue;
+      const dir = path6.join(cwd, p);
+      if (fs5.existsSync(dir)) {
+        const files = fs5.readdirSync(dir);
+        for (const file of files) {
+          const match = file.match(/^(.+)\.(api|service|type|hooks)\.ts$/);
+          if (match) {
+            foundResources.add(match[1]);
+          }
+        }
+      }
+    }
+  }
+  for (const name of foundResources) {
+    if (!data.resources.find((r) => r.name === name)) {
+      let resourcePath = "";
+      if (config.project.architecture === "module") {
+        resourcePath = path6.join(config.project.modulePath, name);
+      }
+      const files = {
+        api: { exists: false, path: "" },
+        service: { exists: false, path: "" },
+        type: { exists: false, path: "" },
+        hooks: { exists: false, path: "" }
+      };
+      if (config.project.architecture === "module") {
+        files.api.path = path6.join(resourcePath, `${name}.api.ts`);
+        files.service.path = path6.join(resourcePath, `${name}.service.ts`);
+        files.type.path = path6.join(resourcePath, `${name}.type.ts`);
+        files.hooks.path = path6.join(resourcePath, `${name}.hooks.ts`);
+      } else {
+        files.api.path = path6.join(config.project.paths.api, `${name}.api.ts`);
+        files.service.path = path6.join(config.project.paths.service, `${name}.service.ts`);
+        files.type.path = path6.join(config.project.paths.types, `${name}.type.ts`);
+        files.hooks.path = path6.join(config.project.paths.hooks, `${name}.hooks.ts`);
+      }
+      files.api.exists = fileExists(path6.join(cwd, files.api.path));
+      files.service.exists = fileExists(path6.join(cwd, files.service.path));
+      files.type.exists = fileExists(path6.join(cwd, files.type.path));
+      files.hooks.exists = fileExists(path6.join(cwd, files.hooks.path));
+      observedResources.push({
+        name,
+        status: "orphan",
+        files,
+        methods: {}
+      });
+    }
+  }
+  state.resources = observedResources;
+  await saveState(state);
+  console.log("\n\u2705 Sync finalizado!");
+  const missing = state.resources.filter((r) => r.status === "missing");
+  if (missing.length > 0) {
+    console.log(`
+\u26A0\uFE0F  ${missing.length} recursos com arquivos faltando:`);
+    missing.forEach((r) => console.log(`   - ${r.name}`));
+  }
+  const orphans = state.resources.filter((r) => r.status === "orphan");
+  if (orphans.length > 0) {
+    console.log(`
+\u{1F47B} ${orphans.length} recursos \xF3rf\xE3os detectados no disco:`);
+    orphans.forEach((r) => console.log(`   - ${r.name}`));
+  }
+}
+
+// src/commands/make-api.ts
+async function makeApiCommand(name) {
+  const cwd = process.cwd();
+  const config = ensureForgeInitialized();
+  const pascalName = toPascalCase(name);
+  const camelName = toCamelCase(name);
+  let filePath = "";
+  let apiImportPath = "";
+  if (config.project.architecture === "layer") {
+    filePath = path7.join(cwd, config.project.paths.api, `${camelName}.api.ts`);
+    apiImportPath = "./api-client";
+  } else {
+    const moduleDir = path7.join(cwd, config.project.modulePath, camelName);
+    await fs6.ensureDir(moduleDir);
+    filePath = path7.join(moduleDir, `${camelName}.api.ts`);
+    apiImportPath = "@/api/api-client";
+  }
+  if (fs6.existsSync(filePath)) {
+    console.log("\u26A0\uFE0F API j\xE1 existe.");
+    return;
+  }
+  const templateRaw = loadTemplate("api.tpl");
+  const content = templateRaw.replace(/{{PascalName}}/g, pascalName).replace(/{{camelName}}/g, camelName).replace(/{{apiImportPath}}/g, apiImportPath);
+  await writeFileSafe(filePath, content);
+  console.log(`\u2705 ${pascalName}API criada com sucesso.`);
+  const data = ensureForgeData();
+  if (!data.resources.find((r) => r.name === name)) {
+    data.resources.push({ name, methods: [] });
+    await saveData(data);
+  }
+  if (config.sync.mode === "auto") {
+    await syncCommand();
+  }
+}
+
+// src/commands/make-service.ts
+import fs7 from "fs-extra";
+import path8 from "path";
+async function makeServiceCommand(name) {
+  const config = ensureForgeInitialized();
+  const cwd = process.cwd();
+  const pascalName = toPascalCase(name);
+  const camelName = toCamelCase(name);
+  let filePath = "";
+  let apiImportPath = "";
+  let utilsImportPath = "@/utils/api.utils";
+  if (config.project.architecture === "layer") {
+    filePath = path8.join(cwd, config.project.paths.service, `${camelName}.service.ts`);
+    apiImportPath = `@/api/${camelName}.api`;
+  } else {
+    const moduleDir = path8.join(cwd, config.project.modulePath, camelName);
+    await fs7.ensureDir(moduleDir);
+    filePath = path8.join(moduleDir, `${camelName}.service.ts`);
+    apiImportPath = `./${camelName}.api`;
+  }
+  if (fs7.existsSync(filePath)) {
+    console.log("\u26A0\uFE0F Service j\xE1 existe.");
+    return;
+  }
+  const templateRaw = loadTemplate("service.tpl");
+  const content = templateRaw.replace(/{{PascalName}}/g, pascalName).replace(/{{apiImportPath}}/g, apiImportPath).replace(/{{utilsImportPath}}/g, utilsImportPath);
+  await writeFileSafe(filePath, content);
+  console.log(`\u2705 ${pascalName}Service criado com sucesso.`);
+  const data = ensureForgeData();
+  if (!data.resources.find((r) => r.name === name)) {
+    data.resources.push({ name, methods: [] });
+    await saveData(data);
+  }
+  if (config.sync.mode === "auto") {
+    await syncCommand();
+  }
+}
+
+// src/commands/make-type.ts
+import fs8 from "fs-extra";
+import path9 from "path";
+async function makeTypeCommand(name, options) {
+  const config = ensureForgeInitialized();
+  const cwd = process.cwd();
+  const pascalName = toPascalCase(name);
+  const camelName = toCamelCase(name);
+  let filePath = "";
+  if (config.project.architecture === "layer") {
+    filePath = path9.join(cwd, config.project.paths.types, `${camelName}.type.ts`);
+  } else {
+    const moduleDir = path9.join(cwd, config.project.modulePath, camelName);
+    await fs8.ensureDir(moduleDir);
+    filePath = path9.join(moduleDir, `${camelName}.type.ts`);
+  }
+  if (fs8.existsSync(filePath)) {
+    console.log("\u26A0\uFE0F Type j\xE1 existe.");
+    return;
+  }
+  const template = loadTemplate("model-type.tpl");
+  let fields = `  id: string;`;
+  if (!!options.timestamps) {
+    fields += `
+  created_at: string;
+  updated_at: string;`;
+  }
+  const content = template.replace(/{{PascalName}}/g, pascalName).replace(/{{fields}}/g, fields);
+  await writeFileSafe(filePath, content);
+  console.log(`\u2705 ${pascalName} type criado com sucesso.`);
+  const data = ensureForgeData();
+  if (!data.resources.find((r) => r.name === name)) {
+    data.resources.push({ name, methods: [] });
+    await saveData(data);
+  }
+  if (config.sync.mode === "auto") {
+    await syncCommand();
+  }
+}
+
+// src/commands/make-resource.ts
+async function makeResourceCommand(name, options) {
+  const config = ensureForgeInitialized();
+  const pascal = toPascalCase(name);
+  console.log(`
+\u{1F680} Creating resource: ${pascal}
+`);
+  try {
+    const data = ensureForgeData();
+    const exists = data.resources.find((r) => r.name === name);
+    if (!exists) {
+      data.resources.push({
+        name,
+        methods: []
+      });
+      await saveData(data);
+    }
+    console.log("\u{1F4E6} Creating type...");
+    await makeTypeCommand(name, { timestamps: true });
+    console.log("\u{1F310} Creating api...");
+    await makeApiCommand(name);
+    console.log("\u2699\uFE0F Creating service...");
+    await makeServiceCommand(name);
+    console.log(`
+\u2705 Resource ${pascal} created successfully!
+`);
+    const shouldSync = options.sync !== false && (config.sync.mode === "auto" || options.sync === true);
+    if (shouldSync) {
+      await syncCommand();
+    }
+  } catch (err) {
+    console.error("\u274C Error creating resource:", err);
+    process.exit(1);
+  }
+}
+
+// src/commands/consume.ts
+import fs9 from "fs-extra";
+import path10 from "path";
+import readline2 from "readline";
+import { Project, SyntaxKind } from "ts-morph";
+function askUser2(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function consumeCommand(method, action, resource, apiInstance = "api") {
+  const config = ensureForgeInitialized();
+  const data = ensureForgeData();
+  const state = ensureForgeState();
+  const cwd = process.cwd();
+  const actionPascal = toPascalCase(action);
+  const actionCamel = toCamelCase(action);
+  if (!resource) {
+    if (state.resources.length === 0) {
+      console.error(`\u274C Nenhum resource encontrado. Crie um resource primeiro com 'forge make:resource'.`);
+      process.exit(1);
+    }
+    const validResources = state.resources.filter((r) => r.status !== "missing");
+    if (validResources.length === 0) {
+      console.error(`\u274C Todos os resources est\xE3o incompletos ('missing'). N\xE3o \xE9 poss\xEDvel consumir.`);
+      process.exit(1);
+    }
+    let question = "\nQual resource deseja usar?\n";
+    validResources.forEach((r, idx) => {
+      question += `${idx + 1} - ${r.name}
+`;
+    });
+    question += `Escolha (1-${validResources.length}): `;
+    const answer = await askUser2(question);
+    const index = parseInt(answer.trim(), 10) - 1;
+    if (isNaN(index) || index < 0 || index >= validResources.length) {
+      console.error("\n\u274C Op\xE7\xE3o inv\xE1lida.");
+      process.exit(1);
+    }
+    resource = validResources[index].name;
+  }
+  const resourcePascal = toPascalCase(resource);
+  let resourceIntent = data.resources.find((r) => r.name === resource);
+  if (!resourceIntent) {
+    console.log(`
+\u{1F47B} Resource "${resource}" estava \xF3rf\xE3o. Registrando inten\xE7\xE3o automaticamente...`);
+    resourceIntent = { name: resource, methods: [] };
+    data.resources.push(resourceIntent);
+    await saveData(data);
+  }
+  const resourceState = state.resources.find((r) => r.name === resource);
+  if (!resourceState || resourceState.status === "missing") {
+    console.error(`\u274C Resource "${resource}" est\xE1 incompleto ou ausente no filesystem.`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F680} Consumindo opera\xE7\xE3o: ${method} ${action} em ${resource}
+`);
+  const project = new Project();
+  const apiFilePath = path10.join(cwd, resourceState.files.api.path);
+  const moduleDir = path10.dirname(apiFilePath);
+  const hooksDir = path10.join(moduleDir, "hooks");
+  const endpointsDir = path10.join(moduleDir, "endpoints");
+  await fs9.ensureDir(hooksDir);
+  await fs9.ensureDir(endpointsDir);
+  const apiSource = project.addSourceFileAtPath(apiFilePath);
+  const apiObject = apiSource.getVariableDeclaration(`${resourcePascal}API`)?.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+  if (apiObject) {
+    const paramsStr = method === "PUT" || method === "DELETE" || method === "GET" ? "`${payload.params.id}`" : "";
+    const bodyStr = method === "POST" || method === "PUT" ? ", payload.body" : "";
+    const urlSuffix = paramsStr ? `/${resource}/${paramsStr}` : `"/${resource}/${actionCamel}"`;
+    apiSource.addImportDeclaration({
+      moduleSpecifier: `./endpoints/${actionCamel}.types`,
+      namedImports: [`${actionPascal}Payload`, `${actionPascal}Response`]
+    });
+    apiObject.addPropertyAssignment({
+      name: actionCamel,
+      initializer: `async (payload: ${actionPascal}Payload):Promise<${actionPascal}Response> => await ${apiInstance}.${method.toLowerCase()}<${actionPascal}Response>(${urlSuffix}${bodyStr})`
+    });
+    await apiSource.save();
+    console.log(`\u{1F310} API (${resource}.api.ts) atualizada.`);
+  }
+  const serviceFilePath = path10.join(cwd, resourceState.files.service.path);
+  const serviceSource = project.addSourceFileAtPath(serviceFilePath);
+  const serviceObject = serviceSource.getVariableDeclaration(`${resourcePascal}Service`)?.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+  if (serviceObject) {
+    serviceSource.addImportDeclaration({
+      moduleSpecifier: `./endpoints/${actionCamel}.types`,
+      namedImports: [`${actionPascal}Payload`, `${actionPascal}Response`]
+    });
+    serviceObject.addPropertyAssignment({
+      name: actionCamel,
+      initializer: `async (payload: ${actionPascal}Payload):Promise<${actionPascal}Response> => {
+    try {
+      const { data } = await ${resourcePascal}API.${actionCamel}(payload);
+      return data;
+    } catch (error) {
+      throw parseApiError(error);
+    }
+  }`
+    });
+    await serviceSource.save();
+    console.log(`\u2699\uFE0F Service (${resource}.service.ts) atualizado.`);
+  }
+  const typesFilePath = path10.join(endpointsDir, `${actionCamel}.types.ts`);
+  const modelExists = resourceState.files.type.exists;
+  const modelName = resourcePascal;
+  let typesContent = loadTemplate("operation-types.tpl");
+  const errorMaps = {
+    GET: "    403: ForbiddenError;\n    404: NotFoundError;",
+    POST: "    403: ForbiddenError;\n    422: ${ActionPascal}ValidationError;",
+    PUT: "    403: ForbiddenError;\n    404: NotFoundError;\n    422: ${ActionPascal}ValidationError;",
+    DELETE: "    403: ForbiddenError;\n    404: NotFoundError;"
+  };
+  const valErrTpl = `export interface \${ActionPascal}ValidationError extends BaseError {
+  errors: TFieldValidationError<keyof \${ModelName}>[];
+}`;
+  let payloadStr = "";
+  if (method === "PUT" || method === "DELETE") {
+    payloadStr = "  params: { id: string };\n  body: Partial<${ModelName}>;";
+  } else if (method === "POST") {
+    payloadStr = "  body: Partial<${ModelName}>;";
+  } else {
+    payloadStr = "  params?: { id?: string };";
+  }
+  typesContent = typesContent.replace(/{{ActionPascal}}/g, actionPascal).replace(/{{ModelName}}/g, modelExists ? modelName : "any").replace(/{{ModelImport}}/g, modelExists ? `import { ${modelName} } from "../${resource}.type";` : "").replace(/{{ValidationErrorInterface}}/g, (method === "POST" || method === "PUT") && modelExists ? valErrTpl.replace(/\${ActionPascal}/g, actionPascal).replace(/\${ModelName}/g, modelName) : "").replace(/{{PayloadStructure}}/g, payloadStr.replace(/\${ModelName}/g, modelExists ? modelName : "any")).replace(/{{ResponseStructure}}/g, `  ${toCamelCase(resource)}: ${modelExists ? modelName : "any"}`).replace(/{{ErrorMapStructure}}/g, errorMaps[method].replace(/\${ActionPascal}/g, actionPascal));
+  await writeFileSafe(typesFilePath, typesContent);
+  console.log(`\u{1F4E6} Types (endpoints/${actionCamel}.types.ts) gerado.`);
+  const hookFilePath = path10.join(hooksDir, `use${actionPascal}.hook.ts`);
+  let hookContent = loadTemplate("operation-hook.tpl");
+  const isMutation = method !== "GET";
+  hookContent = hookContent.replace(/{{HookType}}/g, isMutation ? "useMutation" : "useQuery").replace(/{{HookProperty}}/g, isMutation ? "mutationFn" : "queryFn").replace(/{{ActionPascal}}/g, actionPascal).replace(/{{ResourcePascal}}/g, resourcePascal).replace(/{{resource}}/g, `../${resource}`).replace(/{{ActionPath}}/g, `../endpoints/${actionCamel}`).replace(/{{ActionCamel}}/g, actionCamel);
+  await writeFileSafe(hookFilePath, hookContent);
+  console.log(`\u{1FA9D} Hook (hooks/use${actionPascal}.hook.ts) gerado.`);
+  if (!resourceIntent.methods.includes(actionCamel)) {
+    resourceIntent.methods.push(actionCamel);
+    await saveData(data);
+  }
+  await syncCommand();
+  console.log(`
+\u2705 Opera\xE7\xE3o ${actionCamel} injetada com sucesso!`);
+}
+
+// src/bin/cli.ts
+var program = new Command();
+program.name("forge").description("API contract CLI");
+program.command("init").option("--overwrite", "Sobrescrever arquivos existentes").action(initCommand);
+program.command("sync").description("Sincroniza o estado do projeto com o registro de inten\xE7\xE3o").action(syncCommand);
+program.command("make:client").argument("<name>").option("--overwrite", "Sobrescrever arquivos existentes").action(makeClientCommand);
+program.command("make:resource").argument("<name>").option("--sync", "For\xE7ar sincroniza\xE7\xE3o ap\xF3s cria\xE7\xE3o").option("--no-sync", "Pular sincroniza\xE7\xE3o autom\xE1tica").action(makeResourceCommand);
+program.command("make:type").argument("<name>").option("--timestamps", "Add timestamps", false).action(makeTypeCommand);
+program.command("make:service").argument("<name>").action(makeServiceCommand);
+program.command("make:api").argument("<name>").action(makeApiCommand);
+["GET", "POST", "PUT", "DELETE", "get", "post", "put", "delete"].forEach((method) => {
+  program.command(`consume:${method}`).argument("<action>").argument("[resource]").argument("[api]").action(async (action, resource, api) => {
+    await consumeCommand(method.toUpperCase(), action, resource, api || "api");
+  });
+});
+program.parse();

package/dist/templates/api-client-instance.tpl

@@ -0,0 +1,17 @@
+export const {{camelName}}Api = axios.create({
+  baseURL: import.meta.env.VITE_API_{{upperName}}_URL,
+  timeout: 1000 * 15,
+});
+
+setupInterceptors({{camelName}}Api, false);
+
+async {{camelCaseName}}(payload: {{payload}}): Promise<{{response}}> {
+  try{
+    const {data} = await api.post("/{{route}}", payload);
+
+    return data;
+  }catch(error){
+    throw parseApiError<{{errorMap}}>
+  }
+
+},

package/dist/templates/api-client.ts.tpl

@@ -0,0 +1,50 @@
+import axios from "axios";
+import type { AxiosInstance } from "axios";
+
+type LogoutCallback = () => void;
+
+let logoutHandlers: LogoutCallback[] = [];
+
+export function setLogoutHandler(callback: LogoutCallback) {
+  logoutHandlers.push(callback);
+}
+
+const setupInterceptors = (
+  instance: AxiosInstance,
+  shouldLogoutOnUnauthorizedException = false
+) => {
+  instance.interceptors.request.use((config) => {
+    const token = localStorage.getItem("access_token");
+
+    if (token && !config.headers.Authorization) {
+      config.headers.Authorization = `Bearer ${token}`;
+    }
+
+    return config;
+  });
+
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      const status = error.response?.status;
+
+      if (status === 401 && shouldLogoutOnUnauthorizedException) {
+        if (logoutHandlers.length === 0) {
+          console.error("Logout handler not specified");
+          return Promise.reject(error);
+        }
+
+        logoutHandlers.forEach((handler) => handler());
+      }
+
+      return Promise.reject(error);
+    }
+  );
+};
+
+export const api = axios.create({
+  baseURL: import.meta.env.VITE_API_URL,
+  timeout: 1000 * 15,
+});
+
+setupInterceptors(api);

package/dist/templates/api.tpl

@@ -0,0 +1,5 @@
+import { api } from "{{apiImportPath}}";
+
+export const {{PascalName}}API = {
+
+};

package/dist/templates/api.types.tpl

@@ -0,0 +1,29 @@
+export type HttpStatus = 400 | 401 | 403 | 404 | 409 | 422 | 500;
+
+export interface BaseError {
+  message: string;
+}
+
+export interface UnauthorizedError extends BaseError {}
+export interface ForbiddenError extends BaseError {}
+export interface NotFoundError extends BaseError {}
+
+export type ApiError<
+  TMap extends Partial<Record<HttpStatus, any>>
+> = {
+  [K in keyof TMap & HttpStatus]: {
+    status: K;
+    message: string;
+    error_data: TMap[K];
+  };
+}[keyof TMap & HttpStatus];
+
+export type DefaultErrorMap = {
+  400: BaseError;
+  401: UnauthorizedError;
+  403: ForbiddenError;
+  404: NotFoundError;
+  409: BaseError;
+  422: BaseError;
+  500: BaseError;
+};

package/dist/templates/api.utils.tpl

@@ -0,0 +1,26 @@
+import type { AxiosError } from "axios";
+import type { BaseErrorResponse } from "@/types/global.types";
+import type { ApiError, HttpStatus } from "@/types/api.types";
+
+export function parseApiError<
+  TMap extends Partial<Record<HttpStatus, any>>
+>(
+  error: unknown
+): ApiError<TMap> {
+  const axiosError = error as AxiosError<BaseErrorResponse<any>>;
+
+  const rawStatus = axiosError.response?.status;
+
+  const status = (rawStatus ?? 500) as keyof TMap;
+
+  return {
+    status,
+    message:
+      axiosError.response?.data?.message ||
+      axiosError.message ||
+      "Erro desconhecido",
+    error_data:
+      axiosError.response?.data?.error_data ??
+      ({} as TMap[keyof TMap]),
+  } as ApiError<TMap>;
+}

package/dist/templates/global.types.tpl

@@ -0,0 +1,17 @@
+export type BasePayload<T extends {
+  queryParams?: object;
+  routeParams?: object;
+  body?: object;
+}> = T;
+
+export type BaseSuccessResponse<TData> = {
+  message: string;
+  data: TData;
+  status: number;
+};
+
+export type BaseErrorResponse<TErrorData> = {
+  status: number;
+  error_data: TErrorData;
+  message: string;
+};

package/dist/templates/model-type.tpl

@@ -0,0 +1,3 @@
+export interface {{PascalName}} {
+{{fields}}
+}

package/dist/templates/operation-hook.tpl

@@ -0,0 +1,9 @@
+import { {{HookType}} } from "@tanstack/react-query";
+import { {{ResourcePascal}}Service } from "./{{resource}}.service";
+import { {{ActionPascal}}Payload, {{ActionPascal}}Response } from "./{{ActionPath}}.types";
+
+export const use{{ActionPascal}} = () => {
+  return {{HookType}}<{{ActionPascal}}Response, Error, {{ActionPascal}}Payload>({
+    {{HookProperty}}: (payload) => {{ResourcePascal}}Service.{{ActionCamel}}(payload),
+  });
+};

package/dist/templates/operation-types.tpl

@@ -0,0 +1,17 @@
+import { BasePayload, BaseSuccessResponse, ForbiddenError, NotFoundError, BaseError } from "@/api/api.types";
+import { TFieldValidationError } from "@/types/shared.types";
+{{ModelImport}}
+
+{{ValidationErrorInterface}}
+
+export interface {{ActionPascal}}Payload extends BasePayload<{
+{{PayloadStructure}}
+}> {}
+
+export interface {{ActionPascal}}Response extends BaseSuccessResponse<{
+{{ResponseStructure}}
+}> {}
+
+export type {{ActionPascal}}ErrorMap = {
+{{ErrorMapStructure}}
+};

package/dist/templates/service.tpl

@@ -0,0 +1,6 @@
+import { {{PascalName}}API } from "{{apiImportPath}}";
+import { parseApiError } from "{{utilsImportPath}}";
+
+export const {{PascalName}}Service = {
+
+};

package/dist/templates/shared.types.tpl

@@ -0,0 +1,16 @@
+export type TPagination<TData> = {
+  current_page: number;
+  data: TData[];
+  next_page_url?: string;
+  path: string;
+  per_page: number;
+  prev_page_url?: string;
+  to: number;
+  total: number;
+  last_page: number;
+};
+
+export type TFieldValidationError<TField extends string> = {
+  field: TField;
+  error: string;
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@vitongovisk/forge",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./dist/cli.js",
+  "bin": {
+    "forge": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/bin/cli.ts --format esm --clean && npm run copy:templates",
+    "copy:templates": "cpy src/templates/**/* dist/templates",
+    "dev": "node dist/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@tanstack/react-query": "^5.100.8",
+    "axios": "^1.16.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4",
+    "inquirer": "^13.4.2",
+    "ts-morph": "^28.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.6.0",
+    "cpy-cli": "^7.0.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  },
+  "exports": {
+    ".": "./dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "typescript",
+    "axios",
+    "tanstack-query",
+    "codegen",
+    "frontend",
+    "architecture"
+  ]
+}