@intentius/chant 0.0.1

package/src/cli/watch.ts

@@ -0,0 +1,101 @@
+import { watch } from "fs";
+import { relative } from "path";
+
+/**
+ * Watch options
+ */
+export interface WatchOptions {
+  /** Debounce delay in milliseconds (default: 300) */
+  debounceMs?: number;
+  /** File extensions to include (default: [".ts"]) */
+  extensions?: string[];
+  /** Directory names to ignore */
+  ignoreDirs?: string[];
+}
+
+const DEFAULT_OPTIONS: Required<WatchOptions> = {
+  debounceMs: 300,
+  extensions: [".ts"],
+  ignoreDirs: ["node_modules", ".chant"],
+};
+
+/**
+ * Check if a file path should be watched
+ */
+export function shouldWatch(filePath: string, options: Required<WatchOptions>): boolean {
+  // Ignore dotdirs
+  const parts = filePath.split("/");
+  for (const part of parts) {
+    if (part.startsWith(".") && part.length > 1) return false;
+    if (options.ignoreDirs.includes(part)) return false;
+  }
+
+  // Ignore test/spec files
+  if (filePath.endsWith(".test.ts") || filePath.endsWith(".spec.ts")) return false;
+
+  // Check extension
+  return options.extensions.some((ext) => filePath.endsWith(ext));
+}
+
+/**
+ * Format a timestamp as HH:MM:SS
+ */
+export function formatTimestamp(date: Date = new Date()): string {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+
+/**
+ * Format changed files for display (relative paths, truncated if many)
+ */
+export function formatChangedFiles(files: string[], basePath: string, maxShow = 3): string {
+  const relative_paths = files.map((f) => relative(basePath, f));
+
+  if (relative_paths.length <= maxShow) {
+    return relative_paths.join(", ");
+  }
+
+  const shown = relative_paths.slice(0, maxShow);
+  return `${shown.join(", ")} (+${relative_paths.length - maxShow} more)`;
+}
+
+/**
+ * Watch a directory for file changes with debouncing.
+ * Returns a cleanup function to stop watching.
+ */
+export function watchDirectory(
+  path: string,
+  callback: (changedFiles: string[]) => void,
+  options?: WatchOptions,
+): () => void {
+  const opts: Required<WatchOptions> = { ...DEFAULT_OPTIONS, ...options };
+  let pendingFiles = new Set<string>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const watcher = watch(path, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (!shouldWatch(filename, opts)) return;
+
+    // Collect the full path
+    const fullPath = `${path}/${filename}`;
+    pendingFiles.add(fullPath);
+
+    // Reset the debounce timer
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const files = [...pendingFiles];
+      pendingFiles = new Set();
+      timer = null;
+      if (files.length > 0) {
+        callback(files);
+      }
+    }, opts.debounceMs);
+  });
+
+  return () => {
+    if (timer) clearTimeout(timer);
+    watcher.close();
+  };
+}

package/src/codegen/case.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect } from "bun:test";
+import { toCamelCase, toPascalCase } from "./case";
+
+describe("toCamelCase", () => {
+  test("lowercases first character", () => {
+    expect(toCamelCase("BucketName")).toBe("bucketName");
+  });
+
+  test("preserves already-camelCase", () => {
+    expect(toCamelCase("already")).toBe("already");
+  });
+
+  test("handles single character", () => {
+    expect(toCamelCase("A")).toBe("a");
+  });
+});
+
+describe("toPascalCase", () => {
+  test("uppercases first character", () => {
+    expect(toPascalCase("bucketName")).toBe("BucketName");
+  });
+
+  test("preserves already-PascalCase", () => {
+    expect(toPascalCase("Already")).toBe("Already");
+  });
+
+  test("handles single character", () => {
+    expect(toPascalCase("a")).toBe("A");
+  });
+});

package/src/codegen/case.ts

@@ -0,0 +1,11 @@
+/**
+ * Case conversion utilities for codegen.
+ */
+
+export function toCamelCase(name: string): string {
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+
+export function toPascalCase(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}

package/src/codegen/coverage.ts

@@ -0,0 +1,167 @@
+/**
+ * Coverage analysis for lexicon artifacts.
+ *
+ * Analyzes a generated lexicon JSON to measure coverage across dimensions:
+ * property constraints, lifecycle attributes, return attributes, and extension constraints.
+ */
+
+import type { LexiconEntryParsed } from "../lexicon-schema";
+
+export interface ResourceCoverage {
+  name: string;
+  resourceType: string;
+  hasPropertyConstraints: boolean;
+  hasLifecycle: boolean;
+  hasAttrs: boolean;
+  hasConstraints: boolean;
+}
+
+export interface CoverageReport {
+  resourceCount: number;
+  propertyPct: number;
+  lifecyclePct: number;
+  attrPct: number;
+  constraintPct: number;
+  resources: ResourceCoverage[];
+}
+
+/**
+ * Compute coverage from lexicon JSON content.
+ */
+export function computeCoverage(lexiconJSON: string): CoverageReport {
+  const entries: Record<string, LexiconEntryParsed> = JSON.parse(lexiconJSON);
+
+  // Deduplicate: multiple TS names may map to the same resource type
+  const seen = new Set<string>();
+  const resources: ResourceCoverage[] = [];
+
+  for (const [name, entry] of Object.entries(entries)) {
+    if (entry.kind !== "resource") continue;
+    if (seen.has(entry.resourceType)) continue;
+    seen.add(entry.resourceType);
+
+    resources.push({
+      name,
+      resourceType: entry.resourceType,
+      hasPropertyConstraints: !!(entry.propertyConstraints && Object.keys(entry.propertyConstraints).length > 0),
+      hasLifecycle: !!(entry.createOnly?.length || entry.writeOnly?.length),
+      hasAttrs: !!(entry.attrs && Object.keys(entry.attrs).length > 0),
+      hasConstraints: !!(entry.constraints && entry.constraints.length > 0),
+    });
+  }
+
+  const count = resources.length;
+  if (count === 0) {
+    return {
+      resourceCount: 0,
+      propertyPct: 0,
+      lifecyclePct: 0,
+      attrPct: 0,
+      constraintPct: 0,
+      resources: [],
+    };
+  }
+
+  const propertyCount = resources.filter((r) => r.hasPropertyConstraints).length;
+  const lifecycleCount = resources.filter((r) => r.hasLifecycle).length;
+  const attrCount = resources.filter((r) => r.hasAttrs).length;
+  const constraintCount = resources.filter((r) => r.hasConstraints).length;
+
+  return {
+    resourceCount: count,
+    propertyPct: Math.round((propertyCount / count) * 100),
+    lifecyclePct: Math.round((lifecycleCount / count) * 100),
+    attrPct: Math.round((attrCount / count) * 100),
+    constraintPct: Math.round((constraintCount / count) * 100),
+    resources,
+  };
+}
+
+/**
+ * Overall coverage percentage (average of all dimensions).
+ */
+export function overallPct(report: CoverageReport): number {
+  return Math.round(
+    (report.propertyPct + report.lifecyclePct + report.attrPct + report.constraintPct) / 4,
+  );
+}
+
+/**
+ * Format a human-readable coverage summary.
+ */
+export function formatSummary(report: CoverageReport): string {
+  const lines: string[] = [];
+  lines.push(`Coverage Report: ${report.resourceCount} resources`);
+  lines.push(`  Property constraints: ${report.propertyPct}%`);
+  lines.push(`  Lifecycle (createOnly/writeOnly): ${report.lifecyclePct}%`);
+  lines.push(`  Return attributes: ${report.attrPct}%`);
+  lines.push(`  Extension constraints: ${report.constraintPct}%`);
+  lines.push(`  Overall: ${overallPct(report)}%`);
+  return lines.join("\n");
+}
+
+/**
+ * Threshold configuration for coverage enforcement.
+ */
+export interface CoverageThresholds {
+  minPropertyPct?: number;
+  minLifecyclePct?: number;
+  minAttrPct?: number;
+  minConstraintPct?: number;
+  minOverallPct?: number;
+}
+
+export interface ThresholdResult {
+  ok: boolean;
+  violations: string[];
+}
+
+/**
+ * Check coverage report against thresholds.
+ */
+export function checkThresholds(report: CoverageReport, thresholds: CoverageThresholds): ThresholdResult {
+  const violations: string[] = [];
+
+  if (thresholds.minPropertyPct !== undefined && report.propertyPct < thresholds.minPropertyPct) {
+    violations.push(`Property constraints: ${report.propertyPct}% < ${thresholds.minPropertyPct}% minimum`);
+  }
+  if (thresholds.minLifecyclePct !== undefined && report.lifecyclePct < thresholds.minLifecyclePct) {
+    violations.push(`Lifecycle: ${report.lifecyclePct}% < ${thresholds.minLifecyclePct}% minimum`);
+  }
+  if (thresholds.minAttrPct !== undefined && report.attrPct < thresholds.minAttrPct) {
+    violations.push(`Return attributes: ${report.attrPct}% < ${thresholds.minAttrPct}% minimum`);
+  }
+  if (thresholds.minConstraintPct !== undefined && report.constraintPct < thresholds.minConstraintPct) {
+    violations.push(`Extension constraints: ${report.constraintPct}% < ${thresholds.minConstraintPct}% minimum`);
+  }
+  if (thresholds.minOverallPct !== undefined && overallPct(report) < thresholds.minOverallPct) {
+    violations.push(`Overall: ${overallPct(report)}% < ${thresholds.minOverallPct}% minimum`);
+  }
+
+  return { ok: violations.length === 0, violations };
+}
+
+/**
+ * Format verbose per-resource coverage details.
+ */
+export function formatVerbose(report: CoverageReport): string {
+  const lines: string[] = [formatSummary(report), ""];
+
+  const sorted = [...report.resources].sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const r of sorted) {
+    const missing: string[] = [];
+    if (!r.hasPropertyConstraints) missing.push("property-constraints");
+    if (!r.hasLifecycle) missing.push("lifecycle");
+    if (!r.hasAttrs) missing.push("attrs");
+    if (!r.hasConstraints) missing.push("constraints");
+
+    if (missing.length === 0) {
+      lines.push(`  ${r.name} (${r.resourceType}): full coverage`);
+    } else {
+      lines.push(`  ${r.name} (${r.resourceType}): missing ${missing.join(", ")}`);
+    }
+  }
+
+  return lines.join("\n");
+}