jarvis-ai-framework 1.0.0

package/bin/lib/tasks/comment.js

@@ -0,0 +1,131 @@
+import { cardUrl } from "../vcs/api.js";
+
+function env(name) {
+  return String(process.env[name] || "").trim();
+}
+
+function taskManager() {
+  return env("TASK_MANAGER").toLowerCase() || "jira";
+}
+
+async function commentJira(cardKey, message) {
+  const base = env("TASK_MANAGER_URL_BASE").replace(/\/$/, "");
+  const token = env("TOKEN_TASK_MANAGER");
+  const email = env("USER");
+  if (!base || !token) {
+    throw new Error(
+      "Jira: preencha TASK_MANAGER_URL_BASE e TOKEN_TASK_MANAGER no ENV.md",
+    );
+  }
+  const auth = email
+    ? `Basic ${Buffer.from(`${email}:${token}`).toString("base64")}`
+    : `Bearer ${token}`;
+  const res = await fetch(`${base}/rest/api/3/issue/${cardKey}/comment`, {
+    method: "POST",
+    headers: {
+      Authorization: auth,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify({
+      body: {
+        version: 1,
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: message }],
+          },
+        ],
+      },
+    }),
+  });
+  if (!res.ok) {
+    throw new Error(`Jira ${res.status}: ${await res.text()}`);
+  }
+}
+
+async function commentLinear(cardKey, message) {
+  const token = env("TOKEN_TASK_MANAGER");
+  if (!token) throw new Error("Linear: preencha TOKEN_TASK_MANAGER no ENV.md");
+  const res = await fetch("https://api.linear.app/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: token,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      query: `mutation($id: String!, $body: String!) {
+        commentCreate(input: { issueId: $id, body: $body }) { success }
+      }`,
+      variables: { id: cardKey, body: message },
+    }),
+  });
+  const json = await res.json();
+  if (!res.ok || json.errors) {
+    throw new Error(`Linear: ${JSON.stringify(json.errors || json)}`);
+  }
+}
+
+async function commentGithub(cardKey, message) {
+  const token =
+    env("TOKEN_TASK_MANAGER") || env("GITHUB_TOKEN") || env("GH_TOKEN");
+  const base = env("TASK_MANAGER_URL_BASE").replace(/\/$/, "");
+  if (!token || !base) {
+    throw new Error(
+      "GitHub Issues: TASK_MANAGER_URL_BASE (https://github.com/org/repo) e TOKEN_TASK_MANAGER/GITHUB_TOKEN",
+    );
+  }
+  const path = new URL(base).pathname.replace(/^\/+|\/+$/g, "");
+  const number = String(cardKey).replace(/^#/, "");
+  const res = await fetch(
+    `https://api.github.com/repos/${path}/issues/${number}/comments`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ body: message }),
+    },
+  );
+  if (!res.ok) throw new Error(`GitHub ${res.status}: ${await res.text()}`);
+}
+
+async function commentAsana(cardKey, message) {
+  const token = env("TOKEN_TASK_MANAGER");
+  if (!token) throw new Error("Asana: preencha TOKEN_TASK_MANAGER no ENV.md");
+  const res = await fetch(`https://app.asana.com/api/1.0/tasks/${cardKey}/stories`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ data: { text: message } }),
+  });
+  if (!res.ok) throw new Error(`Asana ${res.status}: ${await res.text()}`);
+}
+
+const cardKey = process.argv[2];
+const message = process.argv.slice(3).join(" ");
+
+if (!cardKey || !message) {
+  console.error("Uso: comment.js <TASK_MANAGER_KEY> <mensagem>");
+  process.exit(1);
+}
+
+const tm = taskManager();
+try {
+  if (tm === "linear") await commentLinear(cardKey, message);
+  else if (tm === "github") await commentGithub(cardKey, message);
+  else if (tm === "asana") await commentAsana(cardKey, message);
+  else await commentJira(cardKey, message);
+
+  const url = cardUrl(tm, env("TASK_MANAGER_URL_BASE"), cardKey);
+  console.log(`💬 Comentário adicionado em ${cardKey} (${tm})`);
+  if (url !== cardKey) console.log(`   ${url}`);
+} catch (err) {
+  console.error(`⚠️ Não foi possível comentar no card ${cardKey}: ${err.message}`);
+  process.exit(2);
+}

package/bin/lib/utils/git-parser.js

@@ -0,0 +1,145 @@
+/**
+ * Parseia URL de repositório Git (GitLab, GitHub, Bitbucket, self-hosted).
+ * Vendor: hostname, senão VERSION_CONTROL do ENV.
+ */
+
+const VENDORS = {
+  gitlab: {
+    detect: (host) => host.includes("gitlab"),
+    apiBase: (origin, host) =>
+      host === "gitlab.com" ? "https://gitlab.com/api/v4" : `${origin}/api/v4`,
+  },
+  github: {
+    detect: (host) => host.includes("github"),
+    apiBase: (origin, host) =>
+      host === "github.com" ? "https://api.github.com" : `${origin}/api/v3`,
+  },
+  bitbucket: {
+    detect: (host) => host.includes("bitbucket"),
+    apiBase: () => "https://api.bitbucket.org/2.0",
+  },
+};
+
+function normalizeGitUrl(url) {
+  let raw = String(url).trim();
+  const ssh = raw.match(/^git@([^:]+):(.+?)(\.git)?$/);
+  if (ssh) {
+    raw = `https://${ssh[1]}/${ssh[2].replace(/\.git$/, "")}`;
+  }
+  raw = raw.replace(/\.git$/, "");
+  return raw;
+}
+
+function detectVendor(host) {
+  const fromEnv = String(process.env.VERSION_CONTROL || "")
+    .trim()
+    .toLowerCase();
+  for (const [vendor, spec] of Object.entries(VENDORS)) {
+    if (spec.detect(host)) return vendor;
+  }
+  if (VENDORS[fromEnv]) return fromEnv;
+  return null;
+}
+
+/**
+ * @param {string} url
+ * @returns {{
+ *   vendor: 'gitlab'|'github'|'bitbucket',
+ *   host: string,
+ *   origin: string,
+ *   projectPath: string,
+ *   projectPathEncoded: string,
+ *   owner: string,
+ *   repo: string,
+ *   apiBase: string,
+ *   webBase: string,
+ * }}
+ */
+export function parseRepoUrl(url) {
+  if (!url || typeof url !== "string") {
+    throw new Error("URL do repositório vazia ou inválida");
+  }
+
+  const normalized = normalizeGitUrl(url);
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(
+      `URL inválida: ${url}\n` +
+        "Formatos: https://github.com/org/repo.git | https://gitlab.com/grupo/repo.git | https://bitbucket.org/ws/repo.git",
+    );
+  }
+
+  const host = parsed.hostname;
+  const origin = parsed.origin;
+  const projectPath = parsed.pathname.replace(/^\/+|\/+$/g, "");
+  if (!projectPath) {
+    throw new Error(`Project path vazio na URL: ${url}`);
+  }
+
+  const vendor = detectVendor(host);
+  if (!vendor) {
+    throw new Error(
+      `Não foi possível detectar o vendor de ${host}.\n` +
+        "Defina VERSION_CONTROL=gitlab|github|bitbucket no ENV.md.",
+    );
+  }
+
+  const parts = projectPath.split("/");
+  const repo = parts[parts.length - 1];
+  const owner = parts.slice(0, -1).join("/");
+
+  return {
+    vendor,
+    host,
+    origin,
+    projectPath,
+    projectPathEncoded: encodeURIComponent(projectPath),
+    owner,
+    repo,
+    apiBase: VENDORS[vendor].apiBase(origin, host),
+    webBase: origin,
+  };
+}
+
+/** @deprecated use parseRepoUrl */
+export function parseGitLabUrl(url) {
+  const parsed = parseRepoUrl(url);
+  if (parsed.vendor !== "gitlab") {
+    throw new Error(
+      `URL não é GitLab (${parsed.vendor}): ${url}\n` +
+        "Use parseRepoUrl() para GitHub/Bitbucket.",
+    );
+  }
+  return parsed;
+}
+
+export function buildApiUrl(repoUrl, endpoint) {
+  const { vendor, apiBase, projectPathEncoded, owner, repo } =
+    parseRepoUrl(repoUrl);
+  if (vendor === "gitlab") {
+    return `${apiBase}/projects/${projectPathEncoded}/${endpoint}`;
+  }
+  if (vendor === "github") {
+    return `${apiBase}/repos/${owner}/${repo}/${endpoint}`;
+  }
+  return `${apiBase}/repositories/${owner}/${repo}/${endpoint}`;
+}
+
+export function buildWebUrl(repoUrl, path) {
+  const { webBase, projectPath, vendor } = parseRepoUrl(repoUrl);
+  if (vendor === "gitlab") {
+    return `${webBase}/${projectPath}/${path}`;
+  }
+  if (vendor === "github") {
+    return `${webBase}/${projectPath}/${path}`;
+  }
+  return `${webBase}/${projectPath}/${path}`;
+}
+
+export function mergeRequestPath(vendor, iid) {
+  if (vendor === "gitlab") return `-/merge_requests/${iid}`;
+  if (vendor === "github") return `pull/${iid}`;
+  return `pull-requests/${iid}`;
+}

package/bin/lib/utils/logger.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Sistema de logging centralizado
+ * @module utils/logger
+ */
+
+/**
+ * @typedef {'debug' | 'info' | 'warn' | 'error' | 'silent'} LogLevel
+ */
+
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 99,
+};
+
+let currentLevel = LOG_LEVELS.info;
+let isTestMode = false;
+
+/**
+ * Define o nível mínimo de log
+ * @param {LogLevel} level
+ */
+export function setLogLevel(level) {
+  currentLevel = LOG_LEVELS[level] ?? LOG_LEVELS.info;
+}
+
+/**
+ * Ativa modo de teste (silencia todos os logs)
+ * @param {boolean} enabled
+ */
+export function setTestMode(enabled) {
+  isTestMode = enabled;
+}
+
+/**
+ * Verifica se deve logar baseado no nível
+ * @private
+ * @param {number} level
+ * @returns {boolean}
+ */
+function shouldLog(level) {
+  return !isTestMode && level >= currentLevel;
+}
+
+/**
+ * Logger principal
+ */
+export const logger = {
+  /**
+   * Log de debug (desenvolvimento)
+   * @param {...any} args
+   */
+  debug(...args) {
+    if (shouldLog(LOG_LEVELS.debug)) {
+      console.log(...args);
+    }
+  },
+
+  /**
+   * Log informativo
+   * @param {...any} args
+   */
+  info(...args) {
+    if (shouldLog(LOG_LEVELS.info)) {
+      console.log(...args);
+    }
+  },
+
+  /**
+   * Log de aviso
+   * @param {...any} args
+   */
+  warn(...args) {
+    if (shouldLog(LOG_LEVELS.warn)) {
+      console.warn(...args);
+    }
+  },
+
+  /**
+   * Log de erro
+   * @param {...any} args
+   */
+  error(...args) {
+    if (shouldLog(LOG_LEVELS.error)) {
+      console.error(...args);
+    }
+  },
+};
+
+/**
+ * Detecta flags de verbosidade e configura logger
+ * @param {Object} flags - Flags do CLI
+ */
+export function configureFromFlags(flags) {
+  if (flags.quiet || flags.q) {
+    setLogLevel("error");
+  } else if (flags.verbose || flags.v) {
+    setLogLevel("debug");
+  } else if (flags.silent) {
+    setLogLevel("silent");
+  }
+}

package/bin/lib/utils/npmrc-parser.js

@@ -0,0 +1,106 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+
+function readNpmrcToken(hostFragment, cwd = process.cwd()) {
+  const paths = [join(cwd, ".npmrc"), join(homedir(), ".npmrc")];
+  const re = new RegExp(
+    `//[^\\s]*${hostFragment.replace(".", "\\.")}[^\\s]*:_authToken=([^\\s]+)`,
+  );
+
+  for (const path of paths) {
+    if (!existsSync(path)) continue;
+    try {
+      const content = readFileSync(path, "utf-8");
+      const match = content.match(re);
+      if (match?.[1]) return match[1];
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function ghCliToken() {
+  try {
+    const token = execSync("gh auth token", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Token do vendor de Git (ENV / .npmrc / CLI).
+ * @param {'gitlab'|'github'|'bitbucket'|string} vendor
+ * @param {string} [cwd]
+ */
+export function getVcsToken(vendor, cwd = process.cwd()) {
+  const v = String(vendor || process.env.VERSION_CONTROL || "")
+    .trim()
+    .toLowerCase();
+
+  if (v === "github") {
+    const token =
+      process.env.GITHUB_TOKEN ||
+      process.env.GH_TOKEN ||
+      readNpmrcToken("npm.pkg.github.com", cwd) ||
+      readNpmrcToken("github.com", cwd) ||
+      ghCliToken();
+    if (token) return token;
+    throw new Error(
+      "Token GitHub não encontrado.\n" +
+        "Use `gh auth login`, ou defina GITHUB_TOKEN, ou //npm.pkg.github.com/:_authToken= no .npmrc.",
+    );
+  }
+
+  if (v === "bitbucket") {
+    const token =
+      process.env.BITBUCKET_TOKEN ||
+      readNpmrcToken("bitbucket.org", cwd);
+    if (token) return token;
+    throw new Error(
+      "Token Bitbucket não encontrado.\n" +
+        "Defina BITBUCKET_TOKEN (App Password) no ambiente.",
+    );
+  }
+
+  const token =
+    process.env.GITLAB_TOKEN ||
+    readNpmrcToken("gitlab.com", cwd) ||
+    readNpmrcToken("gitlab", cwd);
+  if (token) return token;
+  throw new Error(
+    "Token GitLab não encontrado no .npmrc\n" +
+      "Configure:\n" +
+      "  //gitlab.com/api/v4/packages/npm/:_authToken=seu-token\n" +
+      "Ou GITLAB_TOKEN no ambiente.",
+  );
+}
+
+/** @deprecated use getVcsToken('gitlab') */
+export function getGitLabToken(cwd = process.cwd()) {
+  return getVcsToken("gitlab", cwd);
+}
+
+export function hasGitLabToken(cwd = process.cwd()) {
+  try {
+    getVcsToken("gitlab", cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function hasVcsToken(vendor, cwd = process.cwd()) {
+  try {
+    getVcsToken(vendor, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/bin/lib/utils/paths.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { IDES } from "../config/ide-config.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// From bin/lib/utils -> go up 3 levels to reach project root (both dev and production)
+export const FRAMEWORK_ROOT = join(__dirname, "..", "..", "..");
+
+export function getFrameworkRoot() {
+  if (process.env.JARVIS_ROOT && existsSync(process.env.JARVIS_ROOT)) {
+    return process.env.JARVIS_ROOT;
+  }
+
+  if (existsSync(join(FRAMEWORK_ROOT, "agents"))) {
+    return FRAMEWORK_ROOT;
+  }
+
+  throw new Error(
+    "Could not locate framework assets.\n" +
+      "Run: npm install jarvis-framework --save-dev",
+  );
+}
+
+/** @returns {{ name: string, version: string, root: string }} */
+export function getPackageInfo() {
+  const root = getFrameworkRoot();
+  const pkgPath = join(root, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { name: "jarvis-framework", version: "0.0.0", root };
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return {
+    name: pkg.name || "jarvis-framework",
+    version: pkg.version || "0.0.0",
+    root,
+  };
+}
+
+export function detectIDE(cwd) {
+  for (const ide of IDES) {
+    if (!ide.supported) continue;
+    const folder = ide.folderName || ide.value;
+    if (existsSync(join(cwd, `.${folder}`))) return ide.value;
+  }
+  return null;
+}
+
+export function detectAllIDEs(cwd) {
+  return IDES
+    .filter((ide) => ide.supported)
+    .filter((ide) => existsSync(join(cwd, `.${ide.folderName || ide.value}`)))
+    .map((ide) => ide.value);
+}

package/bin/lib/utils/ui.js

@@ -0,0 +1,59 @@
+import { getPackageInfo } from "./paths.js";
+
+export const RED = "\x1b[0;31m";
+export const GREEN = "\x1b[0;32m";
+export const BLUE = "\x1b[0;34m";
+export const YELLOW = "\x1b[1;33m";
+export const CYAN = "\x1b[0;36m";
+export const DIM = "\x1b[2m";
+export const BOLD = "\x1b[1m";
+export const NC = "\x1b[0m";
+
+export function showBanner() {
+  console.log(CYAN);
+  console.log("");
+  console.log("                 ╔════════════════════════════════╗");
+  console.log("              ╔══╝                                ╚══╗");
+  console.log("            ╔═╝        ┌────────────────────┐         ╚═╗");
+  console.log("          ╔═╝          │     J.A.R.V.I.S    │           ╚═╗");
+  console.log("         ║             └────────────────────┘               ║");
+  console.log("        ║                                                    ║");
+  console.log("       ║                  ╭──────────────╮                   ║");
+  console.log("       ║               ╭──╯              ╰──╮                ║");
+  console.log("       ║             ╭─╯     ◉        ◉     ╰─╮              ║");
+  console.log("       ║            │                          │             ║");
+  console.log("       ║            │          ╲____╱          │             ║");
+  console.log("       ║            │       ────────────       │             ║");
+  console.log("       ║             ╰─╮                    ╭─╯              ║");
+  console.log("       ║               ╰──╮              ╭──╯                ║");
+  console.log("       ║                  ╰──────────────╯                   ║");
+  console.log("        ║                                                    ║");
+  console.log("         ╚═╗          ◇  STARK INDUSTRIES  ◇             ╔═╝");
+  console.log("           ╚═╗                                        ╔═╝");
+  console.log("             ╚══╗    [ SYSTEM ONLINE ]           ╔══╝");
+  console.log("                ╚════════════════════════════════╝");
+  console.log("");
+  console.log("              ──────── J . A . R . V . I . S ────────");
+  console.log(NC);
+  console.log(
+    `${DIM}Framework Jarvis para desenvolvimento assistido por IA${NC}`,
+  );
+
+  try {
+    const pkg = getPackageInfo();
+    console.log("");
+    console.log(
+      `${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`,
+    );
+    console.log(`${BOLD}${CYAN}  ${pkg.name}  v${pkg.version}${NC}`);
+    console.log(`${DIM}  origem: ${pkg.root}${NC}`);
+    console.log(
+      `${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`,
+    );
+  } catch {
+    // banner sem versão se assets não forem encontrados
+  }
+
+  console.log("");
+  console.log("");
+}