@openpkg-ts/extract 0.1.0

package/dist/bin/tspec.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  extract
+} from "../shared/chunk-esvc8n1x.js";
+
+// src/cli/spec.ts
+import { Command } from "commander";
+import { normalize, validateSpec } from "@openpkg-ts/spec";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function createProgram() {
+  const program = new Command("tspec").description("Extract TypeScript package API to OpenPkg spec").argument("[entry]", "Entry point file").option("-o, --output <file>", "Output file", "openpkg.json").option("--max-depth <n>", "Max type depth", "20").option("--skip-resolve", "Skip external type resolution").option("--runtime", "Enable Standard Schema runtime extraction").action(async (entry, options) => {
+    const entryFile = entry || findEntryPoint(process.cwd());
+    if (!entryFile) {
+      console.error("No entry point found. Please specify an entry file.");
+      process.exit(1);
+    }
+    console.log(`Extracting from: ${entryFile}`);
+    const result = await extract({
+      entryFile: path.resolve(entryFile),
+      maxTypeDepth: parseInt(options.maxDepth),
+      resolveExternalTypes: !options.skipResolve,
+      schemaExtraction: options.runtime ? "hybrid" : "static"
+    });
+    for (const diag of result.diagnostics) {
+      const prefix = diag.severity === "error" ? "✗" : diag.severity === "warning" ? "⚠" : "ℹ";
+      console.log(`${prefix} ${diag.message}`);
+    }
+    const normalized = normalize(result.spec);
+    const validation = validateSpec(normalized);
+    if (!validation.ok) {
+      console.error("Validation failed:");
+      for (const err of validation.errors) {
+        console.error(`  - ${err.instancePath}: ${err.message}`);
+      }
+      process.exit(1);
+    }
+    fs.writeFileSync(options.output, JSON.stringify(normalized, null, 2));
+    console.log(`Generated ${options.output}`);
+    console.log(`  ${normalized.exports.length} exports`);
+    console.log(`  ${normalized.types?.length || 0} types`);
+  });
+  return program;
+}
+function findEntryPoint(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.types)
+        return path.join(cwd, pkg.types);
+      if (pkg.typings)
+        return path.join(cwd, pkg.typings);
+      if (pkg.exports?.["."]?.types)
+        return path.join(cwd, pkg.exports["."].types);
+      if (pkg.main) {
+        const mainTs = pkg.main.replace(/\.js$/, ".ts");
+        if (fs.existsSync(path.join(cwd, mainTs)))
+          return path.join(cwd, mainTs);
+      }
+    } catch {}
+  }
+  const fallbacks = ["src/index.ts", "index.ts", "lib/index.ts"];
+  for (const fallback of fallbacks) {
+    const fullPath = path.join(cwd, fallback);
+    if (fs.existsSync(fullPath))
+      return fullPath;
+  }
+  return null;
+}
+
+// bin/tspec.ts
+var program = createProgram();
+program.parse();

package/dist/shared/chunk-esvc8n1x.js

@@ -0,0 +1,403 @@
+// src/compiler/program.ts
+import * as path from "node:path";
+import ts from "typescript";
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts.ScriptTarget.Latest,
+  module: ts.ModuleKind.CommonJS,
+  lib: ["lib.es2021.d.ts"],
+  declaration: true,
+  moduleResolution: ts.ModuleResolutionKind.NodeJs
+};
+function createProgram({
+  entryFile,
+  baseDir = path.dirname(entryFile),
+  content
+}) {
+  const configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+  }
+  const allowJsVal = compilerOptions.allowJs;
+  if (typeof allowJsVal === "boolean" && allowJsVal) {
+    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
+  }
+  const compilerHost = ts.createCompilerHost(compilerOptions, true);
+  let inMemorySource;
+  if (content !== undefined) {
+    inMemorySource = ts.createSourceFile(entryFile, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+      if (fileName === entryFile) {
+        return inMemorySource;
+      }
+      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    };
+  }
+  const program = ts.createProgram([entryFile], compilerOptions, compilerHost);
+  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
+  return {
+    program,
+    compilerHost,
+    compilerOptions,
+    sourceFile,
+    configPath
+  };
+}
+
+// src/ast/registry.ts
+class TypeRegistry {
+  types = new Map;
+  add(type) {
+    this.types.set(type.id, type);
+  }
+  get(id) {
+    return this.types.get(id);
+  }
+  has(id) {
+    return this.types.has(id);
+  }
+  getAll() {
+    return Array.from(this.types.values());
+  }
+  registerFromSymbol(symbol, checker) {
+    const name = symbol.getName();
+    if (this.has(name))
+      return this.get(name);
+    const type = {
+      id: name,
+      name,
+      kind: "type"
+    };
+    this.add(type);
+    return type;
+  }
+}
+
+// src/ast/utils.ts
+import ts2 from "typescript";
+function getJSDocComment(node) {
+  const jsDocTags = ts2.getJSDocTags(node);
+  const tags = jsDocTags.map((tag) => ({
+    name: tag.tagName.text,
+    text: typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment) ?? ""
+  }));
+  const jsDocComments = node.jsDoc;
+  let description;
+  if (jsDocComments && jsDocComments.length > 0) {
+    const firstDoc = jsDocComments[0];
+    if (firstDoc.comment) {
+      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts2.getTextOfJSDocComment(firstDoc.comment);
+    }
+  }
+  return { description, tags };
+}
+function getSourceLocation(node, sourceFile) {
+  const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return {
+    file: sourceFile.fileName,
+    line: line + 1
+  };
+}
+
+// src/types/parameters.ts
+function extractParameters(signature, checker) {
+  return signature.getParameters().map((param) => {
+    const type = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
+    return {
+      name: param.getName(),
+      schema: { type: checker.typeToString(type) },
+      required: !(param.flags & 16777216)
+    };
+  });
+}
+
+// src/serializers/functions.ts
+function serializeFunctionExport(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const type = ctx.typeChecker.getTypeAtLocation(node);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx.typeChecker);
+    const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
+    return {
+      parameters: params,
+      returns: {
+        schema: { type: ctx.typeChecker.typeToString(returnType) }
+      }
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "function",
+    description,
+    tags,
+    source,
+    signatures
+  };
+}
+
+// src/serializers/classes.ts
+function serializeClass(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  return {
+    id: name,
+    name,
+    kind: "class",
+    description,
+    tags,
+    source,
+    members: []
+  };
+}
+
+// src/serializers/interfaces.ts
+function serializeInterface(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  return {
+    id: name,
+    name,
+    kind: "interface",
+    description,
+    tags,
+    source,
+    members: []
+  };
+}
+
+// src/serializers/type-aliases.ts
+function serializeTypeAlias(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const type = ctx.typeChecker.getTypeAtLocation(node);
+  const typeString = ctx.typeChecker.typeToString(type);
+  return {
+    id: name,
+    name,
+    kind: "type",
+    description,
+    tags,
+    source,
+    ...typeString !== name ? { type: typeString } : {}
+  };
+}
+
+// src/serializers/enums.ts
+function serializeEnum(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const members = node.members.map((member) => {
+    const memberSymbol = ctx.typeChecker.getSymbolAtLocation(member.name);
+    const memberName = memberSymbol?.getName() ?? member.name.getText();
+    return {
+      id: memberName,
+      name: memberName,
+      kind: "enum-member"
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "enum",
+    description,
+    tags,
+    source,
+    members
+  };
+}
+
+// src/serializers/variables.ts
+function serializeVariable(node, statement, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
+  const name = symbol?.getName() ?? node.name.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(statement);
+  const source = getSourceLocation(node, declSourceFile);
+  const type = ctx.typeChecker.getTypeAtLocation(node);
+  const typeString = ctx.typeChecker.typeToString(type);
+  return {
+    id: name,
+    name,
+    kind: "variable",
+    description,
+    tags,
+    source,
+    ...typeString && typeString !== name ? { type: typeString } : {}
+  };
+}
+
+// src/builder/spec-builder.ts
+import ts3 from "typescript";
+import { SCHEMA_VERSION } from "@openpkg-ts/spec";
+
+// src/serializers/context.ts
+function createContext(program, sourceFile, options = {}) {
+  return {
+    typeChecker: program.getTypeChecker(),
+    program,
+    sourceFile,
+    maxTypeDepth: options.maxTypeDepth ?? 20,
+    resolveExternalTypes: options.resolveExternalTypes ?? true,
+    typeRegistry: new TypeRegistry
+  };
+}
+
+// src/builder/spec-builder.ts
+import * as path2 from "node:path";
+import * as fs from "node:fs";
+async function extract(options) {
+  const { entryFile, baseDir, content, maxTypeDepth, resolveExternalTypes } = options;
+  const diagnostics = [];
+  const exports = [];
+  const result = createProgram({ entryFile, baseDir, content });
+  const { program, sourceFile } = result;
+  if (!sourceFile) {
+    return {
+      spec: createEmptySpec(entryFile),
+      diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
+    };
+  }
+  const ctx = createContext(program, sourceFile, { maxTypeDepth, resolveExternalTypes });
+  const typeChecker = program.getTypeChecker();
+  const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+  if (!moduleSymbol) {
+    return {
+      spec: createEmptySpec(entryFile),
+      diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
+    };
+  }
+  const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
+  for (const symbol of exportedSymbols) {
+    try {
+      const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
+      if (!declaration)
+        continue;
+      const exportName = symbol.getName();
+      const exp = serializeDeclaration(declaration, targetSymbol, exportName, ctx);
+      if (exp)
+        exports.push(exp);
+    } catch (err) {
+      diagnostics.push({
+        message: `Failed to serialize ${symbol.getName()}: ${err}`,
+        severity: "warning"
+      });
+    }
+  }
+  const meta = await getPackageMeta(entryFile, baseDir);
+  const spec = {
+    openpkg: SCHEMA_VERSION,
+    meta,
+    exports,
+    types: ctx.typeRegistry.getAll(),
+    generation: {
+      generator: "@openpkg-ts/extract",
+      timestamp: new Date().toISOString()
+    }
+  };
+  return { spec, diagnostics };
+}
+function resolveExportTarget(symbol, checker) {
+  let targetSymbol = symbol;
+  if (symbol.flags & ts3.SymbolFlags.Alias) {
+    const aliasTarget = checker.getAliasedSymbol(symbol);
+    if (aliasTarget && aliasTarget !== symbol) {
+      targetSymbol = aliasTarget;
+    }
+  }
+  const declarations = targetSymbol.declarations ?? [];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts3.SyntaxKind.ExportSpecifier) || declarations[0];
+  return { declaration, targetSymbol };
+}
+function serializeDeclaration(declaration, symbol, exportName, ctx) {
+  let result = null;
+  if (ts3.isFunctionDeclaration(declaration)) {
+    result = serializeFunctionExport(declaration, ctx);
+  } else if (ts3.isClassDeclaration(declaration)) {
+    result = serializeClass(declaration, ctx);
+  } else if (ts3.isInterfaceDeclaration(declaration)) {
+    result = serializeInterface(declaration, ctx);
+  } else if (ts3.isTypeAliasDeclaration(declaration)) {
+    result = serializeTypeAlias(declaration, ctx);
+  } else if (ts3.isEnumDeclaration(declaration)) {
+    result = serializeEnum(declaration, ctx);
+  } else if (ts3.isVariableDeclaration(declaration)) {
+    const varStatement = declaration.parent?.parent;
+    if (varStatement && ts3.isVariableStatement(varStatement)) {
+      result = serializeVariable(declaration, varStatement, ctx);
+    }
+  }
+  if (result) {
+    result = withExportName(result, exportName);
+  }
+  return result;
+}
+function withExportName(entry, exportName) {
+  if (entry.name === exportName) {
+    return entry;
+  }
+  return {
+    ...entry,
+    id: exportName,
+    name: entry.name
+  };
+}
+function createEmptySpec(entryFile) {
+  return {
+    openpkg: SCHEMA_VERSION,
+    meta: { name: path2.basename(entryFile, path2.extname(entryFile)) },
+    exports: [],
+    generation: {
+      generator: "@openpkg-ts/extract",
+      timestamp: new Date().toISOString()
+    }
+  };
+}
+async function getPackageMeta(entryFile, baseDir) {
+  const searchDir = baseDir ?? path2.dirname(entryFile);
+  const pkgPath = path2.join(searchDir, "package.json");
+  try {
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      return {
+        name: pkg.name ?? path2.basename(searchDir),
+        version: pkg.version,
+        description: pkg.description
+      };
+    }
+  } catch {}
+  return { name: path2.basename(searchDir) };
+}
+export { createProgram, TypeRegistry, getJSDocComment, getSourceLocation, extractParameters, serializeFunctionExport, serializeClass, serializeInterface, serializeTypeAlias, serializeEnum, serializeVariable, extract };

package/dist/src/index.d.ts

@@ -0,0 +1,123 @@
+import { OpenPkg } from "@openpkg-ts/spec";
+interface ExtractOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+	maxTypeDepth?: number;
+	resolveExternalTypes?: boolean;
+	schemaExtraction?: "static" | "hybrid";
+}
+interface ExtractResult {
+	spec: OpenPkg;
+	diagnostics: Diagnostic[];
+}
+interface Diagnostic {
+	message: string;
+	severity: "error" | "warning" | "info";
+	location?: {
+		file?: string;
+		line?: number;
+		column?: number;
+	};
+}
+interface SerializerContext {
+	typeChecker: import("typescript").TypeChecker;
+	program: import("typescript").Program;
+	sourceFile: import("typescript").SourceFile;
+	maxTypeDepth: number;
+	resolveExternalTypes: boolean;
+}
+declare function extract(options: ExtractOptions): Promise<ExtractResult>;
+import ts from "typescript";
+import { SpecSchema } from "@openpkg-ts/spec";
+type SchemaAdapter = {
+	name: string;
+	detect: (node: ts.Node, checker: ts.TypeChecker) => boolean;
+	extract: (node: ts.Node, checker: ts.TypeChecker) => SpecSchema | null;
+};
+declare function registerAdapter(adapter: SchemaAdapter): void;
+declare function findAdapter(node: ts.Node, checker: ts.TypeChecker): SchemaAdapter | undefined;
+declare function isSchemaType(node: ts.Node, checker: ts.TypeChecker): boolean;
+declare function extractSchemaType(node: ts.Node, checker: ts.TypeChecker): SpecSchema | null;
+declare const zodAdapter: SchemaAdapter;
+declare const typeboxAdapter: SchemaAdapter;
+declare const arktypeAdapter: SchemaAdapter;
+declare const valibotAdapter: SchemaAdapter;
+import ts2 from "typescript";
+import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
+interface StandardSchemaResult {
+	schema: SpecSchema2;
+	vendor: string;
+}
+declare function extractStandardSchemas(_program: ts2.Program, _entryFile: string): StandardSchemaResult[];
+import ts3 from "typescript";
+declare function formatTypeReference(type: ts3.Type, checker: ts3.TypeChecker): string;
+declare function collectReferencedTypes(type: ts3.Type, checker: ts3.TypeChecker, visited?: Set<string>): string[];
+import ts4 from "typescript";
+declare function isExported(node: ts4.Node): boolean;
+declare function getNodeName(node: ts4.Node): string | undefined;
+import ts5 from "typescript";
+import { SpecSignatureParameter } from "@openpkg-ts/spec";
+declare function extractParameters(signature: ts5.Signature, checker: ts5.TypeChecker): SpecSignatureParameter[];
+import ts6 from "typescript";
+import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
+declare function buildSchema(type: ts6.Type, checker: ts6.TypeChecker, depth?: number): SpecSchema3;
+import ts7 from "typescript";
+import { SpecSource, SpecTag } from "@openpkg-ts/spec";
+declare function getJSDocComment(node: ts7.Node): {
+	description?: string;
+	tags: SpecTag[];
+};
+declare function getSourceLocation(node: ts7.Node, sourceFile: ts7.SourceFile): SpecSource;
+import ts8 from "typescript";
+import { SpecType } from "@openpkg-ts/spec";
+declare class TypeRegistry {
+	private types;
+	add(type: SpecType): void;
+	get(id: string): SpecType | undefined;
+	has(id: string): boolean;
+	getAll(): SpecType[];
+	registerFromSymbol(symbol: ts8.Symbol, checker: ts8.TypeChecker): SpecType | undefined;
+}
+import ts10 from "typescript";
+import { SpecExport } from "@openpkg-ts/spec";
+import ts9 from "typescript";
+interface SerializerContext2 {
+	typeChecker: ts9.TypeChecker;
+	program: ts9.Program;
+	sourceFile: ts9.SourceFile;
+	maxTypeDepth: number;
+	resolveExternalTypes: boolean;
+	typeRegistry: TypeRegistry;
+}
+declare function serializeFunctionExport(node: ts10.FunctionDeclaration | ts10.ArrowFunction, ctx: SerializerContext2): SpecExport | null;
+import ts11 from "typescript";
+import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
+declare function serializeClass(node: ts11.ClassDeclaration, ctx: SerializerContext2): SpecExport2 | null;
+import ts12 from "typescript";
+import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
+declare function serializeInterface(node: ts12.InterfaceDeclaration, ctx: SerializerContext2): SpecExport3 | null;
+import ts13 from "typescript";
+import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
+declare function serializeTypeAlias(node: ts13.TypeAliasDeclaration, ctx: SerializerContext2): SpecExport4 | null;
+import ts14 from "typescript";
+import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
+declare function serializeEnum(node: ts14.EnumDeclaration, ctx: SerializerContext2): SpecExport5 | null;
+import ts15 from "typescript";
+import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
+declare function serializeVariable(node: ts15.VariableDeclaration, statement: ts15.VariableStatement, ctx: SerializerContext2): SpecExport6 | null;
+import ts16 from "typescript";
+interface ProgramOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+}
+interface ProgramResult {
+	program: ts16.Program;
+	compilerHost: ts16.CompilerHost;
+	compilerOptions: ts16.CompilerOptions;
+	sourceFile?: ts16.SourceFile;
+	configPath?: string;
+}
+declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
+export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerAdapter, isSchemaType, isExported, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };

package/dist/src/index.js

@@ -0,0 +1,139 @@
+import {
+  TypeRegistry,
+  createProgram,
+  extract,
+  extractParameters,
+  getJSDocComment,
+  getSourceLocation,
+  serializeClass,
+  serializeEnum,
+  serializeFunctionExport,
+  serializeInterface,
+  serializeTypeAlias,
+  serializeVariable
+} from "../shared/chunk-esvc8n1x.js";
+// src/schema/adapters/zod.ts
+var zodAdapter = {
+  name: "zod",
+  detect: () => false,
+  extract: () => null
+};
+// src/schema/adapters/typebox.ts
+var typeboxAdapter = {
+  name: "typebox",
+  detect: () => false,
+  extract: () => null
+};
+// src/schema/adapters/arktype.ts
+var arktypeAdapter = {
+  name: "arktype",
+  detect: () => false,
+  extract: () => null
+};
+// src/schema/adapters/valibot.ts
+var valibotAdapter = {
+  name: "valibot",
+  detect: () => false,
+  extract: () => null
+};
+// src/schema/registry.ts
+var adapters = [];
+function registerAdapter(adapter) {
+  adapters.push(adapter);
+}
+function findAdapter(node, checker) {
+  return adapters.find((a) => a.detect(node, checker));
+}
+function isSchemaType(node, checker) {
+  return adapters.some((a) => a.detect(node, checker));
+}
+function extractSchemaType(node, checker) {
+  const adapter = findAdapter(node, checker);
+  return adapter?.extract(node, checker) ?? null;
+}
+// src/schema/standard-schema.ts
+function extractStandardSchemas(_program, _entryFile) {
+  return [];
+}
+// src/types/formatter.ts
+function formatTypeReference(type, checker) {
+  return checker.typeToString(type);
+}
+function collectReferencedTypes(type, checker, visited = new Set) {
+  const symbol = type.getSymbol();
+  if (!symbol)
+    return [];
+  const name = symbol.getName();
+  if (visited.has(name))
+    return [];
+  visited.add(name);
+  return [name];
+}
+// src/types/utils.ts
+function isExported(node) {
+  const modifiers = node.modifiers;
+  if (!modifiers)
+    return false;
+  return modifiers.some((m) => m.kind === 95);
+}
+function getNodeName(node) {
+  if ("name" in node && node.name) {
+    const name = node.name;
+    return name.text;
+  }
+  return;
+}
+// src/types/schema-builder.ts
+function buildSchema(type, checker, depth = 0) {
+  if (depth > 10) {
+    return { type: checker.typeToString(type) };
+  }
+  const typeString = checker.typeToString(type);
+  if (type.flags & 4)
+    return { type: "string" };
+  if (type.flags & 8)
+    return { type: "number" };
+  if (type.flags & 16)
+    return { type: "boolean" };
+  if (type.flags & 32768)
+    return { type: "undefined" };
+  if (type.flags & 65536)
+    return { type: "null" };
+  if (type.flags & 16384)
+    return { type: "void" };
+  if (type.flags & 1)
+    return { type: "any" };
+  if (type.flags & 2)
+    return { type: "unknown" };
+  if (type.flags & 131072)
+    return { type: "never" };
+  return { type: typeString };
+}
+export {
+  zodAdapter,
+  valibotAdapter,
+  typeboxAdapter,
+  serializeVariable,
+  serializeTypeAlias,
+  serializeInterface,
+  serializeFunctionExport,
+  serializeEnum,
+  serializeClass,
+  registerAdapter,
+  isSchemaType,
+  isExported,
+  getSourceLocation,
+  getNodeName,
+  getJSDocComment,
+  formatTypeReference,
+  findAdapter,
+  extractStandardSchemas,
+  extractSchemaType,
+  extractParameters,
+  extract,
+  createProgram,
+  collectReferencedTypes,
+  buildSchema,
+  arktypeAdapter,
+  TypeRegistry
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@openpkg-ts/extract",
+  "version": "0.1.0",
+  "description": "TypeScript export extraction to OpenPkg spec",
+  "keywords": [
+    "openpkg",
+    "typescript",
+    "api-extractor",
+    "documentation",
+    "type-extraction"
+  ],
+  "homepage": "https://github.com/doccov/doccov#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doccov/doccov.git",
+    "directory": "packages/extract"
+  },
+  "license": "MIT",
+  "author": "Ryan Waits",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "tspec": "./dist/bin/tspec.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bunup",
+    "dev": "bunup --watch",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "format": "biome format --write src/"
+  },
+  "dependencies": {
+    "@openpkg-ts/spec": "workspace:*",
+    "commander": "^12.0.0",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
+    "bunup": "latest"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}