outfitter 0.2.7 → 0.3.2

package/dist/shared/outfitter-63gse8fv.js

@@ -1,316 +0,0 @@
-// @bun
-// apps/outfitter/src/commands/check-tsdoc.ts
-import { existsSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import { dirname, join, relative } from "path";
-import { pathToFileURL } from "url";
-import { Result, ValidationError } from "@outfitter/contracts";
-var require2 = createRequire(import.meta.url);
-var DEFAULT_TSDOC_DISCOVERY_PATTERNS = [
-  "packages/*/src/index.ts",
-  "apps/*/src/index.ts",
-  "src/index.ts"
-];
-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 };
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function readJsonFile(filePath) {
-  try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch {
-    return;
-  }
-}
-function readEntrypointsFromTsdocObject(value) {
-  const tsdoc = asRecord(value);
-  const entrypoints = tsdoc?.["entrypoints"];
-  if (!Array.isArray(entrypoints)) {
-    return;
-  }
-  const normalized = entrypoints.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  return normalized.length > 0 ? normalized : undefined;
-}
-function resolveConfiguredEntrypoints(cwd) {
-  const configPath = join(cwd, ".outfitter", "config.json");
-  if (existsSync(configPath)) {
-    const parsed = readJsonFile(configPath);
-    if (parsed) {
-      const fromRoot = readEntrypointsFromTsdocObject(parsed["tsdoc"]);
-      if (fromRoot) {
-        return {
-          entrypoints: fromRoot,
-          source: ".outfitter/config.json#tsdoc.entrypoints"
-        };
-      }
-      const fromOutfitter = readEntrypointsFromTsdocObject(asRecord(parsed["outfitter"])?.["tsdoc"]);
-      if (fromOutfitter) {
-        return {
-          entrypoints: fromOutfitter,
-          source: ".outfitter/config.json#outfitter.tsdoc.entrypoints"
-        };
-      }
-    }
-  }
-  const packageJsonPath = join(cwd, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return null;
-  }
-  const parsedPackageJson = readJsonFile(packageJsonPath);
-  const fromPackageJson = readEntrypointsFromTsdocObject(asRecord(parsedPackageJson?.["outfitter"])?.["tsdoc"]);
-  if (!fromPackageJson) {
-    return null;
-  }
-  return {
-    entrypoints: fromPackageJson,
-    source: "package.json#outfitter.tsdoc.entrypoints"
-  };
-}
-function derivePackagePathFromEntrypoint(match) {
-  const normalized = match.replaceAll("\\", "/");
-  if (normalized === "src/index.ts") {
-    return ".";
-  }
-  if (normalized.endsWith("/src/index.ts")) {
-    return normalized.slice(0, -"/src/index.ts".length);
-  }
-  const srcSegment = normalized.lastIndexOf("/src/");
-  if (srcSegment >= 0) {
-    return srcSegment === 0 ? "." : normalized.slice(0, srcSegment);
-  }
-  const separator = normalized.lastIndexOf("/");
-  return separator > 0 ? normalized.slice(0, separator) : ".";
-}
-function discoverPathsFromEntrypoints(cwd, entrypoints) {
-  const paths = new Set;
-  for (const pattern of entrypoints) {
-    const glob = new Bun.Glob(pattern);
-    for (const match of glob.scanSync({ cwd, dot: false })) {
-      paths.add(derivePackagePathFromEntrypoint(match));
-    }
-  }
-  return [...paths].sort();
-}
-function formatDiscoveryMessage(entrypoints, source) {
-  const patterns = entrypoints.join(", ");
-  return source ? `${patterns} (from ${source})` : patterns;
-}
-function recalculateCounts(pkg, declarations) {
-  const coverage = calculateCoverage(declarations);
-  return {
-    ...pkg,
-    declarations,
-    ...coverage
-  };
-}
-function filterResult(result, options) {
-  let packages = [...result.packages];
-  if (options.packageNames.length > 0) {
-    const names = new Set(options.packageNames);
-    packages = packages.filter((pkg) => names.has(pkg.name));
-  }
-  if (options.level) {
-    packages = packages.map((pkg) => {
-      const declarations = pkg.declarations.filter((d) => d.level === options.level);
-      return recalculateCounts(pkg, declarations);
-    });
-  }
-  const summary = calculateCoverage(packages.flatMap((pkg) => pkg.declarations));
-  const ok = options.strict ? summary.percentage >= options.minCoverage : true;
-  return {
-    ok,
-    packages,
-    summary
-  };
-}
-function summarizeResult(result) {
-  return {
-    ok: result.ok,
-    packages: result.packages.map((pkg) => ({
-      ...pkg,
-      declarations: []
-    })),
-    summary: result.summary
-  };
-}
-function emitJsonlLines(result, summary) {
-  const lines = [];
-  lines.push({ type: "meta", version: "1.0.0", ok: result.ok });
-  lines.push({ type: "summary", ...result.summary });
-  const sortedPackages = [...result.packages].sort((a, b) => a.name.localeCompare(b.name));
-  for (const pkg of sortedPackages) {
-    lines.push({
-      type: "package",
-      name: pkg.name,
-      percentage: pkg.percentage,
-      documented: pkg.documented,
-      partial: pkg.partial,
-      undocumented: pkg.undocumented,
-      total: pkg.total
-    });
-  }
-  if (!summary) {
-    for (const pkg of sortedPackages) {
-      for (const decl of pkg.declarations) {
-        lines.push({
-          type: "declaration",
-          package: pkg.name,
-          name: decl.name,
-          kind: decl.kind,
-          level: decl.level,
-          file: relative(pkg.path, decl.file),
-          line: decl.line
-        });
-      }
-    }
-  }
-  return lines;
-}
-function normalizeJsonlRecord(text) {
-  try {
-    return JSON.stringify(JSON.parse(text));
-  } catch {
-    return JSON.stringify(text);
-  }
-}
-async function applyJq(data, expr, options) {
-  try {
-    const json = JSON.stringify(data);
-    const args = ["jq", ...options?.compact ? ["-c"] : [], expr];
-    const proc = Bun.spawn(args, {
-      stdin: new Response(json),
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    if (exitCode !== 0) {
-      process.stderr.write(`jq error: ${stderr.trim()}
-`);
-      return options?.compact ? `${JSON.stringify(data)}
-` : `${JSON.stringify(data, null, 2)}
-`;
-    }
-    return stdout;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "unknown jq execution error";
-    const missingBinary = /enoent|not found/i.test(message);
-    if (missingBinary) {
-      process.stderr.write(`jq is not installed. Install jq or omit --jq to continue.
-`);
-    } else {
-      process.stderr.write(`jq execution error: ${message}
-`);
-    }
-    return options?.compact ? `${JSON.stringify(data)}
-` : `${JSON.stringify(data, null, 2)}
-`;
-  }
-}
-var toolingCheckTsdocModule;
-function resolveToolingEntrypoint() {
-  const packageJsonPath = require2.resolve("@outfitter/tooling/package.json");
-  const packageRoot = dirname(packageJsonPath);
-  const srcEntrypoint = join(packageRoot, "src", "index.ts");
-  if (existsSync(srcEntrypoint)) {
-    return srcEntrypoint;
-  }
-  const distEntrypoint = join(packageRoot, "dist", "index.js");
-  if (existsSync(distEntrypoint)) {
-    return distEntrypoint;
-  }
-  throw new Error("Unable to resolve @outfitter/tooling entrypoint (expected src/index.ts or dist/index.js).");
-}
-function loadToolingCheckTsdocModule() {
-  if (!toolingCheckTsdocModule) {
-    toolingCheckTsdocModule = import(pathToFileURL(resolveToolingEntrypoint()).href);
-  }
-  return toolingCheckTsdocModule;
-}
-async function runCheckTsdoc(input) {
-  try {
-    const tooling = await loadToolingCheckTsdocModule();
-    const configuredEntrypoints = resolveConfiguredEntrypoints(input.cwd);
-    const configuredPaths = configuredEntrypoints ? discoverPathsFromEntrypoints(input.cwd, configuredEntrypoints.entrypoints) : [];
-    if (configuredEntrypoints && configuredPaths.length === 0) {
-      return Result.err(ValidationError.fromMessage(`No packages found. Searched ${formatDiscoveryMessage(configuredEntrypoints.entrypoints, configuredEntrypoints.source)}.`, { cwd: input.cwd }));
-    }
-    const rawResult = tooling.analyzeCheckTsdoc({
-      strict: input.strict,
-      minCoverage: input.minCoverage,
-      cwd: input.cwd,
-      ...configuredEntrypoints ? { paths: configuredPaths } : {}
-    });
-    if (!rawResult) {
-      const discoveryPatterns = configuredEntrypoints ? configuredEntrypoints.entrypoints : DEFAULT_TSDOC_DISCOVERY_PATTERNS;
-      const discoverySource = configuredEntrypoints?.source;
-      return Result.err(ValidationError.fromMessage(`No packages found. Searched ${formatDiscoveryMessage(discoveryPatterns, discoverySource)}. Use --package <path> to specify explicitly.`, { cwd: input.cwd }));
-    }
-    const hasFilters = input.level !== undefined || input.packages.length > 0;
-    const filteredResult = hasFilters ? filterResult(rawResult, {
-      level: input.level,
-      packageNames: input.packages,
-      strict: input.strict,
-      minCoverage: input.minCoverage
-    }) : rawResult;
-    const outputData = input.summary ? summarizeResult(filteredResult) : filteredResult;
-    if (input.outputMode === "jsonl") {
-      const lines = emitJsonlLines(filteredResult, input.summary);
-      if (input.jq) {
-        for (const line of lines) {
-          const filtered = await applyJq(line, input.jq, { compact: true });
-          for (const rawLine of filtered.split(/\r?\n/)) {
-            const trimmed = rawLine.trim();
-            if (!trimmed) {
-              continue;
-            }
-            process.stdout.write(`${normalizeJsonlRecord(trimmed)}
-`);
-          }
-        }
-      } else {
-        for (const line of lines) {
-          process.stdout.write(`${JSON.stringify(line)}
-`);
-        }
-      }
-    } else if (input.jq) {
-      const filtered = await applyJq(outputData, input.jq);
-      process.stdout.write(filtered);
-    } else if (input.outputMode === "json") {
-      process.stdout.write(`${JSON.stringify(outputData, null, 2)}
-`);
-    } else {
-      tooling.printCheckTsdocHuman(outputData, {
-        strict: input.strict,
-        minCoverage: input.minCoverage
-      });
-    }
-    return Result.ok(outputData);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Failed to run check-tsdoc";
-    return Result.err(new Error(message));
-  }
-}
-
-export { runCheckTsdoc };

package/dist/shared/outfitter-6bkqjk86.d.ts

@@ -1,3 +0,0 @@
-import { ActionRegistry } from "@outfitter/contracts";
-declare const outfitterActions: ActionRegistry;
-export { outfitterActions };

package/dist/shared/outfitter-6fgk6adm.d.ts

@@ -1,40 +0,0 @@
-import { Command } from "commander";
-type DocsMdxMode = "strict" | "lossy";
-interface DocsBaseOptions {
-	readonly cwd?: string;
-	readonly excludedFilenames?: readonly string[];
-	readonly mdxMode?: DocsMdxMode;
-	readonly outputDir?: string;
-	readonly packagesDir?: string;
-	readonly workspaceRoot?: string;
-}
-interface ExecuteCheckCommandOptions extends DocsBaseOptions {}
-interface ExecuteSyncCommandOptions extends DocsBaseOptions {}
-type DocsExportTarget = "packages" | "llms" | "llms-full" | "all";
-interface ExecuteExportCommandOptions extends DocsBaseOptions {
-	readonly llmsFile?: string;
-	readonly llmsFullFile?: string;
-	readonly target?: DocsExportTarget | string;
-}
-interface DocsCommandIo {
-	readonly err: (line: string) => void;
-	readonly out: (line: string) => void;
-}
-interface CreateDocsCommandOptions {
-	readonly commandName?: string;
-	readonly io?: {
-		readonly out?: (line: string) => void;
-		readonly err?: (line: string) => void;
-	};
-}
-interface DocsModule {
-	createDocsCommand: (options?: CreateDocsCommandOptions) => Command;
-	executeCheckCommand: (options: ExecuteCheckCommandOptions, io: DocsCommandIo) => Promise<number>;
-	executeExportCommand: (options: ExecuteExportCommandOptions, io: DocsCommandIo) => Promise<number>;
-	executeSyncCommand: (options: ExecuteSyncCommandOptions, io: DocsCommandIo) => Promise<number>;
-}
-/**
-* Load docs command module with source-first resolution in monorepo development.
-*/
-declare function loadDocsModule(): Promise<DocsModule>;
-export { ExecuteCheckCommandOptions, ExecuteSyncCommandOptions, DocsExportTarget, ExecuteExportCommandOptions, DocsCommandIo, CreateDocsCommandOptions, loadDocsModule };

package/dist/shared/outfitter-79vfxt6y.js

@@ -1,269 +0,0 @@
-// @bun
-import {
-  stampBlock
-} from "./outfitter-mtbpabf3.js";
-import {
-  resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
-
-// apps/outfitter/src/commands/add.ts
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync
-} from "fs";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
-import { output } from "@outfitter/cli";
-import { Result } from "@outfitter/contracts";
-import { RegistrySchema } from "@outfitter/tooling";
-class AddError extends Error {
-  _tag = "AddError";
-  constructor(message) {
-    super(message);
-    this.name = "AddError";
-  }
-}
-function getRegistryPath() {
-  let currentDir = dirname(fileURLToPath(import.meta.url));
-  for (let i = 0;i < 10; i++) {
-    const registryPath = join(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
-    if (existsSync(registryPath)) {
-      return registryPath;
-    }
-    const monoRepoPath = join(currentDir, "packages/tooling/registry/registry.json");
-    if (existsSync(monoRepoPath)) {
-      return monoRepoPath;
-    }
-    currentDir = dirname(currentDir);
-  }
-  throw new AddError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
-}
-function readToolingVersion(registryPath) {
-  try {
-    const toolingRoot = dirname(dirname(registryPath));
-    const pkgPath = join(toolingRoot, "package.json");
-    const content = readFileSync(pkgPath, "utf-8");
-    const pkg = JSON.parse(content);
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function loadRegistry() {
-  try {
-    const registryPath = getRegistryPath();
-    const content = readFileSync(registryPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const registry = RegistrySchema.parse(parsed);
-    const toolingVersion = readToolingVersion(registryPath);
-    return Result.ok({ registry, toolingVersion });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result.err(new AddError(`Failed to load registry: ${message}`));
-  }
-}
-function resolveBlock(registry, blockName, visited = new Set) {
-  if (visited.has(blockName)) {
-    return Result.err(new AddError(`Circular dependency detected for block: ${blockName}`));
-  }
-  visited.add(blockName);
-  const block = registry.blocks[blockName];
-  if (!block) {
-    const available = Object.keys(registry.blocks).join(", ");
-    return Result.err(new AddError(`Block '${blockName}' not found. Available blocks: ${available}`));
-  }
-  if (block.extends && block.extends.length > 0) {
-    const mergedFiles = [];
-    const mergedDeps = {};
-    const mergedDevDeps = {};
-    for (const extendedName of block.extends) {
-      const extendedResult = resolveBlock(registry, extendedName, visited);
-      if (extendedResult.isErr()) {
-        return extendedResult;
-      }
-      const extended = extendedResult.value;
-      if (extended.files) {
-        mergedFiles.push(...extended.files);
-      }
-      if (extended.dependencies) {
-        Object.assign(mergedDeps, extended.dependencies);
-      }
-      if (extended.devDependencies) {
-        Object.assign(mergedDevDeps, extended.devDependencies);
-      }
-    }
-    if (block.files) {
-      mergedFiles.push(...block.files);
-    }
-    if (block.dependencies) {
-      Object.assign(mergedDeps, block.dependencies);
-    }
-    if (block.devDependencies) {
-      Object.assign(mergedDevDeps, block.devDependencies);
-    }
-    return Result.ok({
-      name: block.name,
-      description: block.description,
-      files: mergedFiles.length > 0 ? mergedFiles : undefined,
-      dependencies: Object.keys(mergedDeps).length > 0 ? mergedDeps : undefined,
-      devDependencies: Object.keys(mergedDevDeps).length > 0 ? mergedDevDeps : undefined
-    });
-  }
-  return Result.ok(block);
-}
-function writeFile(filePath, content, executable) {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(filePath, content, "utf-8");
-  if (executable) {
-    chmodSync(filePath, 493);
-  }
-}
-function updatePackageJson(cwd, dependencies, devDependencies, dryRun) {
-  const packageJsonPath = join(cwd, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return { dependencies, devDependencies };
-  }
-  const content = readFileSync(packageJsonPath, "utf-8");
-  const pkg = JSON.parse(content);
-  const existingDeps = pkg["dependencies"] ?? {};
-  const existingDevDeps = pkg["devDependencies"] ?? {};
-  const addedDeps = {};
-  const addedDevDeps = {};
-  for (const [name, version] of Object.entries(dependencies)) {
-    if (!existingDeps[name]) {
-      existingDeps[name] = version;
-      addedDeps[name] = version;
-    }
-  }
-  for (const [name, version] of Object.entries(devDependencies)) {
-    if (!(existingDevDeps[name] || existingDeps[name])) {
-      existingDevDeps[name] = version;
-      addedDevDeps[name] = version;
-    }
-  }
-  if (!dryRun && (Object.keys(addedDeps).length > 0 || Object.keys(addedDevDeps).length > 0)) {
-    if (Object.keys(existingDeps).length > 0) {
-      pkg["dependencies"] = existingDeps;
-    }
-    if (Object.keys(existingDevDeps).length > 0) {
-      pkg["devDependencies"] = existingDevDeps;
-    }
-    writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
-`);
-  }
-  return { dependencies: addedDeps, devDependencies: addedDevDeps };
-}
-async function runAdd(input) {
-  const { block: blockName, force, dryRun, cwd = process.cwd() } = input;
-  const resolvedCwd = resolve(cwd);
-  const registryResult = loadRegistry();
-  if (registryResult.isErr()) {
-    return registryResult;
-  }
-  const { registry, toolingVersion } = registryResult.value;
-  const blockResult = resolveBlock(registry, blockName);
-  if (blockResult.isErr()) {
-    return blockResult;
-  }
-  const block = blockResult.value;
-  const created = [];
-  const skipped = [];
-  const overwritten = [];
-  if (block.files) {
-    for (const file of block.files) {
-      const targetPath = join(resolvedCwd, file.path);
-      const fileExists = existsSync(targetPath);
-      if (fileExists && !force) {
-        skipped.push(file.path);
-        continue;
-      }
-      if (!dryRun) {
-        writeFile(targetPath, file.content, file.executable ?? false);
-      }
-      if (fileExists) {
-        overwritten.push(file.path);
-      } else {
-        created.push(file.path);
-      }
-    }
-  }
-  const { dependencies, devDependencies } = updatePackageJson(resolvedCwd, block.dependencies ?? {}, block.devDependencies ?? {}, dryRun);
-  if (!dryRun) {
-    const stampResult = await stampBlock(resolvedCwd, blockName, toolingVersion);
-    if (stampResult.isErr()) {
-      process.stderr.write(`Warning: failed to stamp manifest: ${stampResult.error.message}
-`);
-    }
-  }
-  return Result.ok({
-    created,
-    skipped,
-    overwritten,
-    dependencies,
-    devDependencies
-  });
-}
-async function printAddResults(result, dryRun, options) {
-  const structuredMode = resolveStructuredOutputMode(options?.mode);
-  if (structuredMode) {
-    await output({
-      dryRun,
-      created: result.created,
-      overwritten: result.overwritten,
-      skipped: result.skipped,
-      dependencies: result.dependencies,
-      devDependencies: result.devDependencies
-    }, { mode: structuredMode });
-    return;
-  }
-  const lines = [];
-  const prefix = dryRun ? "[dry-run] Would " : "";
-  if (result.created.length > 0) {
-    lines.push(`${prefix}create ${result.created.length} file(s):`);
-    for (const file of result.created) {
-      lines.push(`  \u2713 ${file}`);
-    }
-  }
-  if (result.overwritten.length > 0) {
-    lines.push(`${prefix}overwrite ${result.overwritten.length} file(s):`);
-    for (const file of result.overwritten) {
-      lines.push(`  \u2713 ${file}`);
-    }
-  }
-  if (result.skipped.length > 0) {
-    lines.push(`Skipped ${result.skipped.length} existing file(s):`);
-    for (const file of result.skipped) {
-      lines.push(`  - ${file} (use --force to overwrite)`);
-    }
-  }
-  const depCount = Object.keys(result.dependencies).length + Object.keys(result.devDependencies).length;
-  if (depCount > 0) {
-    lines.push("", `${prefix}add ${depCount} package(s) to package.json:`);
-    for (const [name, version] of Object.entries(result.dependencies)) {
-      lines.push(`  + ${name}@${version}`);
-    }
-    for (const [name, version] of Object.entries(result.devDependencies)) {
-      lines.push(`  + ${name}@${version} (dev)`);
-    }
-    if (!dryRun) {
-      lines.push("", "Run `bun install` to install new dependencies.");
-    }
-  }
-  await output(lines, { mode: "human" });
-}
-function listBlocks() {
-  const registryResult = loadRegistry();
-  if (registryResult.isErr()) {
-    return registryResult;
-  }
-  const blocks = Object.keys(registryResult.value.registry.blocks);
-  return Result.ok(blocks);
-}
-
-export { AddError, runAdd, printAddResults, listBlocks };