cloudburn 0.5.0 → 0.6.0

package/dist/cli.js

@@ -5,11 +5,8 @@ import { pathToFileURL } from "url";
 import { Command } from "commander";
 
 // src/commands/discover.ts
-import {
-  assertValidAwsRegion,
-  CloudBurnClient
-} from "@cloudburn/sdk";
-import { InvalidArgumentError } from "commander";
+import { assertValidAwsRegion, CloudBurnClient } from "@cloudburn/sdk";
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
 
 // src/exit-codes.ts
 var EXIT_CODE_OK = 0;
@@ -59,8 +56,8 @@ var categorize = (err) => {
   };
 };
 
-// src/formatters/json.ts
-var formatJson = (result) => JSON.stringify(result, null, 2);
+// src/formatters/output.ts
+import { InvalidArgumentError } from "commander";
 
 // src/formatters/shared.ts
 var flattenScanResult = (result) => result.providers.flatMap(
@@ -77,82 +74,192 @@ var flattenScanResult = (result) => result.providers.flatMap(
 );
 var countScanResultFindings = (result) => flattenScanResult(result).length;
 
-// src/formatters/sarif.ts
-var toSarifLocation = (finding) => {
-  if (!finding.location) {
-    return void 0;
+// src/formatters/output.ts
+var supportedOutputFormats = ["text", "json", "table"];
+var scanColumns = [
+  { key: "provider", header: "Provider" },
+  { key: "ruleId", header: "RuleId" },
+  { key: "source", header: "Source" },
+  { key: "service", header: "Service" },
+  { key: "resourceId", header: "ResourceId" },
+  { key: "accountId", header: "AccountId" },
+  { key: "region", header: "Region" },
+  { key: "path", header: "Path" },
+  { key: "startLine", header: "StartLine" },
+  { key: "startColumn", header: "StartColumn" },
+  { key: "message", header: "Message" }
+];
+var formatOptionDescription = "Output format. table: human-readable terminal output. text: tab-delimited output for grep, sed, and awk. json: machine-readable output for automation and downstream systems.";
+var OUTPUT_FORMAT_OPTION_DESCRIPTION = formatOptionDescription;
+var parseOutputFormat = (value) => {
+  if (supportedOutputFormats.includes(value)) {
+    return value;
   }
-  return [
-    {
-      physicalLocation: {
-        artifactLocation: {
-          uri: finding.location.path
-        },
-        region: {
-          startLine: finding.location.startLine,
-          startColumn: finding.location.startColumn,
-          ...finding.location.endLine ? { endLine: finding.location.endLine } : {},
-          ...finding.location.endColumn ? { endColumn: finding.location.endColumn } : {}
-        }
-      }
+  throw new InvalidArgumentError(`Invalid format "${value}". Allowed formats: ${supportedOutputFormats.join(", ")}.`);
+};
+var resolveOutputFormat = (command, localFormat, defaultFormat = "table") => {
+  if (localFormat) {
+    return localFormat;
+  }
+  const options = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : command.opts();
+  return options.format ?? defaultFormat;
+};
+var renderResponse = (response, format) => {
+  switch (format) {
+    case "json":
+      return renderJson(response);
+    case "text":
+      return renderText(response);
+    case "table":
+      return renderTable(response);
+  }
+};
+var renderJson = (response) => {
+  switch (response.kind) {
+    case "document":
+      return JSON.stringify({ content: response.content, contentType: response.contentType }, null, 2);
+    case "record-list":
+      return JSON.stringify(response.rows, null, 2);
+    case "rule-list":
+      return JSON.stringify(response.rules, null, 2);
+    case "scan-result":
+      return JSON.stringify(response.result, null, 2);
+    case "status":
+      return JSON.stringify(response.data, null, 2);
+    case "string-list":
+      return JSON.stringify(response.values, null, 2);
+  }
+};
+var renderText = (response) => {
+  switch (response.kind) {
+    case "document":
+      return response.content;
+    case "record-list":
+      return renderTextRows(response.rows, response.columns, response.emptyMessage);
+    case "rule-list":
+      return renderRuleList(response.rules, response.emptyMessage);
+    case "scan-result":
+      return renderTextRows(projectScanRows(response.result), scanColumns, "No findings.");
+    case "status":
+      return response.text;
+    case "string-list":
+      return response.values.length === 0 ? response.emptyMessage : response.values.join("\n");
+  }
+};
+var renderTable = (response) => {
+  switch (response.kind) {
+    case "document":
+      return renderAsciiTable(
+        [
+          { Field: "ContentType", Value: response.contentType },
+          { Field: "Content", Value: response.content }
+        ],
+        [
+          { key: "Field", header: "Field" },
+          { key: "Value", header: "Value" }
+        ]
+      );
+    case "record-list":
+      return response.rows.length === 0 ? response.emptyMessage : renderAsciiTable(response.rows, response.columns ?? inferColumns(response.rows));
+    case "rule-list":
+      return renderRuleList(response.rules, response.emptyMessage);
+    case "scan-result": {
+      const rows = projectScanRows(response.result);
+      return rows.length === 0 ? "No findings." : renderAsciiTable(rows, scanColumns);
     }
-  ];
+    case "status":
+      return renderAsciiTable(
+        Object.entries(response.data).map(([field, value]) => ({ Field: field, Value: value })),
+        [
+          { key: "Field", header: "Field" },
+          { key: "Value", header: "Value" }
+        ]
+      );
+    case "string-list":
+      return response.values.length === 0 ? response.emptyMessage : renderAsciiTable(
+        response.values.map((value) => ({ [response.columnHeader]: value })),
+        [{ key: response.columnHeader, header: response.columnHeader }]
+      );
+  }
 };
-var formatSarif = (result) => JSON.stringify(
-  {
-    version: "2.1.0",
-    runs: [
-      {
-        tool: {
-          driver: {
-            name: "cloudburn"
-          }
-        },
-        results: flattenScanResult(result).map(({ ruleId, message, finding }) => ({
-          ruleId,
-          // Severity was intentionally removed — all findings are warnings until a priority model is added.
-          level: "warning",
-          message: { text: message },
-          ...finding.location ? { locations: toSarifLocation(finding) } : {}
-        }))
-      }
-    ]
-  },
-  null,
-  2
-);
-
-// src/formatters/table.ts
-var formatTable = (result) => {
-  const flattenedFindings = flattenScanResult(result);
-  if (flattenedFindings.length === 0) {
-    return "No findings.";
+var projectScanRows = (result) => flattenScanResult(result).map(({ finding, message, provider, ruleId, service, source }) => ({
+  accountId: finding.accountId ?? "",
+  message,
+  path: finding.location?.path ?? "",
+  provider,
+  region: finding.region ?? "",
+  resourceId: finding.resourceId,
+  ruleId,
+  service,
+  source,
+  startColumn: finding.location?.startColumn ?? "",
+  startLine: finding.location?.startLine ?? ""
+}));
+var renderTextRows = (rows, columns, emptyMessage) => {
+  if (rows.length === 0) {
+    return emptyMessage;
   }
-  return flattenedFindings.map(({ provider, ruleId, source, service, message, finding }) => {
-    const location = finding.location ? ` ${finding.location.path}:${finding.location.startLine}:${finding.location.startColumn}` : "";
-    return `${provider} ${ruleId} ${source} ${service} ${finding.resourceId}${location} ${message}`;
-  }).join("\n");
+  const resolvedColumns = columns ?? inferColumns(rows);
+  return rows.map((row) => resolvedColumns.map((column) => toTextCell(row[column.key])).join("	")).join("\n");
 };
-
-// src/commands/discover.ts
-var supportedDiscoverFormats = ["table", "json", "sarif"];
-var parseDiscoverFormat = (value) => {
-  if (supportedDiscoverFormats.includes(value)) {
-    return value;
+var inferColumns = (rows) => {
+  const keys = Array.from(new Set(rows.flatMap((row) => Object.keys(row)))).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  return keys.map((key) => ({ key, header: key }));
+};
+var renderRuleList = (rules, emptyMessage) => {
+  if (rules.length === 0) {
+    return emptyMessage;
   }
-  throw new InvalidArgumentError(`Invalid format "${value}". Allowed formats: ${supportedDiscoverFormats.join(", ")}.`);
+  let currentProvider = "";
+  let currentService = "";
+  const lines = [];
+  for (const rule of rules) {
+    if (rule.provider !== currentProvider) {
+      currentProvider = rule.provider;
+      currentService = "";
+      lines.push(rule.provider);
+    }
+    if (rule.service !== currentService) {
+      currentService = rule.service;
+      lines.push(`  ${rule.service}`);
+    }
+    lines.push(`    ${rule.id}: ${rule.description}`);
+  }
+  return lines.join("\n");
 };
-var parseDiscoverListFormat = (value) => {
-  if (value === "table" || value === "json") {
+var toTextCell = (value) => {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
     return value;
   }
-  throw new InvalidArgumentError("Invalid format. Allowed formats: table, json.");
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+};
+var toTableCell = (value) => toTextCell(value).replace(/\r?\n/g, "\\n");
+var renderAsciiTable = (rows, columns) => {
+  const widths = columns.map(
+    (column) => Math.max(column.header.length, ...rows.map((row) => toTableCell(row[column.key]).length))
+  );
+  const border = `+${widths.map((width) => "-".repeat(width + 2)).join("+")}+`;
+  const header = `| ${columns.map((column, index) => column.header.padEnd(widths[index] ?? 0)).join(" | ")} |`;
+  const body = rows.map(
+    (row) => `| ${columns.map((column, index) => toTableCell(row[column.key]).padEnd(widths[index] ?? 0)).join(" | ")} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
 };
+
+// src/commands/discover.ts
 var parseAwsRegion = (value) => {
   try {
     return assertValidAwsRegion(value);
   } catch (err) {
-    throw new InvalidArgumentError(err instanceof Error ? err.message : "Invalid AWS region.");
+    throw new InvalidArgumentError2(err instanceof Error ? err.message : "Invalid AWS region.");
   }
 };
 var parseDiscoverRegion = (value) => {
@@ -162,16 +269,6 @@ var parseDiscoverRegion = (value) => {
   return parseAwsRegion(value);
 };
 var resolveDiscoveryTarget = (region) => region === void 0 ? { mode: "current" } : region === "all" ? { mode: "all" } : { mode: "region", region };
-var scanFormatters = {
-  json: formatJson,
-  sarif: formatSarif,
-  table: formatTable
-};
-var formatValue = (value) => JSON.stringify(value, null, 2);
-var formatEnabledRegions = (regions) => regions.length === 0 ? "No Resource Explorer indexes are enabled." : regions.map(({ region, type }) => `${region}	${type}`).join("\n");
-var formatSupportedResourceTypes = (resourceTypes) => resourceTypes.length === 0 ? "No supported resource types were returned." : resourceTypes.map(({ resourceType, service }) => `${resourceType}	${service ?? "unknown"}`).join("\n");
-var formatInitializationResult = (result) => result.status === "EXISTING" ? `Resource Explorer setup already exists in ${result.aggregatorRegion}.` : `Resource Explorer setup created in ${result.aggregatorRegion}.`;
-var resolveListFormat = (parentCommand, options) => parentCommand.opts().format === "json" ? "json" : options.format ?? "table";
 var runCommand = async (action) => {
   try {
     process.exitCode = await action() ?? EXIT_CODE_OK;
@@ -186,7 +283,7 @@ var registerDiscoverCommand = (program) => {
     "--region <region>",
     'Discovery region to use. Pass "all" to require an aggregator index.',
     parseDiscoverRegion
-  ).option("--format <format>", "Output format: table|json|sarif", parseDiscoverFormat, "table").option("--exit-code", "Exit with code 1 when findings exist").addHelpText(
+  ).option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).option("--exit-code", "Exit with code 1 when findings exist").addHelpText(
     "after",
     `
 Examples:
@@ -196,11 +293,12 @@ Examples:
   cloudburn discover list-enabled-regions
   cloudburn discover init
 `
-  ).action(async (options) => {
+  ).action(async (options, command) => {
     await runCommand(async () => {
       const scanner = new CloudBurnClient();
       const result = await scanner.discover({ target: resolveDiscoveryTarget(options.region) });
-      const output = scanFormatters[options.format ?? "table"](result);
+      const format = resolveOutputFormat(command, options.format);
+      const output = renderResponse({ kind: "scan-result", result }, format);
       process.stdout.write(`${output}
 `);
       if (options.exitCode && countScanResultFindings(result) > 0) {
@@ -209,34 +307,75 @@ Examples:
       return EXIT_CODE_OK;
     });
   });
-  discoverCommand.command("list-enabled-regions").description("List AWS regions with a local or aggregator Resource Explorer index").option("--format <format>", "Output format: table|json", parseDiscoverListFormat, "table").action(async (options) => {
+  discoverCommand.command("list-enabled-regions").description("List AWS regions with a local or aggregator Resource Explorer index").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).action(async (options, command) => {
     await runCommand(async () => {
       const scanner = new CloudBurnClient();
       const regions = await scanner.listEnabledDiscoveryRegions();
-      const format = resolveListFormat(discoverCommand, options);
-      const output = format === "json" ? formatValue(regions) : formatEnabledRegions(regions);
+      const format = resolveOutputFormat(command, options.format);
+      const output = renderResponse(
+        {
+          kind: "record-list",
+          columns: [
+            { key: "region", header: "Region" },
+            { key: "type", header: "Type" }
+          ],
+          emptyMessage: "No Resource Explorer indexes are enabled.",
+          rows: regions
+        },
+        format
+      );
       process.stdout.write(`${output}
 `);
       return EXIT_CODE_OK;
     });
   });
-  discoverCommand.command("init").description("Set up AWS Resource Explorer for CloudBurn").option("--region <region>", "Aggregator region to create or reuse during setup", parseAwsRegion).action(async (options) => {
+  discoverCommand.command("init").description("Set up AWS Resource Explorer for CloudBurn").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).option("--region <region>", "Aggregator region to create or reuse during setup", parseAwsRegion).action(async (options, command) => {
     await runCommand(async () => {
       const scanner = new CloudBurnClient();
       const parentRegion = discoverCommand.opts().region;
       const region = options.region ?? (parentRegion === "all" ? void 0 : parentRegion);
       const result = await scanner.initializeDiscovery({ region });
-      process.stdout.write(`${formatInitializationResult(result)}
+      const message = result.status === "EXISTING" ? `Resource Explorer setup already exists in ${result.aggregatorRegion}.` : `Resource Explorer setup created in ${result.aggregatorRegion}.`;
+      const format = resolveOutputFormat(command, options.format);
+      const output = renderResponse(
+        {
+          kind: "status",
+          data: {
+            aggregatorRegion: result.aggregatorRegion,
+            message,
+            regions: result.regions,
+            status: result.status,
+            taskId: result.taskId ?? ""
+          },
+          text: message
+        },
+        format
+      );
+      process.stdout.write(`${output}
 `);
       return EXIT_CODE_OK;
     });
   });
-  discoverCommand.command("supported-resource-types").description("List Resource Explorer supported AWS resource types").option("--format <format>", "Output format: table|json", parseDiscoverListFormat, "table").action(async (options) => {
+  discoverCommand.command("supported-resource-types").description("List Resource Explorer supported AWS resource types").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).action(async (options, command) => {
     await runCommand(async () => {
       const scanner = new CloudBurnClient();
       const resourceTypes = await scanner.listSupportedDiscoveryResourceTypes();
-      const format = resolveListFormat(discoverCommand, options);
-      const output = format === "json" ? formatValue(resourceTypes) : formatSupportedResourceTypes(resourceTypes);
+      const format = resolveOutputFormat(command, options.format);
+      const output = renderResponse(
+        {
+          kind: "record-list",
+          columns: [
+            { key: "resourceType", header: "ResourceType" },
+            { key: "service", header: "Service" }
+          ],
+          emptyMessage: "No supported resource types were returned.",
+          rows: resourceTypes.map((resourceType) => ({
+            resourceType: resourceType.resourceType,
+            service: resourceType.service ?? "unknown"
+          }))
+        },
+        format
+      );
       process.stdout.write(`${output}
 `);
       return EXIT_CODE_OK;
@@ -246,12 +385,38 @@ Examples:
 
 // src/commands/estimate.ts
 var registerEstimateCommand = (program) => {
-  program.command("estimate").description("Request optional pricing estimates from a self-hosted dashboard").option("--server <url>", "Dashboard API base URL").action((options) => {
+  program.command("estimate").description("Request optional pricing estimates from a self-hosted dashboard").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).option("--server <url>", "Dashboard API base URL").action((options, command) => {
+    const format = resolveOutputFormat(command, options.format);
     if (!options.server) {
-      process.stdout.write("No server configured. This command is optional and requires a dashboard URL.\n");
+      const output2 = renderResponse(
+        {
+          kind: "status",
+          data: {
+            message: "No server configured. This command is optional and requires a dashboard URL.",
+            server: "",
+            status: "NOT_CONFIGURED"
+          },
+          text: "No server configured. This command is optional and requires a dashboard URL."
+        },
+        format
+      );
+      process.stdout.write(`${output2}
+`);
       return;
     }
-    process.stdout.write(`Estimate request scaffold ready for server: ${options.server}
+    const output = renderResponse(
+      {
+        kind: "status",
+        data: {
+          message: `Estimate request scaffold ready for server: ${options.server}`,
+          server: options.server,
+          status: "READY"
+        },
+        text: `Estimate request scaffold ready for server: ${options.server}`
+      },
+      format
+    );
+    process.stdout.write(`${output}
 `);
   });
 };
@@ -260,49 +425,48 @@ var registerEstimateCommand = (program) => {
 var starterConfig = `version: 1
 profile: dev
 
-profiles:
-  dev:
-    ec2-allowed-instance-types:
-      allow: [t3.micro, t3.small, t3.medium]
-
+# Profiles are parsed but not applied yet, so configure the active rules block directly for now.
 rules:
-  ec2-allowed-instance-types:
+  ec2-instance-type-preferred:
     severity: error
 `;
 var registerInitCommand = (program) => {
-  program.command("init").description("Print a starter .cloudburn.yml configuration").action(() => {
-    process.stdout.write(`${starterConfig}
+  program.command("init").description("Print a starter .cloudburn.yml configuration").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).action((options, command) => {
+    const output = renderResponse(
+      {
+        kind: "document",
+        content: starterConfig,
+        contentType: "application/yaml"
+      },
+      resolveOutputFormat(command, options.format, "text")
+    );
+    process.stdout.write(`${output}
 `);
   });
 };
 
 // src/commands/rules-list.ts
-import { awsCorePreset } from "@cloudburn/sdk";
+import { builtInRuleMetadata } from "@cloudburn/sdk";
 var registerRulesListCommand = (program) => {
-  const rulesCommand = program.command("rules").description("Inspect built-in and custom rules");
-  rulesCommand.command("list").description("List built-in CloudBurn rule IDs").action(() => {
-    process.stdout.write(`${awsCorePreset.ruleIds.join("\n")}
+  const rulesCommand = program.command("rules").description("Inspect built-in CloudBurn rules");
+  rulesCommand.command("list").description("List built-in CloudBurn rules").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).action((options, command) => {
+    const output = renderResponse(
+      {
+        kind: "rule-list",
+        emptyMessage: "No built-in rules are available.",
+        rules: builtInRuleMetadata
+      },
+      resolveOutputFormat(command, options.format, "text")
+    );
+    process.stdout.write(`${output}
 `);
   });
 };
 
 // src/commands/scan.ts
 import { CloudBurnClient as CloudBurnClient2 } from "@cloudburn/sdk";
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
-var supportedScanFormats = ["table", "json", "sarif"];
-var parseScanFormat = (value) => {
-  if (supportedScanFormats.includes(value)) {
-    return value;
-  }
-  throw new InvalidArgumentError2(`Invalid format "${value}". Allowed formats: ${supportedScanFormats.join(", ")}.`);
-};
-var formatters = {
-  json: formatJson,
-  sarif: formatSarif,
-  table: formatTable
-};
 var registerScanCommand = (program) => {
-  program.command("scan").description("Run an autodetected static IaC scan").argument("[path]", "Terraform file, CloudFormation template, or directory to scan").option("--format <format>", "Output format: table|json|sarif", parseScanFormat, "table").option("--exit-code", "Exit with code 1 when findings exist").addHelpText(
+  program.command("scan").description("Run an autodetected static IaC scan").argument("[path]", "Terraform file, CloudFormation template, or directory to scan").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat).option("--exit-code", "Exit with code 1 when findings exist").addHelpText(
     "after",
     `
 Examples:
@@ -310,12 +474,12 @@ Examples:
   cloudburn scan ./template.yaml
   cloudburn scan ./iac
 `
-  ).action(async (path, options) => {
+  ).action(async (path, options, command) => {
     try {
       const scanner = new CloudBurnClient2();
       const result = await scanner.scanStatic(path ?? process.cwd());
-      const format = formatters[options.format ?? "table"];
-      const output = format(result);
+      const format = resolveOutputFormat(command, options.format);
+      const output = renderResponse({ kind: "scan-result", result }, format);
       process.stdout.write(`${output}
 `);
       if (options.exitCode && countScanResultFindings(result) > 0) {
@@ -334,7 +498,7 @@ Examples:
 // src/cli.ts
 var createProgram = () => {
   const program = new Command();
-  program.name("cloudburn").description("Know what you spend. Fix what you waste.").version("0.5.0");
+  program.name("cloudburn").description("Know what you spend. Fix what you waste.").version("0.6.0").option("--format <format>", OUTPUT_FORMAT_OPTION_DESCRIPTION, parseOutputFormat);
   registerDiscoverCommand(program);
   registerScanCommand(program);
   registerInitCommand(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudburn",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Cloudburn CLI for cloud cost optimization",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
   ],
   "dependencies": {
     "commander": "^13.1.0",
-    "@cloudburn/sdk": "0.8.0"
+    "@cloudburn/sdk": "0.8.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.6",