biaws 0.1.0

package/src/commands/agent.js

@@ -0,0 +1,400 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+import { BaseCommand, TOOL_DIRECTORY } from "../baseCommands.js";
+import { showTopic } from "../compatibilityCommands.js";
+import { readLock } from "../localSkills.js";
+import { runSkillsCommand } from "./skills.js";
+
+const CODEX_BEGIN = "# BEGIN BIAWS MANAGED MCP";
+const CODEX_END = "# END BIAWS MANAGED MCP";
+
+function skillTarget(client, projectDirectory) {
+  return path.join(
+    projectDirectory,
+    client === "claude" ? ".claude" : ".agents",
+    "skills",
+  );
+}
+
+function mcpEntrypoint(toolDirectory) {
+  return path.resolve(toolDirectory, "..", "biaws-mcp", "src", "index.js");
+}
+
+async function readOptional(filePath, fallback = "") {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+
+async function writeCodexConfiguration(
+  projectDirectory,
+  entrypoint,
+  envFile,
+  workspaceId,
+  force,
+) {
+  const configPath = path.join(projectDirectory, ".codex", "config.toml");
+  await mkdir(path.dirname(configPath), { recursive: true });
+  let current = await readOptional(configPath);
+  const managedPattern = new RegExp(
+    `${CODEX_BEGIN.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}[\\s\\S]*?${CODEX_END.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\n?`,
+    "gu",
+  );
+  current = current.replace(managedPattern, "").trimEnd();
+  if (/\[mcp_servers\.biaws\]/u.test(current) && !force) {
+    throw new Error(
+      `Já existe uma configuração Codex não gerenciada para mcp_servers.biaws em ${configPath}; use --force para mantê-la sob gestão do CLI`,
+    );
+  }
+  if (force) {
+    current = current.replace(
+      /\n?\[mcp_servers\.biaws\]\n(?:[^[\n].*\n?)*/gu,
+      "",
+    );
+  }
+  const managed = `${CODEX_BEGIN}
+[mcp_servers.biaws]
+command = "node"
+args = [${JSON.stringify(entrypoint)}]
+env = {${envFile ? ` BIAWS_ENV_FILE = ${JSON.stringify(envFile)},` : ""} ISSUE_WORKSPACE_ID = ${JSON.stringify(workspaceId)} }
+${CODEX_END}
+`;
+  const output = current ? `${current}\n\n${managed}` : managed;
+  await writeFile(configPath, output, "utf8");
+  return configPath;
+}
+
+async function writeClaudeConfiguration(
+  projectDirectory,
+  entrypoint,
+  envFile,
+  workspaceId,
+  force,
+) {
+  const configPath = path.join(projectDirectory, ".mcp.json");
+  const raw = await readOptional(configPath, "{}");
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch {
+    throw new Error(`JSON inválido em ${configPath}`);
+  }
+  config.mcpServers ||= {};
+  if (config.mcpServers.biaws && !force) {
+    const current = config.mcpServers.biaws;
+    if (
+      current.command !== "node" ||
+      JSON.stringify(current.args || []) !== JSON.stringify([entrypoint])
+    ) {
+      throw new Error(
+        `Já existe uma configuração Claude diferente para o servidor biaws em ${configPath}; use --force para substituí-la`,
+      );
+    }
+  }
+  config.mcpServers.biaws = {
+    type: "stdio",
+    command: "node",
+    args: [entrypoint],
+    env: {
+      ...(envFile ? { BIAWS_ENV_FILE: envFile } : {}),
+      ISSUE_WORKSPACE_ID: workspaceId,
+    },
+  };
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  return configPath;
+}
+
+async function resolveWorkspaceId(api, requestedWorkspaceId = "") {
+  let identity;
+  try {
+    identity = await api.identity();
+  } catch (error) {
+    if (!requestedWorkspaceId && error.statusCode === 400) {
+      throw new Error(
+        "A identidade acessa mais de um workspace. Informe --workspace <id> para selecionar o workspace deste projeto.",
+      );
+    }
+    throw error;
+  }
+  const workspaceId = requestedWorkspaceId || identity?.actor?.workspaceId;
+  if (!workspaceId) {
+    if ((identity?.actor?.workspaces?.length || 0) > 1) {
+      throw new Error(
+        "A identidade acessa mais de um workspace. Informe --workspace <id> para selecionar o workspace deste projeto.",
+      );
+    }
+    throw new Error(
+      "Não foi possível determinar o workspace. Informe --workspace <id> e confirme que a identidade técnica é membro dele.",
+    );
+  }
+  return { workspaceId, identity };
+}
+
+async function configure(api, client, options, context) {
+  if (!["codex", "claude"].includes(client)) {
+    throw new Error("Informe o cliente: biaws agent configure codex|claude");
+  }
+  const projectDirectory = path.resolve(options.project || process.cwd());
+  const { workspaceId } = await resolveWorkspaceId(api, context.workspaceId);
+  const target = skillTarget(client, projectDirectory);
+  const entrypoint = mcpEntrypoint(context.toolDirectory);
+  const configPath =
+    client === "codex"
+      ? await writeCodexConfiguration(
+          projectDirectory,
+          entrypoint,
+          context.envFile,
+          workspaceId,
+          options.force,
+        )
+      : await writeClaudeConfiguration(
+          projectDirectory,
+          entrypoint,
+          context.envFile,
+          workspaceId,
+          options.force,
+        );
+  const installation = await runSkillsCommand(api, "install-all", [], {
+    target,
+    force: options.force,
+    json: false,
+    quiet: true,
+  });
+  const result = {
+    client,
+    projectDirectory,
+    configPath,
+    skillTarget: target,
+    installation,
+    workspaceId,
+  };
+  if (options.json) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(`Cliente ${client} configurado em ${configPath}`);
+    console.log(`Skills disponíveis em ${target}`);
+  }
+  return result;
+}
+
+async function requestStatus(url, headers = {}) {
+  try {
+    const response = await fetch(url, { headers });
+    const body = await response.json().catch(() => null);
+    return {
+      ok: response.ok,
+      status: response.status,
+      detail: response.ok ? null : body?.error?.message || null,
+    };
+  } catch (error) {
+    return { ok: false, status: null, detail: error.message };
+  }
+}
+
+async function mcpStatus(entrypoint, envFile, workspaceId) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [entrypoint], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        ...(envFile ? { BIAWS_ENV_FILE: envFile } : {}),
+        ISSUE_WORKSPACE_ID: workspaceId,
+      },
+    });
+    let output = "";
+    let errorOutput = "";
+    let settled = false;
+    let toolsRequested = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      child.kill();
+      resolve(result);
+    };
+    const timeout = setTimeout(
+      () =>
+        finish({
+          ok: false,
+          detail: errorOutput.trim() || "MCP não respondeu em 5 segundos",
+        }),
+      5_000,
+    );
+    child.stderr.on("data", (chunk) => {
+      errorOutput += chunk;
+    });
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      const lines = output.split(/\r?\n/u);
+      output = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const message = JSON.parse(line);
+          if (message.id === 1 && message.result && !toolsRequested) {
+            toolsRequested = true;
+            child.stdin.write(
+              `${JSON.stringify({
+                jsonrpc: "2.0",
+                method: "notifications/initialized",
+                params: {},
+              })}\n${JSON.stringify({
+                jsonrpc: "2.0",
+                id: 2,
+                method: "tools/list",
+                params: {},
+              })}\n`,
+            );
+          }
+          if (message.id === 2 && Array.isArray(message.result?.tools)) {
+            finish({ ok: true, toolCount: message.result.tools.length });
+          }
+        } catch {
+          finish({ ok: false, detail: "MCP retornou uma resposta inválida" });
+        }
+      }
+    });
+    child.on("error", (error) => finish({ ok: false, detail: error.message }));
+    child.stdin.on("error", (error) =>
+      finish({ ok: false, detail: error.message }),
+    );
+    child.on("exit", (code) => {
+      if (!settled && code !== null) {
+        finish({
+          ok: false,
+          detail: errorOutput.trim() || `MCP encerrou com código ${code}`,
+        });
+      }
+    });
+    child.stdin.write(
+      `${JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {} },
+      })}\n`,
+    );
+  });
+}
+
+function configurationStatus(
+  client,
+  contents,
+  entrypoint,
+  envFile,
+  workspaceId,
+) {
+  if (typeof contents !== "string") {
+    return { ok: false, detail: "Configuração MCP não encontrada" };
+  }
+  if (client === "codex") {
+    const ok =
+      contents.includes("[mcp_servers.biaws]") &&
+      contents.includes(JSON.stringify(entrypoint)) &&
+      (!envFile || contents.includes(JSON.stringify(envFile))) &&
+      contents.includes(`ISSUE_WORKSPACE_ID = ${JSON.stringify(workspaceId)}`);
+    return {
+      ok,
+      detail: ok
+        ? null
+        : "A configuração Codex não aponta para a instância selecionada",
+    };
+  }
+  try {
+    const server = JSON.parse(contents).mcpServers?.biaws;
+    const ok =
+      server?.command === "node" &&
+      JSON.stringify(server.args || []) === JSON.stringify([entrypoint]) &&
+      (!envFile || server.env?.BIAWS_ENV_FILE === envFile) &&
+      server.env?.ISSUE_WORKSPACE_ID === workspaceId;
+    return {
+      ok,
+      detail: ok
+        ? null
+        : "A configuração Claude não aponta para a instância selecionada",
+    };
+  } catch {
+    return { ok: false, detail: "Configuração Claude contém JSON inválido" };
+  }
+}
+
+async function doctor(api, client, options, context) {
+  if (!["codex", "claude"].includes(client)) {
+    throw new Error("Informe o cliente: biaws agent doctor codex|claude");
+  }
+  const projectDirectory = path.resolve(options.project || process.cwd());
+  const target = skillTarget(client, projectDirectory);
+  const configPath =
+    client === "codex"
+      ? path.join(projectDirectory, ".codex", "config.toml")
+      : path.join(projectDirectory, ".mcp.json");
+  const entrypoint = mcpEntrypoint(context.toolDirectory);
+  const resolved = await resolveWorkspaceId(api, context.workspaceId);
+  const [health, mcp, configContents, lock] = await Promise.all([
+    requestStatus(`${context.apiUrl}/api/health`),
+    mcpStatus(entrypoint, context.envFile, resolved.workspaceId),
+    readOptional(configPath, null),
+    readLock(target),
+  ]);
+  const checks = {
+    node: { ok: Number(process.versions.node.split(".")[0]) >= 20 },
+    api: health,
+    authentication: { ok: true },
+    workspace: { ok: true, id: resolved.workspaceId },
+    mcp,
+    configuration: {
+      ...configurationStatus(
+        client,
+        configContents,
+        entrypoint,
+        context.envFile,
+        resolved.workspaceId,
+      ),
+      path: configPath,
+    },
+    skills: {
+      ok: Object.keys(lock.skills).length > 0,
+      count: Object.keys(lock.skills).length,
+      target,
+    },
+  };
+  const ok = Object.values(checks).every((check) => check.ok);
+  const result = { ok, client, checks };
+  if (options.json) console.log(JSON.stringify(result, null, 2));
+  else {
+    for (const [name, check] of Object.entries(checks)) {
+      console.log(`${check.ok ? "OK" : "FALHA"}  ${name}`);
+      if (!check.ok && check.detail) console.log(`       ${check.detail}`);
+    }
+  }
+  if (!ok) process.exitCode = 1;
+  return result;
+}
+
+export async function runAgentCommand(
+  api,
+  action,
+  positional,
+  options,
+  context,
+) {
+  const client = positional[0];
+  if (action === "configure") return configure(api, client, options, context);
+  if (action === "doctor") return doctor(api, client, options, context);
+  throw new Error(`Ação de agente desconhecida: ${action || "(ausente)"}`);
+}
+
+export default class Agent extends BaseCommand {
+  static description =
+    "Configura e diagnostica clientes de agentes (compatibilidade legada)";
+
+  async run() {
+    await showTopic(this, "agent");
+  }
+}
+
+export const TOOL_DIR = TOOL_DIRECTORY;

package/src/commands/api.js

@@ -0,0 +1,17 @@
+import { Help } from "@oclif/core";
+
+import { AuthenticatedApiCommand } from "../baseCommands.js";
+
+export default class Api extends AuthenticatedApiCommand {
+  static description =
+    "Executa operações autenticadas nos recursos da API do Bondia Workspaces";
+  static examples = [
+    "<%= config.bin %> api workspaces list --json",
+    "<%= config.bin %> api demands get <id-ou-código> --json",
+  ];
+
+  async run() {
+    await this.parse(Api);
+    await new Help(this.config).showHelp(["api"]);
+  }
+}

package/src/commands/applications/get.js

@@ -0,0 +1,17 @@
+import { Args } from "@oclif/core";
+import { connectionFlags, ReadCommand } from "../../domain/readCommand.js";
+export default class ApplicationGet extends ReadCommand {
+  static description = "Obtém uma aplicação por ID";
+  static args = { id: Args.string({ required: true }) };
+  static flags = connectionFlags;
+  async run() {
+    const { args, flags } = await this.parse(ApplicationGet);
+    const result = await this.read(flags, (api) => api.application(args.id), {
+      resource: "application",
+      operation: "get",
+    });
+    this.emit(flags, result, (p) =>
+      JSON.stringify(p.application || p, null, 2),
+    );
+  }
+}

package/src/commands/applications/list.js

@@ -0,0 +1,32 @@
+import {
+  connectionFlags,
+  listFlags,
+  ReadCommand,
+} from "../../domain/readCommand.js";
+import { table } from "../../domain/readService.js";
+export default class ApplicationList extends ReadCommand {
+  static description = "Lista aplicações do workspace";
+  static flags = { ...connectionFlags, ...listFlags };
+  async run() {
+    const { flags } = await this.parse(ApplicationList);
+    const result = await this.read(
+      flags,
+      (api, c) =>
+        api.applications(c.workspaceId, {
+          q: flags.search,
+          status: flags.status,
+          page: flags.page,
+          limit: flags.limit,
+        }),
+      { resource: "applications", operation: "list", requireWorkspace: true },
+    );
+    this.emit(flags, result, (p) =>
+      table(p.items || [], [
+        ["ID", (x) => x.id],
+        ["CHAVE", (x) => x.key],
+        ["NOME", (x) => x.name],
+        ["STATUS", (x) => x.status],
+      ]),
+    );
+  }
+}

package/src/commands/applications.js

@@ -0,0 +1,7 @@
+import { Command } from "@oclif/core";
+export default class Applications extends Command {
+  static description = "Consulta aplicações autorizadas pela API";
+  async run() {
+    await this.config.runCommand("help", ["applications"]);
+  }
+}

package/src/commands/configure/claude.js

@@ -0,0 +1,25 @@
+import { ProjectCommand } from "../../baseCommands.js";
+import {
+  configureContextFlags,
+  configureContextInput,
+  legacyAgentContext,
+} from "../../configure/command.js";
+import { runAgentCommand } from "../agent.js";
+
+export default class ConfigureClaude extends ProjectCommand {
+  static description =
+    "configura MCP e skills do Claude sem persistir credenciais no projeto";
+  static flags = configureContextFlags;
+
+  async run() {
+    const { flags } = await this.parse(ConfigureClaude);
+    const context = await this.projectContext(configureContextInput(flags));
+    await runAgentCommand(
+      context.api,
+      "configure",
+      ["claude"],
+      { ...flags, project: context.projectDirectory },
+      legacyAgentContext(context),
+    );
+  }
+}

package/src/commands/configure/codex.js

@@ -0,0 +1,25 @@
+import { ProjectCommand } from "../../baseCommands.js";
+import {
+  configureContextFlags,
+  configureContextInput,
+  legacyAgentContext,
+} from "../../configure/command.js";
+import { runAgentCommand } from "../agent.js";
+
+export default class ConfigureCodex extends ProjectCommand {
+  static description =
+    "configura MCP e skills do Codex sem persistir credenciais no projeto";
+  static flags = configureContextFlags;
+
+  async run() {
+    const { flags } = await this.parse(ConfigureCodex);
+    const context = await this.projectContext(configureContextInput(flags));
+    await runAgentCommand(
+      context.api,
+      "configure",
+      ["codex"],
+      { ...flags, project: context.projectDirectory },
+      legacyAgentContext(context),
+    );
+  }
+}

package/src/commands/configure/doctor.js

@@ -0,0 +1,49 @@
+import { wizardFlags, collectWizardValues } from "../../core/wizard.js";
+import { ProjectCommand } from "../../baseCommands.js";
+import {
+  clientArgument,
+  configureContextFlags,
+  configureContextInput,
+  legacyAgentContext,
+} from "../../configure/command.js";
+import { runAgentCommand } from "../agent.js";
+
+const definition = {
+  kind: "configure.doctor",
+  questions: [
+    {
+      name: "client",
+      type: "select",
+      message: "Cliente a diagnosticar",
+      choices: [
+        { name: "Codex", value: "codex" },
+        { name: "Claude", value: "claude" },
+      ],
+    },
+  ],
+};
+
+export default class ConfigureDoctor extends ProjectCommand {
+  static description = "diagnostica configuração, autenticação, MCP e skills";
+  static args = { client: clientArgument };
+  static flags = { ...configureContextFlags, ...wizardFlags };
+
+  async run() {
+    const { args, flags } = await this.parse(ConfigureDoctor);
+    const context = await this.projectContext(configureContextInput(flags));
+    const collected = await collectWizardValues(definition, {
+      environment: context.env,
+      flags: { client: args.client },
+      options: flags,
+      promptAdapter: this.adapters.prompts,
+      terminal: this.adapters.terminal,
+    });
+    await runAgentCommand(
+      context.api,
+      "doctor",
+      [collected.values.client],
+      { ...flags, project: context.projectDirectory },
+      legacyAgentContext(context),
+    );
+  }
+}

package/src/commands/configure/skills.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+
+import { Args, Flags } from "@oclif/core";
+
+import { ProjectCommand } from "../../baseCommands.js";
+import {
+  configureContextFlags,
+  configureContextInput,
+} from "../../configure/command.js";
+import { CliError } from "../../core/errors.js";
+import { runSkillsCommand } from "../skills.js";
+
+export default class ConfigureSkills extends ProjectCommand {
+  static description = "lista, instala, atualiza e verifica skills do projeto";
+  static args = {
+    action: Args.string({
+      description: "operação sobre as skills",
+      options: ["list", "install", "update", "verify"],
+      required: true,
+    }),
+    skill: Args.string({ description: "ID da skill", required: false }),
+  };
+  static flags = {
+    ...configureContextFlags,
+    client: Flags.string({
+      description: "diretório padrão do cliente",
+      options: ["codex", "claude"],
+      default: "codex",
+    }),
+    all: Flags.boolean({ description: "instala todas as skills publicadas" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(ConfigureSkills);
+    const context = await this.projectContext(configureContextInput(flags));
+    const target = path.join(
+      context.projectDirectory,
+      flags.client === "claude" ? ".claude" : ".agents",
+      "skills",
+    );
+    let action = args.action;
+    let positional = args.skill ? [args.skill] : [];
+    if (action === "install" && flags.all) action = "install-all";
+    if (action === "install" && !args.skill) {
+      if (!context.isInteractive) {
+        throw new CliError(
+          "Informe o ID da skill ou use --all em modo não interativo.",
+          { code: "SKILL_SELECTION_REQUIRED", exitCode: 2 },
+        );
+      }
+      const catalog = await context.api.list();
+      if (!catalog.items.length)
+        throw new CliError("Nenhuma skill publicada no catálogo.", {
+          code: "SKILL_CATALOG_EMPTY",
+        });
+      const selected = await this.adapters.prompts.ask({
+        name: "skill",
+        type: "select",
+        message: "Skill a instalar",
+        choices: catalog.items.map((item) => ({
+          name: `${item.skillId}@${item.latestVersion}`,
+          value: item.skillId,
+        })),
+      });
+      positional = [selected];
+    }
+    if (action === "verify") action = "status";
+    await runSkillsCommand(context.api, action, positional, {
+      force: flags.force,
+      json: flags.json,
+      target,
+    });
+  }
+}

package/src/commands/configure.js

@@ -0,0 +1,19 @@
+import { Help } from "@oclif/core";
+
+import { ProjectCommand } from "../baseCommands.js";
+
+export default class Configure extends ProjectCommand {
+  static description =
+    "Configura projetos, clientes de agentes e skills de desenvolvimento";
+  static examples = [
+    "<%= config.bin %> configure codex",
+    "<%= config.bin %> configure claude",
+    "<%= config.bin %> configure skills list",
+    "<%= config.bin %> configure doctor codex",
+  ];
+
+  async run() {
+    await this.parse(Configure);
+    await new Help(this.config).showHelp(["configure"]);
+  }
+}

package/src/commands/demands/complete-task.js

@@ -0,0 +1,6 @@
+import DemandTaskStatus from "./task-status.js";
+
+export default class DemandCompleteTask extends DemandTaskStatus {
+  static description = "Conclui uma tarefa de uma melhoria";
+  static defaultStatus = "Concluído";
+}

package/src/commands/demands/get.js

@@ -0,0 +1,16 @@
+import { Args } from "@oclif/core";
+import { connectionFlags, ReadCommand } from "../../domain/readCommand.js";
+export default class DemandGet extends ReadCommand {
+  static description = "Obtém uma melhoria por ID ou código";
+  static args = { id: Args.string({ required: true }) };
+  static flags = connectionFlags;
+  async run() {
+    const { args, flags } = await this.parse(DemandGet);
+    const result = await this.read(
+      flags,
+      (api, c) => api.demand(args.id, { workspaceId: c.workspaceId }),
+      { resource: "demand", operation: "get", requireWorkspace: true },
+    );
+    this.emit(flags, result, (p) => JSON.stringify(p.request || p, null, 2));
+  }
+}