@outfitter/tooling 0.2.4 → 0.3.0

package/dist/shared/@outfitter/tooling-qk5xgmxr.js

@@ -0,0 +1,405 @@
+// @bun
+import {
+  __require
+} from "./tooling-dvwh9qve.js";
+
+// packages/tooling/src/cli/check-tsdoc.ts
+import { resolve } from "path";
+import ts from "typescript";
+import { z } from "zod";
+var coverageLevelSchema = z.enum([
+  "documented",
+  "partial",
+  "undocumented"
+]);
+var declarationCoverageSchema = z.object({
+  name: z.string(),
+  kind: z.string(),
+  level: coverageLevelSchema,
+  file: z.string(),
+  line: z.number()
+});
+var coverageSummarySchema = z.object({
+  documented: z.number(),
+  partial: z.number(),
+  undocumented: z.number(),
+  total: z.number(),
+  percentage: z.number()
+});
+var packageCoverageSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  declarations: z.array(declarationCoverageSchema),
+  documented: z.number(),
+  partial: z.number(),
+  undocumented: z.number(),
+  total: z.number(),
+  percentage: z.number()
+});
+var tsDocCheckResultSchema = z.object({
+  ok: z.boolean(),
+  packages: z.array(packageCoverageSchema),
+  summary: coverageSummarySchema
+});
+function isExportedDeclaration(node) {
+  if (ts.isExportDeclaration(node))
+    return false;
+  if (ts.isExportAssignment(node))
+    return false;
+  const isDeclaration = ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+  if (!isDeclaration)
+    return false;
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+  if (!modifiers)
+    return false;
+  return modifiers.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
+}
+function getDeclarationName(node) {
+  if (ts.isVariableStatement(node)) {
+    const decl = node.declarationList.declarations[0];
+    if (decl && ts.isIdentifier(decl.name)) {
+      return decl.name.text;
+    }
+    return;
+  }
+  if (ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) {
+    return node.name?.text;
+  }
+  return;
+}
+function getDeclarationKind(node) {
+  if (ts.isFunctionDeclaration(node))
+    return "function";
+  if (ts.isInterfaceDeclaration(node))
+    return "interface";
+  if (ts.isTypeAliasDeclaration(node))
+    return "type";
+  if (ts.isClassDeclaration(node))
+    return "class";
+  if (ts.isEnumDeclaration(node))
+    return "enum";
+  if (ts.isVariableStatement(node))
+    return "variable";
+  return "unknown";
+}
+function hasJSDocComment(node, sourceFile) {
+  const sourceText = sourceFile.getFullText();
+  const ranges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  if (!ranges)
+    return false;
+  return ranges.some((range) => {
+    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
+      return false;
+    const text = sourceText.slice(range.pos, range.end);
+    return text.startsWith("/**");
+  });
+}
+function memberHasJSDoc(member, sourceFile) {
+  const sourceText = sourceFile.getFullText();
+  const ranges = ts.getLeadingCommentRanges(sourceText, member.getFullStart());
+  if (!ranges)
+    return false;
+  return ranges.some((range) => {
+    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
+      return false;
+    const text = sourceText.slice(range.pos, range.end);
+    return text.startsWith("/**");
+  });
+}
+function classifyDeclaration(node, sourceFile) {
+  const hasDoc = hasJSDocComment(node, sourceFile);
+  if (!hasDoc)
+    return "undocumented";
+  if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
+    const members = node.members;
+    if (members.length > 0) {
+      const allMembersDocumented = members.every((member) => memberHasJSDoc(member, sourceFile));
+      if (!allMembersDocumented)
+        return "partial";
+    }
+  }
+  return "documented";
+}
+function analyzeSourceFile(sourceFile) {
+  const results = [];
+  for (const statement of sourceFile.statements) {
+    if (!isExportedDeclaration(statement))
+      continue;
+    const name = getDeclarationName(statement);
+    if (!name)
+      continue;
+    const kind = getDeclarationKind(statement);
+    const level = classifyDeclaration(statement, sourceFile);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
+    results.push({
+      name,
+      kind,
+      level,
+      file: sourceFile.fileName,
+      line: line + 1
+    });
+  }
+  return results;
+}
+function calculateCoverage(declarations) {
+  const total = declarations.length;
+  if (total === 0) {
+    return {
+      documented: 0,
+      partial: 0,
+      undocumented: 0,
+      total: 0,
+      percentage: 100
+    };
+  }
+  const documented = declarations.filter((d) => d.level === "documented").length;
+  const partial = declarations.filter((d) => d.level === "partial").length;
+  const undocumented = declarations.filter((d) => d.level === "undocumented").length;
+  const score = documented + partial * 0.5;
+  const percentage = Math.round(score / total * 100);
+  return { documented, partial, undocumented, total, percentage };
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+function resolveJsonMode(options = {}) {
+  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
+}
+function bar(percentage, width = 20) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  const color = percentage >= 80 ? COLORS.green : percentage >= 50 ? COLORS.yellow : COLORS.red;
+  return `${color}${"\u2588".repeat(filled)}${COLORS.dim}${"\u2591".repeat(empty)}${COLORS.reset}`;
+}
+function discoverPackages(cwd) {
+  const packages = [];
+  const seenEntryPoints = new Set;
+  for (const pattern of ["packages/*/src/index.ts", "apps/*/src/index.ts"]) {
+    const glob = new Bun.Glob(pattern);
+    for (const match of glob.scanSync({ cwd, dot: false })) {
+      const parts = match.split("/");
+      const rootDir = parts[0];
+      const pkgDir = parts[1];
+      if (!rootDir || !pkgDir)
+        continue;
+      const entryPoint = resolve(cwd, match);
+      if (seenEntryPoints.has(entryPoint)) {
+        continue;
+      }
+      seenEntryPoints.add(entryPoint);
+      const pkgRoot = resolve(cwd, rootDir, pkgDir);
+      let pkgName = pkgDir;
+      try {
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+        if (pkgJson.name)
+          pkgName = pkgJson.name;
+      } catch {}
+      packages.push({
+        name: pkgName,
+        path: pkgRoot,
+        entryPoint
+      });
+    }
+  }
+  if (packages.length === 0) {
+    const entryPoint = resolve(cwd, "src/index.ts");
+    try {
+      __require("fs").accessSync(entryPoint);
+      let pkgName = "root";
+      try {
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
+        if (pkgJson.name)
+          pkgName = pkgJson.name;
+      } catch {}
+      packages.push({
+        name: pkgName,
+        path: cwd,
+        entryPoint
+      });
+      seenEntryPoints.add(entryPoint);
+    } catch {}
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
+  const result = [];
+  const seen = new Set;
+  for (const statement of sourceFile.statements) {
+    if (!ts.isExportDeclaration(statement))
+      continue;
+    if (!statement.moduleSpecifier)
+      continue;
+    if (!ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const specifier = statement.moduleSpecifier.text;
+    if (!specifier.startsWith("."))
+      continue;
+    const resolvedModule = ts.resolveModuleName(specifier, sourceFile.fileName, program.getCompilerOptions(), ts.sys);
+    const resolvedFileName = resolvedModule.resolvedModule?.resolvedFileName;
+    if (!resolvedFileName)
+      continue;
+    if (!resolvedFileName.startsWith(pkgPath))
+      continue;
+    if (seen.has(resolvedFileName))
+      continue;
+    seen.add(resolvedFileName);
+    const sf = program.getSourceFile(resolvedFileName);
+    if (sf)
+      result.push(sf);
+  }
+  return result;
+}
+function analyzePackage(pkg, workspaceCwd) {
+  try {
+    __require("fs").accessSync(pkg.entryPoint);
+  } catch {
+    return {
+      name: pkg.name,
+      path: pkg.path,
+      declarations: [],
+      documented: 0,
+      partial: 0,
+      undocumented: 0,
+      total: 0,
+      percentage: 0
+    };
+  }
+  let tsconfigPath = resolve(pkg.path, "tsconfig.json");
+  try {
+    __require("fs").accessSync(tsconfigPath);
+  } catch {
+    tsconfigPath = resolve(workspaceCwd, "tsconfig.json");
+  }
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, pkg.path);
+  const program = ts.createProgram({
+    rootNames: [pkg.entryPoint],
+    options: parsedConfig.options,
+    host: ts.createCompilerHost(parsedConfig.options)
+  });
+  const sourceFile = program.getSourceFile(pkg.entryPoint);
+  if (!sourceFile) {
+    return {
+      name: pkg.name,
+      path: pkg.path,
+      declarations: [],
+      documented: 0,
+      partial: 0,
+      undocumented: 0,
+      total: 0,
+      percentage: 0
+    };
+  }
+  const declarations = analyzeSourceFile(sourceFile);
+  const reExportedFiles = collectReExportedSourceFiles(sourceFile, program, pkg.path);
+  for (const sf of reExportedFiles) {
+    declarations.push(...analyzeSourceFile(sf));
+  }
+  const stats = calculateCoverage(declarations);
+  return {
+    name: pkg.name,
+    path: pkg.path,
+    declarations,
+    ...stats
+  };
+}
+function analyzeCheckTsdoc(options = {}) {
+  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
+  const minCoverage = options.minCoverage ?? 0;
+  let packages;
+  if (options.paths && options.paths.length > 0) {
+    packages = options.paths.map((p) => {
+      const absPath = resolve(cwd, p);
+      const entryPoint = resolve(absPath, "src/index.ts");
+      let name = p;
+      try {
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
+        if (pkgJson.name)
+          name = pkgJson.name;
+      } catch {}
+      return { name, path: absPath, entryPoint };
+    });
+  } else {
+    packages = discoverPackages(cwd);
+  }
+  if (packages.length === 0) {
+    return null;
+  }
+  const packageResults = [];
+  for (const pkg of packages) {
+    packageResults.push(analyzePackage(pkg, cwd));
+  }
+  const allDeclarations = packageResults.flatMap((p) => p.declarations);
+  const summary = calculateCoverage(allDeclarations);
+  const ok = !options.strict || summary.percentage >= minCoverage;
+  return {
+    ok,
+    packages: packageResults,
+    summary
+  };
+}
+function printCheckTsdocHuman(result, options) {
+  process.stdout.write(`
+${COLORS.bold}TSDoc Coverage Report${COLORS.reset}
+
+`);
+  for (const pkg of result.packages) {
+    const color = pkg.percentage >= 80 ? COLORS.green : pkg.percentage >= 50 ? COLORS.yellow : COLORS.red;
+    process.stdout.write(`  ${color}${pkg.percentage.toString().padStart(3)}%${COLORS.reset} ${bar(pkg.percentage)} ${pkg.name}
+`);
+    if (pkg.total > 0) {
+      const parts = [];
+      if (pkg.documented > 0)
+        parts.push(`${COLORS.green}${pkg.documented} documented${COLORS.reset}`);
+      if (pkg.partial > 0)
+        parts.push(`${COLORS.yellow}${pkg.partial} partial${COLORS.reset}`);
+      if (pkg.undocumented > 0)
+        parts.push(`${COLORS.red}${pkg.undocumented} undocumented${COLORS.reset}`);
+      process.stdout.write(`       ${COLORS.dim}${pkg.total} declarations:${COLORS.reset} ${parts.join(", ")}
+`);
+    } else {
+      process.stdout.write(`       ${COLORS.dim}no exported declarations${COLORS.reset}
+`);
+    }
+  }
+  const { summary } = result;
+  process.stdout.write(`
+  ${COLORS.bold}Summary:${COLORS.reset} ${summary.percentage}% coverage (${summary.documented} documented, ${summary.partial} partial, ${summary.undocumented} undocumented of ${summary.total} total)
+`);
+  const minCoverage = options?.minCoverage ?? 0;
+  if (options?.strict && summary.percentage < minCoverage) {
+    process.stderr.write(`
+  ${COLORS.red}Coverage ${summary.percentage}% is below minimum threshold of ${minCoverage}%${COLORS.reset}
+`);
+  }
+  process.stdout.write(`
+`);
+}
+async function runCheckTsdoc(options = {}) {
+  const result = analyzeCheckTsdoc(options);
+  if (!result) {
+    process.stderr.write(`No packages found with src/index.ts entry points.
+` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
+` + `Use --package <path> to specify a package path explicitly.
+`);
+    process.exit(1);
+  }
+  if (resolveJsonMode(options)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    printCheckTsdocHuman(result, {
+      strict: options.strict,
+      minCoverage: options.minCoverage
+    });
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };

package/dist/shared/@outfitter/{tooling-g83d0kjv.js → tooling-wv09k6hr.js}

@@ -11,13 +11,13 @@ var BlockSchema = z.object({
   name: z.string().min(1),
   description: z.string().min(1),
   files: z.array(FileEntrySchema).optional(),
-  dependencies: z.record(z.string()).optional(),
-  devDependencies: z.record(z.string()).optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  devDependencies: z.record(z.string(), z.string()).optional(),
   extends: z.array(z.string()).optional()
 });
 var RegistrySchema = z.object({
   version: z.string(),
-  blocks: z.record(BlockSchema)
+  blocks: z.record(z.string(), BlockSchema)
 });
 
 export { FileEntrySchema, BlockSchema, RegistrySchema };