flagshark 1.3.1 → 1.4.0

package/dist/cli.js

@@ -1,140 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, writeFileSync } from "node:fs";
 import { parse as parseYaml } from "yaml";
-import { scanRepo, FlagsharkConfigSchema } from "@flagshark/core";
-
-// src/formatter.ts
-var VERSION = "1.2.0";
-function pad(str, width) {
-  if (str.length > width) {
-    return str.slice(0, width - 1) + "\u2026";
-  }
-  return str.padEnd(width);
-}
-function buildTable(flags) {
-  const cols = {
-    flag: 16,
-    file: 22,
-    added: 13,
-    signal: 28
-  };
-  const hBorder = (left, mid, right) => `${left}${"\u2500".repeat(cols.flag + 2)}${mid}${"\u2500".repeat(cols.file + 2)}${mid}${"\u2500".repeat(cols.added + 2)}${mid}${"\u2500".repeat(cols.signal + 2)}${right}`;
-  const lines = [];
-  lines.push(hBorder("\u250C", "\u252C", "\u2510"));
-  lines.push(
-    `\u2502 ${pad("Flag", cols.flag)} \u2502 ${pad("File", cols.file)} \u2502 ${pad("Added", cols.added)} \u2502 ${pad("Signal", cols.signal)} \u2502`
-  );
-  lines.push(hBorder("\u251C", "\u253C", "\u2524"));
-  for (const sf of flags) {
-    const fileRef = `${sf.filePath}:${sf.lineNumber}`;
-    const signalText = sf.signals.map((s) => {
-      if (s.type === "age") {
-        return "Age > threshold";
-      }
-      if (s.type === "low-usage") {
-        return "Single file";
-      }
-      return s.description;
-    }).join(", ");
-    lines.push(
-      `\u2502 ${pad(sf.name, cols.flag)} \u2502 ${pad(fileRef, cols.file)} \u2502 ${pad(sf.age ?? "unknown", cols.added)} \u2502 ${pad(signalText, cols.signal)} \u2502`
-    );
-  }
-  lines.push(hBorder("\u2514", "\u2534", "\u2518"));
-  return lines.join("\n");
-}
-function formatText(result, options) {
-  const lines = [];
-  lines.push(`\u{1F988} FlagShark v${VERSION}`);
-  lines.push("");
-  const langCount = Object.keys(result.languageBreakdown).length;
-  lines.push(`Scanned ${result.filesScanned} files across ${langCount} language${langCount === 1 ? "" : "s"}`);
-  if (result.excludedCount && result.excludedCount > 0) {
-    lines.push(`(${result.excludedCount} excluded via .flagsharkignore + excludes)`);
-  }
-  if (result.totalFlags === 0) {
-    lines.push("No feature flags detected.");
-    lines.push("");
-    lines.push("Supported providers: LaunchDarkly, Unleash, Flipt, Split.io, PostHog, and more.");
-    lines.push("Run flagshark scan --help for configuration options.");
-    return lines.join("\n");
-  }
-  if (result.detectedProviders.length > 0) {
-    lines.push(`Detected providers: ${result.detectedProviders.join(", ")}`);
-  }
-  const uniqueStaleNames = new Set(result.staleFlags.map((f) => f.name));
-  const staleCount = uniqueStaleNames.size;
-  lines.push(`Found ${result.totalFlags} feature flags, ${staleCount} stale`);
-  if (staleCount > 0) {
-    lines.push("");
-    lines.push("Stale flags:");
-    const displayCount = options.verbose ? staleCount : Math.min(staleCount, options.maxDisplay);
-    const displayFlags = result.staleFlags.slice(0, displayCount);
-    lines.push(buildTable(displayFlags));
-    const remaining = staleCount - displayCount;
-    if (remaining > 0) {
-      lines.push("");
-      lines.push(`... and ${remaining} more (use --verbose to see all)`);
-    }
-  }
-  lines.push("");
-  if (staleCount === 0) {
-    lines.push(`Flag Health Score: ${result.healthScore}/100 \u2713 All flags look healthy!`);
-  } else {
-    lines.push(
-      `Flag Health Score: ${result.healthScore}/100 (${staleCount}/${result.totalFlags} flags are stale)`
-    );
-    lines.push("");
-    lines.push("Automate cleanup \u2192 https://flagshark.com");
-    lines.push("Open source CLI  \u2192 https://github.com/FlagShark/flagshark");
-  }
-  if (result.excludedPaths && result.excludedPaths.length > 0) {
-    lines.push("");
-    lines.push(`Excluded files (${result.excludedPaths.length}):`);
-    for (const p of result.excludedPaths) {
-      lines.push(`  ${p}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatJson(result) {
-  const languages = { ...result.languageBreakdown };
-  const flags = result.staleFlags.map((sf) => ({
-    name: sf.name,
-    file: sf.filePath,
-    line: sf.lineNumber,
-    language: sf.language,
-    provider: sf.provider,
-    stale: true,
-    signals: sf.signals.map((s) => ({
-      type: s.type,
-      description: s.description
-    })),
-    age: sf.age ?? null
-  }));
-  const output = {
-    version: VERSION,
-    totalFlags: result.totalFlags,
-    staleFlags: new Set(result.staleFlags.map((f) => f.name)).size,
-    healthScore: result.healthScore,
-    detectedProviders: result.detectedProviders,
-    languages,
-    flags,
-    excludedPaths: result.excludedPaths,
-    scanDuration: result.scanDuration,
-    links: {
-      dashboard: "https://flagshark.com",
-      cli: "https://github.com/FlagShark/flagshark",
-      npm: "https://www.npmjs.com/package/flagshark"
-    }
-  };
-  return JSON.stringify(output, null, 2);
+import { scanRepo, FlagsharkConfigSchema, selectFormatter } from "@flagshark/core";
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-
-// src/cli.ts
-var VERSION2 = "1.3.1";
+var VERSION = "1.3.1";
 var HELP_TEXT = `
 flagshark scan [options]
 
@@ -151,15 +24,27 @@ Configuration:
   --no-config              Skip config file discovery
   --no-ignore-file         Skip .flagsharkignore discovery
   --show-excluded          Show excluded files in text output
+
+Output:
+  --format <fmt>           Output format: text | json | markdown | csv | sarif (default: text)
+  --output <path> | -o     Write output to this file instead of stdout
+  --json                   Shorthand for --format json (deprecated, will be removed in v2)
+
+Platform integration:
+  --no-cache             Skip platform-flag cache, force re-fetch
+  --fail-on-error        Fail on any missing-in-platform flag (default: true)
+  --no-fail-on-error     Disable fail-on-error
 `.trim();
 function parseArgs(argv) {
   const args = {
     json: false,
+    format: "text",
     diff: null,
     threshold: void 0,
     verbose: false,
     help: false,
-    version: false
+    version: false,
+    failOnError: true
   };
   let i = 2;
   while (i < argv.length) {
@@ -172,6 +57,19 @@ function parseArgs(argv) {
     switch (arg) {
       case "--json":
         args.json = true;
+        args.format = "json";
+        break;
+      case "--format": {
+        const v = argv[++i];
+        if (!["text", "json", "markdown", "csv", "sarif"].includes(v)) {
+          throw new Error(`--format must be one of text, json, markdown, csv, sarif; got '${v}'`);
+        }
+        args.format = v;
+        break;
+      }
+      case "--output":
+      case "-o":
+        args.output = argv[++i];
         break;
       case "--diff":
         i++;
@@ -201,9 +99,7 @@ function parseArgs(argv) {
       case "--engine": {
         const value = argv[++i];
         if (value !== "regex" && value !== "tree-sitter") {
-          process.stderr.write(`Error: --engine must be 'regex' or 'tree-sitter', got '${value}'
-`);
-          process.exit(2);
+          throw new Error(`--engine must be 'regex' or 'tree-sitter', got '${value}'`);
         }
         args.engine = value;
         break;
@@ -224,6 +120,15 @@ function parseArgs(argv) {
       case "--show-excluded":
         args.showExcluded = true;
         break;
+      case "--no-cache":
+        args.noCache = true;
+        break;
+      case "--no-fail-on-error":
+        args.failOnError = false;
+        break;
+      case "--fail-on-error":
+        args.failOnError = true;
+        break;
       case "scan":
         break;
       default:
@@ -245,16 +150,23 @@ function createLogger(verbose) {
     error: (...args) => console.error("[error]", ...args)
   };
 }
-async function main() {
-  const args = parseArgs(process.argv);
+async function runCli(argv, io) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (err) {
+    io.stderr.write(`[error] ${toErrorMessage(err)}
+`);
+    return 2;
+  }
   if (args.version) {
-    process.stdout.write(`flagshark v${VERSION2}
+    io.stdout.write(`flagshark v${VERSION}
 `);
-    process.exit(0);
+    return 0;
   }
   if (args.help) {
-    process.stdout.write(HELP_TEXT + "\n");
-    process.exit(0);
+    io.stdout.write(HELP_TEXT + "\n");
+    return 0;
   }
   const logger = createLogger(args.verbose);
   if (args.diff) {
@@ -265,22 +177,29 @@ async function main() {
   let configOverride;
   if (args.configPath) {
     if (!existsSync(args.configPath)) {
-      process.stderr.write(`Error: config file not found: ${args.configPath}
+      io.stderr.write(`Error: config file not found: ${args.configPath}
 `);
-      process.exit(2);
+      return 2;
     }
     const raw = readFileSync(args.configPath, "utf-8");
-    const parsed = parseYaml(raw);
+    let parsed;
+    try {
+      parsed = parseYaml(raw);
+    } catch (err) {
+      io.stderr.write(`Error: invalid YAML at ${args.configPath}: ${toErrorMessage(err)}
+`);
+      return 2;
+    }
     const configResult = FlagsharkConfigSchema.safeParse(parsed);
     if (!configResult.success) {
-      process.stderr.write(`Error: invalid config at ${args.configPath}: ${configResult.error.message}
+      io.stderr.write(`Error: invalid config at ${args.configPath}: ${configResult.error.message}
 `);
-      process.exit(2);
+      return 2;
     }
     configOverride = configResult.data;
   }
   const result = await scanRepo({
-    cwd: process.cwd(),
+    cwd: io.cwd,
     threshold: args.threshold,
     diff: args.diff ?? void 0,
     engine: args.engine,
@@ -288,6 +207,7 @@ async function main() {
     noConfig: args.noConfig,
     noIgnoreFile: args.noIgnoreFile,
     collectExcludedPaths: args.showExcluded,
+    noCache: args.noCache,
     logger
   });
   if (args.verbose && result.effectiveExcludes) {
@@ -299,20 +219,36 @@ async function main() {
       ...r.ignoreFile.map((p) => `.flagsharkignore: ${p}`)
     ];
     if (allRules.length > 0) {
-      process.stderr.write("Effective excludes:\n");
-      for (const rule of allRules) process.stderr.write(`  ${rule}
+      io.stderr.write("Effective excludes:\n");
+      for (const rule of allRules) io.stderr.write(`  ${rule}
 `);
     }
   }
-  const output = args.json ? formatJson(result) + "\n" : formatText(result, { json: false, verbose: args.verbose, maxDisplay: 10 }) + "\n";
-  const exitCode = result.staleFlags.length > 0 ? 1 : 0;
-  if (process.stdout.write(output)) {
-    process.exit(exitCode);
-  } else {
-    process.stdout.once("drain", () => process.exit(exitCode));
+  const formatter = selectFormatter(args.format);
+  const output = formatter(result, {
+    version: VERSION,
+    scanMode: args.diff ? "changed" : "full",
+    verbose: args.verbose
+  });
+  const hasErrorSignals = result.staleFlags.some(
+    (f) => f.signals.some((s) => s.severity === "error")
+  );
+  const exitCode = args.failOnError && hasErrorSignals ? 1 : result.staleFlags.length > 0 ? 1 : 0;
+  if (args.output) {
+    writeFileSync(args.output, output);
+    return exitCode;
   }
+  const finalOutput = output.endsWith("\n") ? output : output + "\n";
+  io.stdout.write(finalOutput);
+  return exitCode;
 }
-main().catch((err) => {
+
+// src/main.ts
+runCli(process.argv, {
+  stdout: process.stdout,
+  stderr: process.stderr,
+  cwd: process.cwd()
+}).then((code) => process.exit(code)).catch((err) => {
   console.error(`[error] ${err instanceof Error ? err.message : String(err)}`);
   process.exit(2);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagshark",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "type": "module",
   "description": "Find stale feature flags in your codebase",
   "license": "MIT",
@@ -17,17 +17,19 @@
 "main": "./dist/cli.js",
 "files": ["dist/", "bin/"],
 "scripts": {
-  "build": "esbuild src/cli.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/cli.js --external:zod --external:@flagshark/core --external:yaml",
-  "test": "vitest run",
+  "build": "esbuild src/main.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/cli.js --external:zod --external:@flagshark/core --external:yaml",
+  "test": "bun run build && vitest run",
+  "test:coverage": "bun run build && vitest run --coverage",
   "typecheck": "tsc --noEmit"
 },
 "dependencies": {
-  "@flagshark/core": "1.3.1",
+  "@flagshark/core": "1.4.0",
   "yaml": "^2.4.0",
   "zod": "^3.23.0"
 },
 "devDependencies": {
   "@types/node": "^22.0.0",
+  "@vitest/coverage-v8": "^3.0.0",
   "esbuild": "^0.24.0",
   "typescript": "^5.7.0",
   "vitest": "^3.0.0"