@intentius/chant 0.0.3 → 0.0.5

package/src/project/scan.ts

@@ -1,182 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { join, basename, relative } from "node:path";
-import ts from "typescript";
-
-export interface ProjectExport {
-  name: string;
-  file: string;
-  className: string;
-}
-
-export interface ProjectScan {
-  barrelPath: string;
-  lexiconPackage: string;
-  exports: ProjectExport[];
-}
-
-/**
- * Extract the lexicon package from export * declarations in the barrel file.
- * Finds the first `export * from "..."` where the module specifier is not a relative path.
- */
-function extractLexiconPackage(sourceFile: ts.SourceFile): string {
-  for (const stmt of sourceFile.statements) {
-    if (
-      ts.isExportDeclaration(stmt) &&
-      !stmt.exportClause &&
-      stmt.moduleSpecifier &&
-      ts.isStringLiteral(stmt.moduleSpecifier)
-    ) {
-      const spec = stmt.moduleSpecifier.text;
-      if (!spec.startsWith(".")) {
-        return spec;
-      }
-    }
-  }
-  return "";
-}
-
-/**
- * Infer class name from a variable declaration's initializer or type annotation.
- *
- * Patterns:
- * - `export const x = new aws.Bucket(...)` → "Bucket"
- * - `export const x = new _.Bucket(...)` → "Bucket"
- * - `export const x = new Bucket(...)` → "Bucket"
- * - `export const x: aws.Code = ...` → "Code"
- * - `export const x: _.Code = ...` → "Code"
- */
-function inferClassName(decl: ts.VariableDeclaration): string {
-  // Check initializer: new X.ClassName(...) or new ClassName(...)
-  if (decl.initializer && ts.isNewExpression(decl.initializer)) {
-    const expr = decl.initializer.expression;
-    if (ts.isPropertyAccessExpression(expr)) {
-      return expr.name.text;
-    }
-    if (ts.isIdentifier(expr)) {
-      return expr.text;
-    }
-  }
-
-  // Check type annotation: X.ClassName or ClassName
-  if (decl.type) {
-    if (ts.isTypeReferenceNode(decl.type)) {
-      const typeName = decl.type.typeName;
-      if (ts.isQualifiedName(typeName)) {
-        return typeName.right.text;
-      }
-      if (ts.isIdentifier(typeName)) {
-        return typeName.text;
-      }
-    }
-  }
-
-  return "";
-}
-
-/**
- * Extract named exports from a source file.
- */
-function extractExports(
-  sourceFile: ts.SourceFile,
-  filePath: string,
-): ProjectExport[] {
-  const results: ProjectExport[] = [];
-
-  for (const stmt of sourceFile.statements) {
-    // export const x = ...
-    if (
-      ts.isVariableStatement(stmt) &&
-      stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
-    ) {
-      for (const decl of stmt.declarationList.declarations) {
-        if (ts.isIdentifier(decl.name)) {
-          results.push({
-            name: decl.name.text,
-            file: filePath,
-            className: inferClassName(decl),
-          });
-        }
-      }
-    }
-
-    // export function x() {}
-    if (
-      ts.isFunctionDeclaration(stmt) &&
-      stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
-      stmt.name
-    ) {
-      results.push({
-        name: stmt.name.text,
-        file: filePath,
-        className: "",
-      });
-    }
-
-    // export class X {}
-    if (
-      ts.isClassDeclaration(stmt) &&
-      stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
-      stmt.name
-    ) {
-      results.push({
-        name: stmt.name.text,
-        file: filePath,
-        className: stmt.name.text,
-      });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Scan a project directory to identify the barrel file, lexicon package,
- * and all exports with their inferred types.
- */
-export function scanProject(dir: string): ProjectScan {
-  const barrelPath = join(dir, "_.ts");
-
-  let barrelContent: string;
-  try {
-    barrelContent = readFileSync(barrelPath, "utf-8");
-  } catch {
-    throw new Error(`No barrel file found at ${barrelPath}`);
-  }
-
-  const barrelSource = ts.createSourceFile(
-    "_.ts",
-    barrelContent,
-    ts.ScriptTarget.Latest,
-    true,
-  );
-
-  const lexiconPackage = extractLexiconPackage(barrelSource);
-
-  // Scan sibling .ts files
-  const entries = readdirSync(dir, { withFileTypes: true });
-  const exports: ProjectExport[] = [];
-
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    if (!entry.name.endsWith(".ts")) continue;
-    if (entry.name === "_.ts") continue;
-    if (entry.name.startsWith("_")) continue;
-    if (entry.name.endsWith(".test.ts") || entry.name.endsWith(".spec.ts"))
-      continue;
-    if (entry.name.endsWith(".d.ts")) continue;
-
-    const filePath = "./" + entry.name.replace(/\.ts$/, "");
-    const fullPath = join(dir, entry.name);
-    const content = readFileSync(fullPath, "utf-8");
-    const sourceFile = ts.createSourceFile(
-      entry.name,
-      content,
-      ts.ScriptTarget.Latest,
-      true,
-    );
-
-    exports.push(...extractExports(sourceFile, filePath));
-  }
-
-  return { barrelPath, lexiconPackage, exports };
-}

package/src/project/sync.test.ts

@@ -1,87 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { generateBarrelTypes, syncProject } from "./sync";
-import { withTestDir } from "@intentius/chant-test-utils";
-import { writeFile, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { ProjectScan } from "./scan";
-
-describe("generateBarrelTypes", () => {
-  test("generates valid .d.ts with import and typed $", () => {
-    const scan: ProjectScan = {
-      barrelPath: "/project/_.ts",
-      lexiconPackage: "@intentius/chant-lexicon-testdom",
-      exports: [
-        { name: "dataBucket", file: "./data-bucket", className: "Bucket" },
-        { name: "logsBucket", file: "./logs-bucket", className: "Bucket" },
-        { name: "functionRole", file: "./iam", className: "Role" },
-      ],
-    };
-
-    const result = generateBarrelTypes(scan);
-    expect(result).toContain(
-      'import type * as _lexicon from "@intentius/chant-lexicon-testdom";',
-    );
-    expect(result).toContain("dataBucket: _lexicon.Bucket;");
-    expect(result).toContain("logsBucket: _lexicon.Bucket;");
-    expect(result).toContain("functionRole: _lexicon.Role;");
-    expect(result).toContain("export declare const $: typeof _barrel;");
-  });
-
-  test("uses unknown for unresolvable types", () => {
-    const scan: ProjectScan = {
-      barrelPath: "/project/_.ts",
-      lexiconPackage: "@intentius/chant-lexicon-testdom",
-      exports: [
-        { name: "dataBucket", file: "./data-bucket", className: "Bucket" },
-        { name: "greeting", file: "./utils", className: "" },
-      ],
-    };
-
-    const result = generateBarrelTypes(scan);
-    expect(result).toContain("dataBucket: _lexicon.Bucket;");
-    expect(result).toContain("greeting: unknown;");
-  });
-
-  test("handles scan with no lexicon package", () => {
-    const scan: ProjectScan = {
-      barrelPath: "/project/_.ts",
-      lexiconPackage: "",
-      exports: [
-        { name: "bucket", file: "./storage", className: "Bucket" },
-      ],
-    };
-
-    const result = generateBarrelTypes(scan);
-    expect(result).not.toContain("import type");
-    expect(result).toContain("bucket: Bucket;");
-  });
-});
-
-describe("syncProject", () => {
-  test("writes _.d.ts to directory", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "storage.ts"),
-        [
-          `import * as td from "@intentius/chant-lexicon-testdom";`,
-          `export const dataBucket = new td.Bucket({});`,
-          `export const logsBucket = new td.Bucket({});`,
-        ].join("\n"),
-      );
-
-      syncProject(dir);
-
-      const dtsContent = await readFile(join(dir, "_.d.ts"), "utf-8");
-      expect(dtsContent).toContain(
-        'import type * as _lexicon from "@intentius/chant-lexicon-testdom";',
-      );
-      expect(dtsContent).toContain("dataBucket: _lexicon.Bucket;");
-      expect(dtsContent).toContain("logsBucket: _lexicon.Bucket;");
-      expect(dtsContent).toContain("export declare const $: typeof _barrel;");
-    });
-  });
-});

package/src/project/sync.ts

@@ -1,46 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { scanProject, type ProjectScan } from "./scan";
-
-/**
- * Generate a _.d.ts file content from a project scan.
- * Produces typed declarations for the barrel's $ proxy.
- */
-export function generateBarrelTypes(scan: ProjectScan): string {
-  const lines: string[] = [];
-
-  lines.push("// _.d.ts (auto-generated by chant lint)");
-
-  if (scan.lexiconPackage) {
-    lines.push(`import type * as _lexicon from "${scan.lexiconPackage}";`);
-  }
-
-  lines.push("declare const _barrel: {");
-
-  for (const exp of scan.exports) {
-    let typeName: string;
-    if (!exp.className) {
-      typeName = "unknown";
-    } else if (scan.lexiconPackage) {
-      typeName = `_lexicon.${exp.className}`;
-    } else {
-      typeName = exp.className;
-    }
-    lines.push(`  ${exp.name}: ${typeName};`);
-  }
-
-  lines.push("};");
-  lines.push("export declare const $: typeof _barrel;");
-  lines.push("");
-
-  return lines.join("\n");
-}
-
-/**
- * Scan a project directory and write the _.d.ts file.
- */
-export function syncProject(dir: string): void {
-  const scan = scanProject(dir);
-  const content = generateBarrelTypes(scan);
-  writeFileSync(join(dir, "_.d.ts"), content, "utf-8");
-}