@askills/openapi-explorer-cli 0.0.3 → 0.0.4

package/src/core/queries.ts

@@ -1,165 +0,0 @@
-import type {
-  OpenAPISpec,
-  EndpointSummary,
-  SchemaSummary,
-  SearchResult,
-} from "../types.ts";
-
-const HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "options",
-  "head",
-] as const;
-const METHOD_PRIORITY: Record<string, number> = {
-  get: 0,
-  post: 1,
-  put: 2,
-  patch: 3,
-  delete: 4,
-  options: 5,
-  head: 6,
-};
-
-export function getEndpoints(
-  spec: OpenAPISpec,
-  tag?: string,
-): EndpointSummary[] {
-  const eps: EndpointSummary[] = [];
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    for (const method of HTTP_METHODS) {
-      const op = pathItem[method];
-      if (!op) continue;
-      if (tag && (!op.tags || !op.tags.includes(tag))) continue;
-      eps.push({
-        path,
-        method,
-        summary:
-          op.summary || op.operationId || `${method.toUpperCase()} ${path}`,
-        operationId: op.operationId,
-        tags: op.tags || [],
-        deprecated: op.deprecated || false,
-      });
-    }
-  }
-  eps.sort((a, b) => {
-    if (a.path !== b.path) return a.path.localeCompare(b.path);
-    return (
-      (METHOD_PRIORITY[a.method] ?? 99) - (METHOD_PRIORITY[b.method] ?? 99)
-    );
-  });
-  return eps;
-}
-
-export function getTags(spec: OpenAPISpec): { name: string; count: number }[] {
-  const counts = new Map<string, number>();
-  for (const pathItem of Object.values(spec.paths)) {
-    for (const method of HTTP_METHODS) {
-      const op = pathItem[method];
-      if (!op?.tags) continue;
-      for (const tag of op.tags) counts.set(tag, (counts.get(tag) || 0) + 1);
-    }
-  }
-  return Array.from(counts.entries())
-    .map(([name, count]) => ({ name, count }))
-    .sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function getSchemas(spec: OpenAPISpec): SchemaSummary[] {
-  const schemas = spec.components?.schemas || spec.definitions || {};
-  return Object.entries(schemas)
-    .map(([name, s]) => ({
-      name,
-      type: (s as any).type || "object",
-      description: (s as any).description || (s as any).title,
-      properties: (s as any).properties
-        ? Object.keys((s as any).properties).length
-        : 0,
-    }))
-    .sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function getSchemaDetail(spec: OpenAPISpec, name: string): unknown {
-  return (spec.components?.schemas || spec.definitions || {})[name] || null;
-}
-
-export function getPathParams(path: string): string[] {
-  const m = path.match(/\{(\w+)\}/g);
-  return m ? m.map((s) => s.slice(1, -1)) : [];
-}
-
-export function searchSpec(spec: OpenAPISpec, query: string): SearchResult[] {
-  const results: SearchResult[] = [];
-  const lower = query.toLowerCase();
-
-  for (const [path, pi] of Object.entries(spec.paths)) {
-    for (const method of HTTP_METHODS) {
-      const op = pi[method];
-      if (!op) continue;
-      const text = [
-        path,
-        method,
-        op.summary,
-        op.operationId,
-        op.description,
-        ...(op.tags || []),
-      ]
-        .filter(Boolean)
-        .join(" ")
-        .toLowerCase();
-      if (text.includes(lower)) {
-        results.push({
-          type: "endpoint",
-          path,
-          method,
-          match: `${method.toUpperCase()} ${path}`,
-          summary: op.summary || op.operationId,
-        });
-      }
-    }
-  }
-
-  const schemas = spec.components?.schemas || spec.definitions || {};
-  for (const [name, s] of Object.entries(schemas)) {
-    const sAny = s as any;
-    if (
-      [name, sAny.description, sAny.title]
-        .filter(Boolean)
-        .join(" ")
-        .toLowerCase()
-        .includes(lower)
-    ) {
-      results.push({
-        type: "schema",
-        schemaName: name,
-        match: `Schema: ${name}`,
-        summary: sAny.description,
-      });
-    }
-    if (sAny.properties) {
-      for (const [pn, ps] of Object.entries(sAny.properties)) {
-        const psAny = ps as any;
-        if (
-          [pn, psAny.description]
-            .filter(Boolean)
-            .join(" ")
-            .toLowerCase()
-            .includes(lower)
-        ) {
-          results.push({
-            type: "property",
-            schemaName: name,
-            propertyName: pn,
-            match: `Schema ${name} > ${pn}`,
-            summary: psAny.description,
-          });
-        }
-      }
-    }
-  }
-
-  return results;
-}

package/src/core/resolve.ts

@@ -1,70 +0,0 @@
-import type { OpenAPISpec } from "../types.ts";
-
-export function resolveRef(spec: OpenAPISpec, ref: string): unknown {
-  const parts = ref.replace(/^#\//, "").split("/");
-  let cur: unknown = spec as unknown as Record<string, unknown>;
-  for (const p of parts) {
-    if (
-      cur &&
-      typeof cur === "object" &&
-      p in (cur as Record<string, unknown>)
-    ) {
-      cur = (cur as Record<string, unknown>)[p];
-    } else {
-      return null;
-    }
-  }
-  return cur;
-}
-
-export function deepResolve(
-  schema: unknown,
-  spec: OpenAPISpec,
-  visited = new Set<string>(),
-): unknown {
-  if (!schema || typeof schema !== "object") return schema;
-
-  const obj = schema as Record<string, unknown>;
-
-  if (obj.$ref && typeof obj.$ref === "string") {
-    if (visited.has(obj.$ref))
-      return { $ref: obj.$ref, description: `(circular: ${obj.$ref})` };
-    visited.add(obj.$ref);
-    const resolved = resolveRef(spec, obj.$ref);
-    if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
-      const base = deepResolve(resolved, spec, new Set(visited)) as Record<
-        string,
-        unknown
-      >;
-      const merged = { ...base };
-      for (const k of Object.keys(obj)) if (k !== "$ref") merged[k] = obj[k];
-      return merged;
-    }
-    return obj;
-  }
-
-  const result: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (k === "properties" && v && typeof v === "object") {
-      const props: Record<string, unknown> = {};
-      for (const [pn, ps] of Object.entries(v as Record<string, unknown>)) {
-        props[pn] = deepResolve(ps, spec, new Set(visited));
-      }
-      result[k] = props;
-    } else if (
-      (k === "items" || k === "additionalProperties") &&
-      v &&
-      typeof v === "object" &&
-      !Array.isArray(v)
-    ) {
-      result[k] = deepResolve(v, spec, new Set(visited));
-    } else if (["oneOf", "anyOf", "allOf"].includes(k) && Array.isArray(v)) {
-      result[k] = (v as unknown[]).map((s) =>
-        deepResolve(s, spec, new Set(visited)),
-      );
-    } else {
-      result[k] = v;
-    }
-  }
-  return result;
-}

package/src/formatters/endpoint.ts

@@ -1,74 +0,0 @@
-import type { FormattedEndpoint } from "../types.ts";
-import { fmtSchema } from "./schema.ts";
-
-export function fmtEndpoint(ep: FormattedEndpoint): string {
-  const lines: string[] = [`# ${ep.method.toUpperCase()} ${ep.path}`];
-  if (ep.deprecated) lines.push("", "DEPRECATED");
-  if (ep.summary) lines.push("", ep.summary);
-  if (ep.description) lines.push("", ep.description);
-  if (ep.operationId) lines.push("", `Operation ID: \`${ep.operationId}\``);
-  if (ep.tags?.length)
-    lines.push("", `Tags: ${ep.tags.map((t) => `\`${t}\``).join(", ")}`);
-
-  if (ep.parameters?.length) {
-    lines.push(
-      "",
-      "## Parameters",
-      "",
-      "| Name | In | Type | Required | Description |",
-      "|------|----|------|----------|-------------|",
-    );
-    for (const p of ep.parameters) {
-      lines.push(
-        `| \`${p.name}\` | ${p.in} | ${p.schema?.type || p.type || "string"} | ${p.required ? "Yes" : "No"} | ${p.description || ""} |`,
-      );
-    }
-  }
-
-  if (ep.requestBody) {
-    lines.push("", "## Request Body");
-    if (ep.requestBody.required) lines.push("> Required");
-    if (ep.requestBody.description) lines.push("", ep.requestBody.description);
-    for (const [ct, mt] of Object.entries(ep.requestBody.content || {})) {
-      lines.push(
-        "",
-        `${ct}:`,
-        "```",
-        fmtSchema((mt as any).schema || {}),
-        "```",
-      );
-    }
-  }
-
-  if (ep.responses) {
-    lines.push("", "## Responses");
-    for (const [code, resp] of Object.entries(ep.responses)) {
-      const r = resp as any;
-      lines.push("", `### ${code}`, r.description);
-      if (r.content) {
-        for (const [ct, mt] of Object.entries(r.content)) {
-          lines.push(
-            "",
-            `${ct}:`,
-            "```",
-            fmtSchema((mt as any).schema || {}),
-            "```",
-          );
-        }
-      }
-    }
-  }
-
-  if (ep.security?.length) {
-    lines.push("", "## Security");
-    for (const sec of ep.security) {
-      for (const [scheme, scopes] of Object.entries(sec)) {
-        lines.push(
-          `- \`${scheme}\`${Array.isArray(scopes) && scopes.length ? ` [${scopes.join(", ")}]` : ""}`,
-        );
-      }
-    }
-  }
-
-  return lines.join("\n");
-}

package/src/formatters/schema.ts

@@ -1,66 +0,0 @@
-export function fmtSchema(schema: unknown, indent = 0): string {
-  const pad = "  ".repeat(indent);
-  if (!schema || typeof schema !== "object") return `${pad}${String(schema)}`;
-
-  const s = schema as Record<string, unknown>;
-
-  if (s.$ref && typeof s.$ref === "string") {
-    return `${pad}$ref: "${(s.$ref as string).split("/").pop()}"`;
-  }
-
-  if (s.enum && Array.isArray(s.enum)) {
-    return `${pad}enum: [${s.enum.map((v) => JSON.stringify(v)).join(", ")}]`;
-  }
-
-  for (const kw of ["oneOf", "anyOf", "allOf"] as const) {
-    if (s[kw] && Array.isArray(s[kw])) {
-      const lines = [`${pad}${kw}:`];
-      for (let i = 0; i < s[kw].length; i++) {
-        if (i > 0) lines.push(`${pad}  ---`);
-        lines.push(fmtSchema(s[kw][i], indent + 1));
-      }
-      return lines.join("\n");
-    }
-  }
-
-  const allLines: string[] = [];
-
-  if (s.description && typeof s.description === "string") {
-    allLines.push(`${pad}// ${s.description}`);
-  }
-
-  allLines.push(
-    `${pad}type: ${s.type || "any"}${s.format ? `<${s.format}>` : ""}${s.nullable ? " | null" : ""}`,
-  );
-
-  if (s.properties && typeof s.properties === "object") {
-    const req = new Set<string>(Array.isArray(s.required) ? s.required : []);
-    for (const [pn, ps] of Object.entries(
-      s.properties as Record<string, unknown>,
-    )) {
-      allLines.push(`${pad}${pn}${req.has(pn) ? " (required)" : ""}:`);
-      allLines.push(fmtSchema(ps, indent + 1));
-    }
-  }
-
-  if (s.items) {
-    allLines.push(`${pad}items:`);
-    allLines.push(fmtSchema(s.items, indent + 1));
-  }
-
-  if (s.additionalProperties && typeof s.additionalProperties === "object") {
-    allLines.push(`${pad}additionalProperties:`);
-    allLines.push(fmtSchema(s.additionalProperties, indent + 1));
-  }
-
-  if (s.example !== undefined)
-    allLines.push(`${pad}example: ${JSON.stringify(s.example)}`);
-  if (s.default !== undefined)
-    allLines.push(`${pad}default: ${JSON.stringify(s.default)}`);
-  for (const k of ["minLength", "maxLength", "minimum", "maximum"] as const) {
-    if (s[k] !== undefined) allLines.push(`${pad}${k}: ${s[k] as number}`);
-  }
-  if (s.pattern) allLines.push(`${pad}pattern: ${s.pattern as string}`);
-
-  return allLines.join("\n");
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-import { dispatch } from "./cli/dispatch.js";
-
-async function main() {
-  const output = await dispatch(process.argv);
-  console.log(output);
-}
-
-main().catch((err) => {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-});

package/src/types.ts

@@ -1,60 +0,0 @@
-export interface OpenAPISpec {
-  openapi?: string;
-  swagger?: string;
-  info: {
-    title?: string;
-    version?: string;
-    description?: string;
-    contact?: Record<string, string>;
-    license?: { name: string; url?: string };
-  };
-  paths: Record<string, Record<string, any>>;
-  components?: { schemas?: Record<string, any> };
-  definitions?: Record<string, any>;
-  servers?: { url: string }[];
-  host?: string;
-  basePath?: string;
-  schemes?: string[];
-  consumes?: string[];
-  produces?: string[];
-}
-
-export interface EndpointSummary {
-  path: string;
-  method: string;
-  summary: string;
-  operationId?: string;
-  tags: string[];
-  deprecated: boolean;
-}
-
-export interface SchemaSummary {
-  name: string;
-  type: string;
-  description?: string;
-  properties: number;
-}
-
-export interface SearchResult {
-  type: "endpoint" | "schema" | "property";
-  path?: string;
-  method?: string;
-  schemaName?: string;
-  propertyName?: string;
-  match: string;
-  summary?: string;
-}
-
-export interface FormattedEndpoint {
-  path: string;
-  method: string;
-  summary?: string;
-  description?: string;
-  operationId?: string;
-  tags: string[];
-  deprecated: boolean;
-  parameters?: any[];
-  requestBody?: any;
-  responses?: any;
-  security?: any[];
-}