Function adaptPlugin

src/ast/native-loader.ts:304–359

Map a raw LoadedPlugin to codesight's domain types. A method is exposed only * when the plugin exports the matching capability (so callers can detect it).

(loaded: LoadedPlugin)

/** Map a raw LoadedPlugin to codesight's domain types. A method is exposed only
 *  when the plugin exports the matching capability (so callers can detect it). */
function adaptPlugin(loaded: LoadedPlugin): NativePlugin {
  const np: NativePlugin = {};

  if (loaded.routes) {
    np.routes = (file, content, framework, tags) => {
      const raw = loaded.routes!(content);
      if (!Array.isArray(raw)) return null;
      return raw.map((x: any): RouteInfo => {
        const path = String(x?.path ?? "");
        return {
          method: String(x?.method ?? "ALL"),
          path,
          file,
          tags,
          framework,
          params: Array.isArray(x?.params) ? x.params.map(String) : extractPathParams(path),
          confidence: "native",
          ...(Array.isArray(x?.middleware) ? { middleware: x.middleware.map(String) } : {}),
        };
      });
    };
  }

  if (loaded.schemas) {
    np.schemas = (_file, content) => {
      const raw = loaded.schemas!(content);
      if (!Array.isArray(raw)) return null;
      return raw.map((m: any): SchemaModel => ({
        name: String(m?.name ?? ""),
        fields: (Array.isArray(m?.fields) ? m.fields : []).map((f: any): SchemaField => ({
          name: String(f?.name ?? ""),
          type: String(f?.type ?? "unknown"),
          flags: Array.isArray(f?.flags) ? f.flags.map(String) : [],
        })),
        relations: (Array.isArray(m?.relations) ? m.relations : []).map(String),
        orm: (m?.orm ?? "unknown") as ORM,
        confidence: "native",
      }));
    };
  }

  // `imports` is part of the published contract and exercised by the conformance
  // test, but no scan dispatches to it yet (see detectors/graph.ts).
  if (loaded.imports) {
    np.imports = (file, content) => {
      const raw = loaded.imports!(content);
      if (!Array.isArray(raw)) return null;
      return raw.map((x: any): ImportEdge => ({
        from: file,
        to: typeof x === "string" ? x : String(x?.to ?? ""),
      }));
    };
  }

  return np;
}

function extractPathParams(path: string): string[] {