dialekt 0.1.0 → 0.1.1

package/src/cli/format.ts

@@ -12,21 +12,21 @@
 
 // ─── Output format ──────────────────────────────────────────────────────────
 
-export type OutputFormat = 'pretty' | 'json';
+export type OutputFormat = "pretty" | "json";
 
 /**
  * Environment variables that signal dialekt is running inside an AI agent.
  * When any is set (truthy), or stdout is not a TTY, JSON mode is the default.
  */
 export const AGENT_ENV_VARS = [
-  'CLAUDE_CODE',
-  'CLAUDECODE',
-  'CURSOR',
-  'CURSOR_TRACE_ID',
-  'DEVIN',
-  'GEMINI_CLI',
-  'AGENT_TASK_ID',
-  'AIDER_CHAT',
+  "CLAUDE_CODE",
+  "CLAUDECODE",
+  "CURSOR",
+  "CURSOR_TRACE_ID",
+  "DEVIN",
+  "GEMINI_CLI",
+  "AGENT_TASK_ID",
+  "AIDER_CHAT",
 ] as const;
 
 /**
@@ -38,23 +38,23 @@ export const AGENT_ENV_VARS = [
  */
 export function detectFormat(explicit?: OutputFormat | undefined): OutputFormat {
   if (explicit !== undefined) return explicit;
-  if (!process.stdout.isTTY) return 'json';
-  if (AGENT_ENV_VARS.some((k) => process.env[k])) return 'json';
-  return 'pretty';
+  if (!process.stdout.isTTY) return "json";
+  if (AGENT_ENV_VARS.some((k) => process.env[k])) return "json";
+  return "pretty";
 }
 
 // ─── ANSI colours ────────────────────────────────────────────────────────────
 
 const C = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
 } as const;
 
 function isTty(): boolean {
@@ -64,7 +64,7 @@ function isTty(): boolean {
 /** Wraps text in ANSI codes only when stdout is a TTY; otherwise returns it bare. */
 export function color(text: string, ...codes: string[]): string {
   if (!isTty()) return text;
-  return `${codes.join('')}${text}${C.reset}`;
+  return `${codes.join("")}${text}${C.reset}`;
 }
 
 // ─── Box-drawing glyphs ──────────────────────────────────────────────────────
@@ -91,39 +91,39 @@ interface Glyphs {
 const PRETTY_GLYPHS: Glyphs = {
   hLine: String.fromCharCode(0x2500),
   vLine: String.fromCharCode(0x2502),
-  cornerTL: String.fromCharCode(0x250C),
+  cornerTL: String.fromCharCode(0x250c),
   cornerTR: String.fromCharCode(0x2510),
   cornerBL: String.fromCharCode(0x2514),
   cornerBR: String.fromCharCode(0x2518),
-  teeRight: String.fromCharCode(0x251C),
+  teeRight: String.fromCharCode(0x251c),
   teeLeft: String.fromCharCode(0x2524),
-  teeDown: String.fromCharCode(0x252C),
+  teeDown: String.fromCharCode(0x252c),
   teeUp: String.fromCharCode(0x2534),
-  cross: String.fromCharCode(0x253C),
+  cross: String.fromCharCode(0x253c),
   bullet: String.fromCharCode(0x2022),
   arrow: String.fromCharCode(0x2192),
   check: String.fromCharCode(0x2713),
   crossMark: String.fromCharCode(0x2717),
-  warn: String.fromCharCode(0x26A0),
+  warn: String.fromCharCode(0x26a0),
 };
 
 const ASCII_GLYPHS: Glyphs = {
-  hLine: '-',
-  vLine: '|',
-  cornerTL: '+',
-  cornerTR: '+',
-  cornerBL: '+',
-  cornerBR: '+',
-  teeRight: '+',
-  teeLeft: '+',
-  teeDown: '+',
-  teeUp: '+',
-  cross: '+',
-  bullet: '*',
-  arrow: '>',
-  check: '+',
-  crossMark: 'x',
-  warn: '!',
+  hLine: "-",
+  vLine: "|",
+  cornerTL: "+",
+  cornerTR: "+",
+  cornerBL: "+",
+  cornerBR: "+",
+  teeRight: "+",
+  teeLeft: "+",
+  teeDown: "+",
+  teeUp: "+",
+  cross: "+",
+  bullet: "*",
+  arrow: ">",
+  check: "+",
+  crossMark: "x",
+  warn: "!",
 };
 
 export function glyphs(): Glyphs {
@@ -134,38 +134,35 @@ export function glyphs(): Glyphs {
 
 export function drawTable(
   headers: readonly string[],
-  rows: readonly (readonly string[])[]
+  rows: readonly (readonly string[])[],
 ): string {
   const g = glyphs();
   const colWidths = headers.map((h, i) =>
-    Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length))
+    Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
   );
 
   const pad = (text: string, width: number) => text.padEnd(width);
 
-  const hLine = g.cornerTL +
-    colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.teeDown) +
-    g.cornerTR;
+  const hLine =
+    g.cornerTL + colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.teeDown) + g.cornerTR;
 
-  const headerRow = g.vLine +
+  const headerRow =
+    g.vLine +
     headers.map((h, i) => ` ${color(pad(h, colWidths[i]!), C.bold)} `).join(g.vLine) +
     g.vLine;
 
-  const separator = g.teeRight +
-    colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.cross) +
-    g.teeLeft;
+  const separator =
+    g.teeRight + colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.cross) + g.teeLeft;
 
-  const dataRows = rows.map((row) =>
-    g.vLine +
-    row.map((cell, i) => ` ${pad(cell, colWidths[i]!)} `).join(g.vLine) +
-    g.vLine
+  const dataRows = rows.map(
+    (row) =>
+      g.vLine + row.map((cell, i) => ` ${pad(cell, colWidths[i]!)} `).join(g.vLine) + g.vLine,
   );
 
-  const bottomLine = g.cornerBL +
-    colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.teeUp) +
-    g.cornerBR;
+  const bottomLine =
+    g.cornerBL + colWidths.map((w) => g.hLine.repeat(w + 2)).join(g.teeUp) + g.cornerBR;
 
-  return [hLine, headerRow, separator, ...dataRows, bottomLine].join('\n');
+  return [hLine, headerRow, separator, ...dataRows, bottomLine].join("\n");
 }
 
 // ─── Banner / header helpers ─────────────────────────────────────────────────

package/src/cli/formatters.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from "vitest";
 import {
   formatMissingKeys,
   formatUnusedKeys,
@@ -8,179 +8,201 @@ import {
   formatAdd,
   formatBenchmark,
   formatError,
-} from './formatters.js';
+} from "./formatters.js";
 
-describe('formatMissingKeys', () => {
-  it('returns JSON array in json mode', () => {
-    const entries = [{ adapter: 'a', locale: 'de', resource: 'r', key: 'k' }];
-    const result = formatMissingKeys(entries, 'json');
+describe("formatMissingKeys", () => {
+  it("returns JSON array in json mode", () => {
+    const entries = [{ adapter: "a", locale: "de", resource: "r", key: "k" }];
+    const result = formatMissingKeys(entries, "json");
     expect(JSON.parse(result)).toEqual(entries);
   });
 
-  it('returns success message when empty in pretty mode', () => {
-    const result = formatMissingKeys([], 'pretty');
-    expect(result).toContain('complete');
+  it("returns success message when empty in pretty mode", () => {
+    const result = formatMissingKeys([], "pretty");
+    expect(result).toContain("complete");
   });
 
-  it('groups by adapter, locale, resource in pretty mode', () => {
+  it("groups by adapter, locale, resource in pretty mode", () => {
     const entries = [
-      { adapter: 'a1', locale: 'de', resource: 'auth', key: 'k1' },
-      { adapter: 'a1', locale: 'de', resource: 'auth', key: 'k2' },
-      { adapter: 'a1', locale: 'fr', resource: 'auth', key: 'k3' },
+      { adapter: "a1", locale: "de", resource: "auth", key: "k1" },
+      { adapter: "a1", locale: "de", resource: "auth", key: "k2" },
+      { adapter: "a1", locale: "fr", resource: "auth", key: "k3" },
     ];
-    const result = formatMissingKeys(entries, 'pretty');
-    expect(result).toContain('a1');
-    expect(result).toContain('de');
-    expect(result).toContain('fr');
-    expect(result).toContain('auth');
-    expect(result).toContain('k1');
-    expect(result).toContain('k2');
-    expect(result).toContain('k3');
+    const result = formatMissingKeys(entries, "pretty");
+    expect(result).toContain("a1");
+    expect(result).toContain("de");
+    expect(result).toContain("fr");
+    expect(result).toContain("auth");
+    expect(result).toContain("k1");
+    expect(result).toContain("k2");
+    expect(result).toContain("k3");
   });
 });
 
-describe('formatUnusedKeys', () => {
-  it('returns JSON array in json mode', () => {
-    const entries = [{ adapter: 'a', locale: 'en', resource: 'r', key: 'old' }];
-    const result = formatUnusedKeys(entries, 'json');
+describe("formatUnusedKeys", () => {
+  it("returns JSON array in json mode", () => {
+    const entries = [{ adapter: "a", locale: "en", resource: "r", key: "old" }];
+    const result = formatUnusedKeys(entries, "json");
     expect(JSON.parse(result)).toEqual(entries);
   });
 
-  it('returns success message when empty in pretty mode', () => {
-    const result = formatUnusedKeys([], 'pretty');
-    expect(result).toContain('referenced');
+  it("returns success message when empty in pretty mode", () => {
+    const result = formatUnusedKeys([], "pretty");
+    expect(result).toContain("referenced");
   });
 
-  it('groups entries in pretty mode', () => {
-    const entries = [{ adapter: 'a', locale: 'en', resource: 'r', key: 'old' }];
-    const result = formatUnusedKeys(entries, 'pretty');
-    expect(result).toContain('a');
-    expect(result).toContain('old');
+  it("groups entries in pretty mode", () => {
+    const entries = [{ adapter: "a", locale: "en", resource: "r", key: "old" }];
+    const result = formatUnusedKeys(entries, "pretty");
+    expect(result).toContain("a");
+    expect(result).toContain("old");
   });
 });
 
-describe('formatValidate', () => {
-  it('returns JSON in json mode', () => {
-    const result = formatValidate({ passing: true, entries: [] }, 'json');
+describe("formatValidate", () => {
+  it("returns JSON in json mode", () => {
+    const result = formatValidate({ passing: true, entries: [] }, "json");
     const parsed = JSON.parse(result);
     expect(parsed.passing).toBe(true);
   });
 
-  it('returns success message when passing in pretty mode', () => {
-    const result = formatValidate({ passing: true, entries: [] }, 'pretty');
-    expect(result).toContain('up to date');
+  it("returns success message when passing in pretty mode", () => {
+    const result = formatValidate({ passing: true, entries: [] }, "pretty");
+    expect(result).toContain("up to date");
   });
 
-  it('returns table when failing in pretty mode', () => {
+  it("returns table when failing in pretty mode", () => {
     const result = formatValidate(
-      { passing: false, entries: [{ adapter: 'a', locale: 'de', resource: 'r', count: 3 }] },
-      'pretty',
+      { passing: false, entries: [{ adapter: "a", locale: "de", resource: "r", count: 3 }] },
+      "pretty",
     );
-    expect(result).toContain('Missing');
-    expect(result).toContain('a');
-    expect(result).toContain('de');
-    expect(result).toContain('3');
+    expect(result).toContain("Missing");
+    expect(result).toContain("a");
+    expect(result).toContain("de");
+    expect(result).toContain("3");
   });
 });
 
-describe('formatLanguages', () => {
-  it('returns JSON in json mode', () => {
-    const result = formatLanguages([{ adapter: 'a', locales: ['en', 'de'] }], 'json');
-    expect(JSON.parse(result)).toEqual([{ adapter: 'a', locales: ['en', 'de'] }]);
+describe("formatLanguages", () => {
+  it("returns JSON in json mode", () => {
+    const result = formatLanguages([{ adapter: "a", locales: ["en", "de"] }], "json");
+    expect(JSON.parse(result)).toEqual([{ adapter: "a", locales: ["en", "de"] }]);
   });
 
-  it('returns warning when empty in pretty mode', () => {
-    const result = formatLanguages([], 'pretty');
-    expect(result).toContain('No adapters');
+  it("returns warning when empty in pretty mode", () => {
+    const result = formatLanguages([], "pretty");
+    expect(result).toContain("No adapters");
   });
 
-  it('lists adapters and locales in pretty mode', () => {
-    const result = formatLanguages([{ adapter: 'laravel', locales: ['en', 'de'] }], 'pretty');
-    expect(result).toContain('laravel');
-    expect(result).toContain('en');
-    expect(result).toContain('de');
+  it("lists adapters and locales in pretty mode", () => {
+    const result = formatLanguages([{ adapter: "laravel", locales: ["en", "de"] }], "pretty");
+    expect(result).toContain("laravel");
+    expect(result).toContain("en");
+    expect(result).toContain("de");
   });
 });
 
-describe('formatTranslate', () => {
-  it('returns JSON in json mode', () => {
-    const result = formatTranslate({ success: true, message: 'Done' }, 'json');
-    expect(JSON.parse(result)).toEqual({ success: true, message: 'Done' });
+describe("formatTranslate", () => {
+  it("returns JSON in json mode", () => {
+    const result = formatTranslate({ success: true, message: "Done" }, "json");
+    expect(JSON.parse(result)).toEqual({ success: true, message: "Done" });
   });
 
-  it('returns success text in pretty mode', () => {
-    const result = formatTranslate({ success: true, message: 'Done' }, 'pretty');
-    expect(result).toContain('Done');
+  it("returns success text in pretty mode", () => {
+    const result = formatTranslate({ success: true, message: "Done" }, "pretty");
+    expect(result).toContain("Done");
   });
 
-  it('includes stats in pretty mode', () => {
+  it("includes stats in pretty mode", () => {
     const result = formatTranslate(
-      { success: true, message: 'Done', stats: { adaptersProcessed: 1, localesTranslated: 2, keysTranslated: 5 } },
-      'pretty',
+      {
+        success: true,
+        message: "Done",
+        stats: { adaptersProcessed: 1, localesTranslated: 2, keysTranslated: 5 },
+      },
+      "pretty",
     );
-    expect(result).toContain('Adapters:');
-    expect(result).toContain('1');
-    expect(result).toContain('Locales:');
-    expect(result).toContain('2');
+    expect(result).toContain("Adapters:");
+    expect(result).toContain("1");
+    expect(result).toContain("Locales:");
+    expect(result).toContain("2");
   });
 
-  it('returns failure text in pretty mode', () => {
-    const result = formatTranslate({ success: false, message: 'Failed' }, 'pretty');
-    expect(result).toContain('Failed');
+  it("returns failure text in pretty mode", () => {
+    const result = formatTranslate({ success: false, message: "Failed" }, "pretty");
+    expect(result).toContain("Failed");
   });
 });
 
-describe('formatAdd', () => {
-  it('returns JSON in json mode', () => {
-    const result = formatAdd({ success: true, message: 'Done' }, 'json');
-    expect(JSON.parse(result)).toEqual({ success: true, message: 'Done' });
+describe("formatAdd", () => {
+  it("returns JSON in json mode", () => {
+    const result = formatAdd({ success: true, message: "Done" }, "json");
+    expect(JSON.parse(result)).toEqual({ success: true, message: "Done" });
   });
 
-  it('returns success text in pretty mode', () => {
-    const result = formatAdd({ success: true, message: 'Done' }, 'pretty');
-    expect(result).toContain('Done');
+  it("returns success text in pretty mode", () => {
+    const result = formatAdd({ success: true, message: "Done" }, "pretty");
+    expect(result).toContain("Done");
   });
 
-  it('lists added resources in pretty mode', () => {
+  it("lists added resources in pretty mode", () => {
     const result = formatAdd(
-      { success: true, message: 'Done', addedResources: ['a/en/messages'] },
-      'pretty',
+      { success: true, message: "Done", addedResources: ["a/en/messages"] },
+      "pretty",
     );
-    expect(result).toContain('a/en/messages');
+    expect(result).toContain("a/en/messages");
   });
 });
 
-describe('formatBenchmark', () => {
-  it('returns JSON in json mode', () => {
-    const entries = [{ strategyName: 's', totalChunks: 1, succeededChunks: 1, failedChunks: 0, totalDurationMs: 100, averageDurationMsPerChunk: 100, totalAttempts: 1 }];
-    const result = formatBenchmark(entries, 'json');
+describe("formatBenchmark", () => {
+  it("returns JSON in json mode", () => {
+    const entries = [
+      {
+        strategyName: "s",
+        totalChunks: 1,
+        succeededChunks: 1,
+        failedChunks: 0,
+        totalDurationMs: 100,
+        averageDurationMsPerChunk: 100,
+        totalAttempts: 1,
+      },
+    ];
+    const result = formatBenchmark(entries, "json");
     expect(JSON.parse(result)).toEqual(entries);
   });
 
-  it('returns warning when empty in pretty mode', () => {
-    const result = formatBenchmark([], 'pretty');
-    expect(result).toContain('No benchmark');
+  it("returns warning when empty in pretty mode", () => {
+    const result = formatBenchmark([], "pretty");
+    expect(result).toContain("No benchmark");
   });
 
-  it('renders table in pretty mode', () => {
+  it("renders table in pretty mode", () => {
     const entries = [
-      { strategyName: 'one-shot', totalChunks: 2, succeededChunks: 2, failedChunks: 0, totalDurationMs: 200, averageDurationMsPerChunk: 100, totalAttempts: 2 },
+      {
+        strategyName: "one-shot",
+        totalChunks: 2,
+        succeededChunks: 2,
+        failedChunks: 0,
+        totalDurationMs: 200,
+        averageDurationMsPerChunk: 100,
+        totalAttempts: 2,
+      },
     ];
-    const result = formatBenchmark(entries, 'pretty');
-    expect(result).toContain('Benchmark');
-    expect(result).toContain('one-shot');
-    expect(result).toContain('2/2');
+    const result = formatBenchmark(entries, "pretty");
+    expect(result).toContain("Benchmark");
+    expect(result).toContain("one-shot");
+    expect(result).toContain("2/2");
   });
 });
 
-describe('formatError', () => {
-  it('returns JSON in json mode', () => {
-    const result = formatError('Something broke', 'json');
-    expect(JSON.parse(result)).toEqual({ error: 'Something broke' });
+describe("formatError", () => {
+  it("returns JSON in json mode", () => {
+    const result = formatError("Something broke", "json");
+    expect(JSON.parse(result)).toEqual({ error: "Something broke" });
   });
 
-  it('returns failure text in pretty mode', () => {
-    const result = formatError('Something broke', 'pretty');
-    expect(result).toContain('Something broke');
+  it("returns failure text in pretty mode", () => {
+    const result = formatError("Something broke", "pretty");
+    expect(result).toContain("Something broke");
   });
 });