@intentius/chant 0.0.4 → 0.0.8

package/src/barrel.ts

@@ -1,101 +0,0 @@
-import { readdirSync, readFileSync } from "fs";
-import { join } from "path";
-
-export function barrel(dir: string): Record<string, unknown> {
-  let allExports: Record<string, unknown> | null = null;
-
-  function load(): Record<string, unknown> {
-    if (allExports) return allExports;
-    allExports = {};
-
-    const files = readdirSync(dir)
-      .filter(
-        (f) =>
-          f.endsWith(".ts") &&
-          !f.startsWith("_") &&
-          !f.endsWith(".test.ts") &&
-          !f.endsWith(".spec.ts"),
-      )
-      .sort();
-
-    // Identify files that reference the barrel (.$. or .$[) — these
-    // may silently resolve cross-references to undefined if their
-    // dependency files haven't loaded yet
-    const barrelRefPattern = /\.\$[.\[]/;
-    const usesBarrel = new Set<string>();
-    for (const file of files) {
-      const src = readFileSync(join(dir, file), "utf-8");
-      if (barrelRefPattern.test(src)) {
-        usesBarrel.add(file);
-      }
-    }
-
-    function loadFile(file: string, overwrite = false): boolean {
-      const fullPath = join(dir, file);
-      try {
-        const mod = require(fullPath);
-        for (const [key, val] of Object.entries(mod)) {
-          if (val !== undefined && (overwrite || !(key in allExports!))) {
-            allExports![key] = val;
-          }
-        }
-        return true;
-      } catch {
-        // Clear require cache so retry re-executes the file
-        delete require.cache[require.resolve(fullPath)];
-        return false;
-      }
-    }
-
-    // First pass — load all files in alphabetical order
-    const failed: string[] = [];
-    for (const file of files) {
-      if (!loadFile(file)) {
-        failed.push(file);
-      }
-    }
-
-    // Retry files that threw — their dependencies are now available
-    for (const file of failed) {
-      loadFile(file);
-    }
-
-    // Second pass — reload files that reference the barrel so
-    // cross-references that silently resolved to undefined now
-    // pick up the correct values. Files without barrel references
-    // keep their original instances to preserve the reference graph.
-    for (const file of files) {
-      if (!usesBarrel.has(file)) continue;
-      const fullPath = join(dir, file);
-      try { delete require.cache[require.resolve(fullPath)]; } catch {}
-    }
-    for (const file of files) {
-      if (!usesBarrel.has(file)) continue;
-      loadFile(file, true);
-    }
-
-    return allExports;
-  }
-
-  return new Proxy<Record<string, unknown>>({}, {
-    get(_, prop: string | symbol) {
-      if (typeof prop === 'symbol') return undefined;
-      return load()[prop];
-    },
-    has(_, prop: string | symbol) {
-      if (typeof prop === 'symbol') return false;
-      return prop in load();
-    },
-    ownKeys(_) {
-      return Object.keys(load());
-    },
-    getOwnPropertyDescriptor(_, prop: string | symbol) {
-      if (typeof prop === 'symbol') return undefined;
-      const exports = load();
-      if (prop in exports) {
-        return { configurable: true, enumerable: true, value: exports[prop] };
-      }
-      return undefined;
-    },
-  });
-}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/rollback.ts

@@ -1,45 +0,0 @@
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
-import { join, basename } from "path";
-
-export interface Snapshot {
-  timestamp: string;
-  resources: number;
-  path: string;
-}
-
-/**
- * List available generation snapshots.
- */
-export function listSnapshots(snapshotsDir: string): Snapshot[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  return readdirSync(snapshotsDir)
-    .filter((d) => !d.startsWith("."))
-    .sort()
-    .reverse()
-    .map((dir) => {
-      const fullPath = join(snapshotsDir, dir);
-      const metaPath = join(fullPath, "meta.json");
-      let resources = 0;
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          resources = meta.resources ?? 0;
-        } catch {}
-      }
-      return { timestamp: dir, resources, path: fullPath };
-    });
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(timestamp: string, generatedDir: string): void {
-  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
-  const snapshotDir = join(snapshotsDir, timestamp);
-  if (!existsSync(snapshotDir)) {
-    throw new Error(`Snapshot not found: ${timestamp}`);
-  }
-  mkdirSync(generatedDir, { recursive: true });
-  cpSync(snapshotDir, generatedDir, { recursive: true });
-}

package/src/codegen/case.test.ts

@@ -1,30 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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/rollback.test.ts

@@ -1,92 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { snapshotArtifacts, saveSnapshot, restoreSnapshot, listSnapshots } from "./rollback";
-
-function makeTempDir(): string {
-  const dir = join(tmpdir(), `chant-rollback-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-describe("rollback", () => {
-  test("snapshot captures generated files with default artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"Bucket":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "index.d.ts"), "declare class Bucket {}");
-    writeFileSync(join(genDir, "index.ts"), "export const Bucket = {};");
-
-    const snapshot = snapshotArtifacts(genDir);
-    expect(snapshot.files["lexicon.json"]).toBeDefined();
-    expect(snapshot.files["index.d.ts"]).toBeDefined();
-    expect(snapshot.files["index.ts"]).toBeDefined();
-    expect(snapshot.hashes["lexicon.json"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("snapshot uses custom artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "my-lexicon.json"), '{"Resource":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "types.d.ts"), "declare class Resource {}");
-
-    const snapshot = snapshotArtifacts(genDir, ["my-lexicon.json", "types.d.ts"]);
-    expect(snapshot.files["my-lexicon.json"]).toBeDefined();
-    expect(snapshot.files["types.d.ts"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("save and list snapshots", () => {
-    const dir = makeTempDir();
-    const snapshotsDir = join(dir, ".snapshots");
-
-    const snapshot = {
-      timestamp: "2025-01-01T00:00:00.000Z",
-      files: { "test.json": "{}" },
-      hashes: { "test.json": "abc123" },
-      resourceCount: 0,
-    };
-
-    saveSnapshot(snapshot, snapshotsDir);
-    const list = listSnapshots(snapshotsDir);
-    expect(list.length).toBe(1);
-    expect(list[0].timestamp).toBe("2025-01-01T00:00:00.000Z");
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("restore snapshot overwrites generated files", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    const snapshotsDir = join(dir, ".snapshots");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"original":true}');
-
-    const snapshot = snapshotArtifacts(genDir);
-    const snapshotPath = saveSnapshot(snapshot, snapshotsDir);
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"modified":true}');
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"modified":true}');
-
-    restoreSnapshot(snapshotPath, genDir);
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"original":true}');
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("listSnapshots returns empty for nonexistent dir", () => {
-    const list = listSnapshots("/nonexistent/path");
-    expect(list).toHaveLength(0);
-  });
-});

package/src/codegen/rollback.ts

@@ -1,115 +0,0 @@
-/**
- * Artifact snapshot and restore for generation rollback.
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
-import { join } from "path";
-import { hashArtifact } from "../lexicon-integrity";
-
-export interface ArtifactSnapshot {
-  timestamp: string;
-  files: Record<string, string>;
-  hashes: Record<string, string>;
-  resourceCount: number;
-}
-
-export interface SnapshotInfo {
-  path: string;
-  timestamp: string;
-  resourceCount: number;
-}
-
-const DEFAULT_ARTIFACT_NAMES = ["lexicon.json", "index.d.ts", "index.ts"];
-
-/**
- * Snapshot current generated artifacts.
- *
- * @param generatedDir - Directory containing generated artifacts
- * @param artifactNames - List of filenames to snapshot (defaults to generic names)
- */
-export function snapshotArtifacts(
-  generatedDir: string,
-  artifactNames: string[] = DEFAULT_ARTIFACT_NAMES,
-): ArtifactSnapshot {
-  const files: Record<string, string> = {};
-  const hashes: Record<string, string> = {};
-  let resourceCount = 0;
-
-  for (const entry of artifactNames) {
-    const path = join(generatedDir, entry);
-    if (existsSync(path)) {
-      const content = readFileSync(path, "utf-8");
-      files[entry] = content;
-      hashes[entry] = hashArtifact(content);
-
-      // Count resources in any .json artifact
-      if (entry.endsWith(".json")) {
-        try {
-          const parsed = JSON.parse(content);
-          resourceCount = Object.values(parsed).filter(
-            (e: any) => e && typeof e === "object" && e.kind === "resource"
-          ).length;
-        } catch {}
-      }
-    }
-  }
-
-  return {
-    timestamp: new Date().toISOString(),
-    files,
-    hashes,
-    resourceCount,
-  };
-}
-
-/**
- * Save a snapshot to the .snapshots directory.
- */
-export function saveSnapshot(snapshot: ArtifactSnapshot, snapshotsDir: string): string {
-  mkdirSync(snapshotsDir, { recursive: true });
-
-  const filename = `${snapshot.timestamp.replace(/[:.]/g, "-")}.json`;
-  const path = join(snapshotsDir, filename);
-  writeFileSync(path, JSON.stringify(snapshot, null, 2));
-  return path;
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(snapshotPath: string, generatedDir: string): void {
-  const raw = readFileSync(snapshotPath, "utf-8");
-  const snapshot: ArtifactSnapshot = JSON.parse(raw);
-
-  mkdirSync(generatedDir, { recursive: true });
-  for (const [filename, content] of Object.entries(snapshot.files)) {
-    writeFileSync(join(generatedDir, filename), content);
-  }
-}
-
-/**
- * List available snapshots.
- */
-export function listSnapshots(snapshotsDir: string): SnapshotInfo[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  const entries = readdirSync(snapshotsDir)
-    .filter((f) => f.endsWith(".json"))
-    .sort()
-    .reverse();
-
-  const snapshots: SnapshotInfo[] = [];
-  for (const entry of entries) {
-    try {
-      const path = join(snapshotsDir, entry);
-      const raw = readFileSync(path, "utf-8");
-      const data = JSON.parse(raw);
-      snapshots.push({
-        path,
-        timestamp: data.timestamp,
-        resourceCount: data.resourceCount ?? 0,
-      });
-    } catch {}
-  }
-
-  return snapshots;
-}

package/src/lint/rules/barrel-import-style.test.ts

@@ -1,80 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import * as ts from "typescript";
-import { barrelImportStyleRule } from "./barrel-import-style";
-import type { LintContext } from "../rule";
-
-function createContext(code: string, filePath = "test.ts"): LintContext {
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    code,
-    ts.ScriptTarget.Latest,
-    true
-  );
-
-  return {
-    sourceFile,
-    entities: [],
-    filePath,
-    lexicon: undefined,
-  };
-}
-
-describe("COR002: barrel-import-style", () => {
-  test("rule metadata", () => {
-    expect(barrelImportStyleRule.id).toBe("COR002");
-    expect(barrelImportStyleRule.severity).toBe("error");
-    expect(barrelImportStyleRule.category).toBe("style");
-  });
-
-  test("flags named import from ./_", () => {
-    const code = `import { bucketEncryption } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].ruleId).toBe("COR002");
-    expect(diagnostics[0].severity).toBe("error");
-    expect(diagnostics[0].message).toBe(
-      `Use namespace import for local barrel — replace with: import * as _ from "./_"`
-    );
-  });
-
-  test("allows namespace import from ./_", () => {
-    const code = `import * as _ from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("allows type-only import from ./_", () => {
-    const code = `import type { Config } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from other relative paths", () => {
-    const code = `import { helper } from "./utils";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from packages", () => {
-    const code = `import { useState } from "react";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("reports correct line and column numbers", () => {
-    const code = `import { foo } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].line).toBe(1);
-    expect(diagnostics[0].column).toBe(1);
-    expect(diagnostics[0].file).toBe("test.ts");
-  });
-});

package/src/lint/rules/barrel-import-style.ts

@@ -1,59 +0,0 @@
-import * as ts from "typescript";
-import type { LintRule, LintContext, LintDiagnostic } from "../rule";
-
-/**
- * COR002: barrel-import-style
- *
- * Enforce `import * as _` for local `_.ts` barrel imports.
- *
- * Triggers on: import { bucketEncryption } from "./_"
- * OK: import * as _ from "./_"
- * OK: import type { Config } from "./_"
- */
-
-const barrelPattern = /^\.\/(_|_\..*)$/;
-
-function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
-  if (ts.isImportDeclaration(node)) {
-    const moduleSpecifier = node.moduleSpecifier;
-    if (!ts.isStringLiteral(moduleSpecifier)) return;
-
-    const modulePath = moduleSpecifier.text;
-    if (!barrelPattern.test(modulePath)) return;
-
-    // Skip type-only imports: import type { X } from "..."
-    if (node.importClause?.isTypeOnly) return;
-
-    const importClause = node.importClause;
-    if (!importClause?.namedBindings) return;
-
-    // Flag named imports (not namespace imports)
-    if (ts.isNamedImports(importClause.namedBindings)) {
-      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
-        node.getStart(context.sourceFile)
-      );
-
-      diagnostics.push({
-        file: context.filePath,
-        line: line + 1,
-        column: character + 1,
-        ruleId: "COR002",
-        severity: "error",
-        message: `Use namespace import for local barrel — replace with: import * as _ from "./_"`,
-      });
-    }
-  }
-
-  ts.forEachChild(node, child => checkNode(child, context, diagnostics));
-}
-
-export const barrelImportStyleRule: LintRule = {
-  id: "COR002",
-  severity: "error",
-  category: "style",
-  check(context: LintContext): LintDiagnostic[] {
-    const diagnostics: LintDiagnostic[] = [];
-    checkNode(context.sourceFile, context, diagnostics);
-    return diagnostics;
-  },
-};