@mugwork/mug 0.1.0

package/dist/src/connector-parser.js

@@ -0,0 +1,94 @@
+import * as acorn from "acorn";
+import * as walk from "acorn-walk";
+import { transformSync } from "esbuild";
+export function parseSourceFile(source, fileName) {
+    const tableComments = extractTableComments(source);
+    const js = transformSync(source, { loader: "ts", target: "es2022" }).code;
+    const ast = acorn.parse(js, { ecmaVersion: 2022, sourceType: "module" });
+    let result = null;
+    walk.simple(ast, {
+        CallExpression(node) {
+            const callee = node.callee?.name;
+            if (callee !== "connector" && callee !== "source")
+                return;
+            const args = node.arguments;
+            if (args.length < 1 || args[0].type !== "ObjectExpression")
+                return;
+            const def = args[0];
+            const name = getStringProp(def, "name", js);
+            const database = getStringProp(def, "database", js);
+            const description = getStringProp(def, "description", js);
+            const baseUrl = getStringProp(def, "baseUrl", js);
+            if (!name || !database)
+                return;
+            const tables = [];
+            const tablesProp = findProp(def, "tables");
+            if (tablesProp?.value?.type === "ArrayExpression") {
+                let tableIdx = 0;
+                for (const el of tablesProp.value.elements ?? []) {
+                    if (el?.type !== "ObjectExpression")
+                        continue;
+                    const tName = getStringProp(el, "name", js);
+                    const tPK = getStringProp(el, "primaryKey", js);
+                    const tEndpoint = getStringProp(el, "endpoint", js);
+                    if (!tName)
+                        continue;
+                    const tDesc = tableComments[tableIdx] || undefined;
+                    tableIdx++;
+                    tables.push({
+                        name: tName,
+                        primaryKey: tPK ?? "id",
+                        endpoint: tEndpoint,
+                        description: tDesc,
+                    });
+                }
+            }
+            result = { name, description, database, tables, baseUrl };
+        },
+    });
+    return result;
+}
+function extractTableComments(source) {
+    const lines = source.split("\n");
+    const comments = [];
+    for (let i = 0; i < lines.length; i++) {
+        const nameMatch = lines[i].match(/^(\s*)name:\s*["']/);
+        if (!nameMatch || nameMatch[1].length < 6)
+            continue;
+        const commentLines = [];
+        for (let j = i - 1; j >= 0; j--) {
+            const prev = lines[j].trim();
+            if (prev === "" || prev === "{")
+                continue;
+            if (prev.startsWith("//")) {
+                commentLines.unshift(prev.replace(/^\/\/\s*/, ""));
+            }
+            else {
+                break;
+            }
+        }
+        comments.push(commentLines.join(" "));
+    }
+    return comments;
+}
+function findProp(obj, name) {
+    for (const prop of obj.properties ?? []) {
+        if (prop.type === "SpreadElement")
+            continue;
+        const key = prop.key?.name ?? prop.key?.value;
+        if (key === name)
+            return prop;
+    }
+    return undefined;
+}
+function getStringProp(obj, name, source) {
+    const prop = findProp(obj, name);
+    if (!prop)
+        return undefined;
+    const val = prop.value;
+    if (val?.type === "Literal" && typeof val.value === "string")
+        return val.value;
+    if (val?.type === "TemplateLiteral")
+        return source.slice(val.start + 1, val.end - 1);
+    return undefined;
+}

package/dist/src/connector-service/discover.d.ts

@@ -0,0 +1,37 @@
+import type { ApiMetadata, ApiTier, ApiType, AuthConfig } from "./types.js";
+export interface DiscoverInput {
+    product: string;
+    tier?: ApiTier;
+    hasApi?: boolean;
+    apiType?: ApiType;
+    docsUrl?: string;
+    specUrl?: string;
+    auth?: AuthConfig;
+    alternatives?: string[];
+    notes?: string;
+    integrations?: {
+        zapier?: boolean;
+        make?: boolean;
+        n8n?: boolean;
+    };
+}
+export interface DiscoverResult {
+    slug: string;
+    meta: ApiMetadata;
+    cached: boolean;
+    nextStep: NextStep;
+}
+export type NextStep = {
+    action: "gather-from-spec";
+    specUrl: string;
+} | {
+    action: "gather-from-docs";
+    docsUrl: string;
+} | {
+    action: "gather-from-har";
+    reason: string;
+} | {
+    action: "no-api";
+    reason: string;
+};
+export declare function discover(workspaceRoot: string, input: DiscoverInput): DiscoverResult;

package/dist/src/connector-service/discover.js

@@ -0,0 +1,79 @@
+import { readMeta, writeMeta, slugify } from "./spec-storage.js";
+export function discover(workspaceRoot, input) {
+    const slug = slugify(input.product);
+    const existing = readMeta(workspaceRoot, slug);
+    if (existing && !inputHasNewData(input)) {
+        return {
+            slug,
+            meta: existing,
+            cached: true,
+            nextStep: routeNextStep(existing),
+        };
+    }
+    const hasApi = input.hasApi ?? inferHasApi(input);
+    const tier = input.tier ?? inferTier(input);
+    const meta = {
+        name: input.product,
+        slug,
+        hasApi,
+        apiType: input.apiType ?? (hasApi ? "rest" : "unknown"),
+        docsUrl: input.docsUrl,
+        openapiSpecUrl: input.specUrl,
+        auth: input.auth,
+        tier,
+        alternatives: input.alternatives,
+        lastVerified: new Date().toISOString(),
+        notes: buildNotes(input),
+    };
+    writeMeta(workspaceRoot, slug, meta);
+    return {
+        slug,
+        meta,
+        cached: false,
+        nextStep: routeNextStep(meta),
+    };
+}
+function inputHasNewData(input) {
+    return !!(input.tier || input.hasApi !== undefined || input.docsUrl || input.specUrl || input.auth || input.apiType);
+}
+function inferHasApi(input) {
+    if (input.specUrl || input.docsUrl)
+        return true;
+    if (input.integrations?.zapier || input.integrations?.make || input.integrations?.n8n)
+        return true;
+    return false;
+}
+function inferTier(input) {
+    if (input.specUrl)
+        return 1;
+    if (input.docsUrl)
+        return 2;
+    return 3;
+}
+function buildNotes(input) {
+    const parts = [];
+    if (input.notes)
+        parts.push(input.notes);
+    const integrations = input.integrations;
+    if (integrations) {
+        const found = Object.entries(integrations)
+            .filter(([, v]) => v)
+            .map(([k]) => k);
+        if (found.length > 0) {
+            parts.push(`Integration platforms: ${found.join(", ")}`);
+        }
+    }
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
+function routeNextStep(meta) {
+    if (!meta.hasApi) {
+        return { action: "no-api", reason: `No API found for ${meta.name}` };
+    }
+    if (meta.openapiSpecUrl) {
+        return { action: "gather-from-spec", specUrl: meta.openapiSpecUrl };
+    }
+    if (meta.docsUrl) {
+        return { action: "gather-from-docs", docsUrl: meta.docsUrl };
+    }
+    return { action: "gather-from-har", reason: `${meta.name} has an API but no spec or docs URL — capture browser traffic as HAR` };
+}

package/dist/src/connector-service/gather.d.ts

@@ -0,0 +1,22 @@
+export interface GatherResult {
+    slug: string;
+    endpointCount: number;
+    qualityScore: number;
+    warnings: string[];
+    specPath: string;
+}
+export interface NormalizeResult {
+    spec: Record<string, unknown>;
+    converted: boolean;
+    originalVersion?: string;
+}
+export interface LintResult {
+    score: number;
+    warnings: string[];
+    errors: string[];
+}
+export declare function gatherFromSpec(workspaceRoot: string, slug: string, url: string): Promise<GatherResult>;
+export declare function gatherFromFile(workspaceRoot: string, slug: string, filePath: string): Promise<GatherResult>;
+export declare function gatherFromHar(workspaceRoot: string, slug: string, harPath: string): Promise<GatherResult>;
+export declare function normalize(raw: Record<string, unknown>): Promise<NormalizeResult>;
+export declare function lintSpec(spec: Record<string, unknown>): Promise<LintResult>;

package/dist/src/connector-service/gather.js

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { parse as yamlParse } from "yaml";
+import { writeSpec, ensureSpecDir } from "./spec-storage.js";
+export async function gatherFromSpec(workspaceRoot, slug, url) {
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch spec from ${url}: ${res.status} ${res.statusText}`);
+    }
+    const body = await res.text();
+    const raw = parseSpecString(body);
+    return processSpec(workspaceRoot, slug, raw);
+}
+export async function gatherFromFile(workspaceRoot, slug, filePath) {
+    const body = readFileSync(filePath, "utf-8");
+    const raw = parseSpecString(body);
+    return processSpec(workspaceRoot, slug, raw);
+}
+export async function gatherFromHar(workspaceRoot, slug, harPath) {
+    const { generateSpec } = await import("har-to-openapi");
+    const harContent = JSON.parse(readFileSync(harPath, "utf-8"));
+    const result = await generateSpec(harContent);
+    return processSpec(workspaceRoot, slug, result.spec);
+}
+async function processSpec(workspaceRoot, slug, raw) {
+    const { spec } = await normalize(raw);
+    const lint = await lintSpec(spec);
+    ensureSpecDir(workspaceRoot, slug);
+    writeSpec(workspaceRoot, slug, spec);
+    const paths = spec.paths;
+    const endpointCount = paths ? Object.keys(paths).length : 0;
+    const specPath = `src/connectors/.specs/${slug}/openapi.yaml`;
+    return {
+        slug,
+        endpointCount,
+        qualityScore: lint.score,
+        warnings: [...lint.errors, ...lint.warnings],
+        specPath,
+    };
+}
+export async function normalize(raw) {
+    const version = detectVersion(raw);
+    if (version === "2.0") {
+        const s2o = await import("swagger2openapi");
+        const result = await s2o.default.convertObj(raw, { patch: true, warnOnly: true });
+        return { spec: result.openapi, converted: true, originalVersion: "2.0" };
+    }
+    return { spec: resolveLocalRefs(raw), converted: false };
+}
+export async function lintSpec(spec) {
+    try {
+        const { Spectral } = await import("@stoplight/spectral-core");
+        const { oas } = await import("@stoplight/spectral-rulesets");
+        const spectral = new Spectral();
+        spectral.setRuleset(oas);
+        const results = await spectral.run(spec);
+        const errors = results.filter((r) => r.severity === 0).map((r) => r.message);
+        const warnings = results.filter((r) => r.severity === 1).map((r) => r.message);
+        const infos = results.filter((r) => r.severity >= 2);
+        const total = results.length || 1;
+        const errorPenalty = errors.length * 10;
+        const warnPenalty = warnings.length * 3;
+        const score = Math.max(0, Math.min(100, 100 - errorPenalty - warnPenalty));
+        return { score, warnings: dedupe(warnings), errors: dedupe(errors) };
+    }
+    catch {
+        return { score: 50, warnings: ["Spectral lint unavailable — score estimated"], errors: [] };
+    }
+}
+function detectVersion(spec) {
+    if (typeof spec.swagger === "string")
+        return spec.swagger;
+    if (typeof spec.openapi === "string")
+        return spec.openapi;
+    return "unknown";
+}
+function resolveLocalRefs(spec) {
+    // For OpenAPI 3.x, return as-is — full $ref resolution happens during verify
+    return spec;
+}
+function parseSpecString(body) {
+    const trimmed = body.trim();
+    if (trimmed.startsWith("{")) {
+        return JSON.parse(trimmed);
+    }
+    return yamlParse(trimmed);
+}
+function dedupe(arr) {
+    return [...new Set(arr)];
+}

package/dist/src/connector-service/init.d.ts

@@ -0,0 +1,14 @@
+import { type ScaffoldResult } from "./scaffold.js";
+export interface InitResult {
+    slug: string;
+    steps: StepResult[];
+    finalOutput?: ScaffoldResult;
+    stoppedAt?: string;
+    nextAction?: string;
+}
+export interface StepResult {
+    step: string;
+    status: "done" | "skipped" | "stopped";
+    summary: string;
+}
+export declare function init(workspaceRoot: string, product: string, sourceName?: string): Promise<InitResult>;

package/dist/src/connector-service/init.js

@@ -0,0 +1,109 @@
+import { readMeta, slugify } from "./spec-storage.js";
+import { gatherFromSpec } from "./gather.js";
+import { verify } from "./verify.js";
+import { scaffold } from "./scaffold.js";
+export async function init(workspaceRoot, product, sourceName) {
+    const slug = slugify(product);
+    const steps = [];
+    // Step 1 — Discover (check cache)
+    const meta = readMeta(workspaceRoot, slug);
+    if (!meta) {
+        steps.push({
+            step: "discover",
+            status: "stopped",
+            summary: `No metadata found for "${product}". Run discover first with research findings.`,
+        });
+        return {
+            slug,
+            steps,
+            stoppedAt: "discover",
+            nextAction: `mug source discover "${product}" --tier <n> --docs-url <url> [--spec-url <url>]`,
+        };
+    }
+    steps.push({ step: "discover", status: "done", summary: `Tier ${meta.tier} — ${meta.apiType}` });
+    if (!meta.hasApi) {
+        steps.push({ step: "gather", status: "stopped", summary: `${product} has no API` });
+        return { slug, steps, stoppedAt: "gather", nextAction: "No API available — cannot build source" };
+    }
+    // Step 2 — Gather
+    if (meta.openapiSpecUrl) {
+        try {
+            const result = await gatherFromSpec(workspaceRoot, slug, meta.openapiSpecUrl);
+            steps.push({ step: "gather", status: "done", summary: `${result.endpointCount} endpoints, quality ${result.qualityScore}/100` });
+        }
+        catch (err) {
+            steps.push({ step: "gather", status: "stopped", summary: `Fetch failed: ${err instanceof Error ? err.message : err}` });
+            return {
+                slug,
+                steps,
+                stoppedAt: "gather",
+                nextAction: `Spec URL failed. Try: mug source gather --slug ${slug} --from-file <agent-generated-spec>`,
+            };
+        }
+    }
+    else if (meta.docsUrl) {
+        steps.push({
+            step: "gather",
+            status: "stopped",
+            summary: `Tier 2 — docs exist but no spec URL. Agent should generate spec from docs.`,
+        });
+        return {
+            slug,
+            steps,
+            stoppedAt: "gather",
+            nextAction: `Read docs at ${meta.docsUrl}, generate OpenAPI spec, then: mug source gather --slug ${slug} --from-file <spec-file>`,
+        };
+    }
+    else {
+        steps.push({
+            step: "gather",
+            status: "stopped",
+            summary: `Tier 3 — no spec or docs. Need HAR capture.`,
+        });
+        return {
+            slug,
+            steps,
+            stoppedAt: "gather",
+            nextAction: `Capture browser traffic as HAR, then: mug source gather --slug ${slug} --from-har <har-file>`,
+        };
+    }
+    // Step 3 — Verify
+    if (sourceName) {
+        try {
+            const result = await verify(workspaceRoot, slug, sourceName);
+            const passCount = result.probes.filter((p) => p.status === "pass").length;
+            steps.push({ step: "verify", status: "done", summary: `${result.overallStatus} — ${passCount}/7 probes passed` });
+        }
+        catch (err) {
+            steps.push({ step: "verify", status: "stopped", summary: `Verify failed: ${err instanceof Error ? err.message : err}` });
+            return {
+                slug,
+                steps,
+                stoppedAt: "verify",
+                nextAction: `Fix source config in mug.json, then: mug source verify --slug ${slug} --source ${sourceName}`,
+            };
+        }
+    }
+    else {
+        steps.push({
+            step: "verify",
+            status: "skipped",
+            summary: "No --source provided — skipping verification",
+        });
+    }
+    // Step 4 — Scaffold
+    try {
+        const result = scaffold(workspaceRoot, slug);
+        steps.push({ step: "scaffold", status: "done", summary: `${result.tableCount} tables → ${result.outputPath}` });
+        return { slug, steps, finalOutput: result };
+    }
+    catch (err) {
+        steps.push({ step: "scaffold", status: "stopped", summary: `Scaffold failed: ${err instanceof Error ? err.message : err}` });
+        return {
+            slug,
+            steps,
+            stoppedAt: "scaffold",
+            nextAction: `mug source scaffold --slug ${slug}`,
+        };
+    }
+}

package/dist/src/connector-service/scaffold.d.ts

@@ -0,0 +1,17 @@
+export interface ScaffoldResult {
+    slug: string;
+    outputPath: string;
+    tableCount: number;
+    tables: TableInfo[];
+    syncStrategy: string;
+}
+interface TableInfo {
+    name: string;
+    endpoint: string;
+    primaryKey: string;
+    fieldCount: number;
+    pagination: string | null;
+    incrementalSync: boolean;
+}
+export declare function scaffold(workspaceRoot: string, slug: string): ScaffoldResult;
+export {};

package/dist/src/connector-service/scaffold.js

@@ -0,0 +1,194 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { readSpec, readMeta } from "./spec-storage.js";
+export function scaffold(workspaceRoot, slug) {
+    const spec = readSpec(workspaceRoot, slug);
+    if (!spec)
+        throw new Error(`No spec found for "${slug}" — run gather first`);
+    const meta = readMeta(workspaceRoot, slug);
+    const baseUrl = extractBaseUrl(spec);
+    const rateLimits = spec["x-mug-rate-limits"];
+    const endpoints = extractListEndpoints(spec);
+    if (endpoints.length === 0) {
+        throw new Error(`No list endpoints found in spec for "${slug}" — nothing to scaffold`);
+    }
+    const tables = endpoints.map((ep) => buildTableInfo(ep));
+    const code = generateCode(slug, baseUrl, meta?.auth?.type, rateLimits, endpoints, tables);
+    const sourcesDir = join(workspaceRoot, "src", "sources");
+    mkdirSync(sourcesDir, { recursive: true });
+    const outputPath = join(sourcesDir, `${slug}.ts`);
+    writeFileSync(outputPath, code);
+    const hasIncremental = tables.some((t) => t.incrementalSync);
+    const syncStrategy = hasIncremental ? "incremental where supported, full sync fallback" : "full sync";
+    return {
+        slug,
+        outputPath: `src/sources/${slug}.ts`,
+        tableCount: tables.length,
+        tables,
+        syncStrategy,
+    };
+}
+function extractBaseUrl(spec) {
+    const servers = spec.servers;
+    return servers?.[0]?.url ?? "https://api.example.com";
+}
+function extractListEndpoints(spec) {
+    const paths = spec.paths;
+    if (!paths)
+        return [];
+    const endpoints = [];
+    for (const [path, pathItem] of Object.entries(paths)) {
+        const op = pathItem.get;
+        if (!op)
+            continue;
+        if (path.match(/\{[^}]+\}$/))
+            continue;
+        const pagination = pathItem["x-mug-pagination"];
+        const sync = pathItem["x-mug-sync"];
+        const responses = op.responses;
+        let responseSchema;
+        const ok = responses?.["200"] ?? responses?.["201"];
+        if (ok?.content) {
+            const content = ok.content;
+            const json = content["application/json"] ?? content["application/xml"];
+            responseSchema = json?.schema;
+        }
+        endpoints.push({
+            path,
+            operationId: op.operationId,
+            responseSchema,
+            pagination,
+            sync,
+            parameters: op.parameters,
+        });
+    }
+    return endpoints;
+}
+function buildTableInfo(ep) {
+    const name = tableNameFromPath(ep.path);
+    const fields = countFields(ep.responseSchema);
+    return {
+        name,
+        endpoint: ep.path,
+        primaryKey: "id",
+        fieldCount: fields,
+        pagination: ep.pagination?.style ?? null,
+        incrementalSync: ep.sync?.supportsIncrementalSync ?? false,
+    };
+}
+function tableNameFromPath(path) {
+    return path
+        .replace(/^\//, "")
+        .replace(/\//g, "_")
+        .replace(/[^a-zA-Z0-9_]/g, "")
+        .toLowerCase();
+}
+function countFields(schema) {
+    if (!schema)
+        return 0;
+    if (schema.type === "array") {
+        const items = schema.items;
+        return countFields(items);
+    }
+    const props = schema.properties;
+    return props ? Object.keys(props).length : 0;
+}
+function generateCode(slug, baseUrl, authType, rateLimits, endpoints, tables) {
+    const lines = [];
+    lines.push(`import { source, type SourceContext } from "../source.js";`);
+    lines.push(``);
+    // Auth helper — still needed for the fetch fallback
+    const credName = authType === "bearer" || authType === "oauth2" ? "token"
+        : authType === "basic" ? "credentials" : "api_key";
+    const authHeader = authType === "basic"
+        ? '`Basic ${btoa(cred)}`'
+        : '`Bearer ${cred}`';
+    lines.push(`async function authedFetch(url: string, ctx: SourceContext): Promise<Record<string, unknown>[]> {`);
+    lines.push(`  const cred = await ctx.credential("${credName}");`);
+    lines.push(`  const res = await fetch(url, { headers: { Authorization: ${authHeader} } });`);
+    lines.push(`  if (!res.ok) throw new Error(\`\${res.status} \${res.statusText}: \${url}\`);`);
+    lines.push(`  const body = await res.json() as any;`);
+    lines.push(`  return Array.isArray(body) ? body : (body.data ?? body.results ?? body.records ?? body.items ?? []);`);
+    lines.push(`}`);
+    lines.push(``);
+    // Source definition — declarative style
+    lines.push(`export default source({`);
+    lines.push(`  name: "${slug}",`);
+    lines.push(`  database: "${slug}",`);
+    lines.push(`  baseUrl: "${baseUrl}",`);
+    if (rateLimits) {
+        lines.push(`  rateLimits: {`);
+        if (rateLimits.requestsPerSecond)
+            lines.push(`    requestsPerSecond: ${rateLimits.requestsPerSecond},`);
+        if (rateLimits.requestsPerMinute)
+            lines.push(`    requestsPerMinute: ${rateLimits.requestsPerMinute},`);
+        lines.push(`  },`);
+    }
+    lines.push(`  tables: [`);
+    for (let i = 0; i < endpoints.length; i++) {
+        const ep = endpoints[i];
+        const table = tables[i];
+        const wrapper = detectListWrapper(ep.responseSchema);
+        lines.push(`    {`);
+        lines.push(`      name: "${table.name}",`);
+        lines.push(`      primaryKey: "${table.primaryKey}",`);
+        lines.push(`      endpoint: "${ep.path}",`);
+        // Pagination config
+        if (ep.pagination) {
+            lines.push(`      pagination: ${jsonLiteral(ep.pagination, 6)},`);
+        }
+        // Sync config
+        if (ep.sync?.supportsIncrementalSync) {
+            const syncConfig = {};
+            if (ep.sync.filterParam)
+                syncConfig.filterParam = ep.sync.filterParam;
+            if (ep.sync.filterFormat)
+                syncConfig.filterFormat = ep.sync.filterFormat;
+            if (ep.sync.updatedAtField)
+                syncConfig.updatedAtField = ep.sync.updatedAtField;
+            if (ep.sync.deletedAtField) {
+                syncConfig.deletedAtField = ep.sync.deletedAtField;
+                syncConfig.deletionStrategy = ep.sync.deletionStrategy ?? "soft-delete-field";
+            }
+            if (Object.keys(syncConfig).length > 0) {
+                lines.push(`      sync: ${jsonLiteral(syncConfig, 6)},`);
+            }
+        }
+        // Extract items — only if response wraps in a named field
+        if (wrapper) {
+            lines.push(`      extractItems: (body: any) => body.${wrapper} ?? [],`);
+        }
+        // Fetch fallback — the sync runtime uses endpoint + pagination config,
+        // but fetch is the escape hatch for custom logic
+        lines.push(`      async fetch(ctx) {`);
+        lines.push(`        return authedFetch(\`${baseUrl}${ep.path}\`, ctx);`);
+        lines.push(`      },`);
+        lines.push(`    },`);
+    }
+    lines.push(`  ],`);
+    lines.push(`});`);
+    lines.push(``);
+    return lines.join("\n");
+}
+function detectListWrapper(schema) {
+    if (!schema)
+        return null;
+    if (schema.type === "array")
+        return null;
+    const props = schema.properties;
+    if (!props)
+        return null;
+    for (const [key, value] of Object.entries(props)) {
+        if (value.type === "array")
+            return key;
+    }
+    return null;
+}
+function jsonLiteral(obj, indent) {
+    const pad = " ".repeat(indent);
+    const inner = " ".repeat(indent + 2);
+    const entries = Object.entries(obj)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${inner}${k}: ${JSON.stringify(v)}`);
+    return `{\n${entries.join(",\n")},\n${pad}}`;
+}

package/dist/src/connector-service/spec-storage.d.ts

@@ -0,0 +1,8 @@
+import type { ApiMetadata } from "./types.js";
+export declare function ensureSpecDir(workspaceRoot: string, slug: string): string;
+export declare function readMeta(workspaceRoot: string, slug: string): ApiMetadata | null;
+export declare function writeMeta(workspaceRoot: string, slug: string, meta: ApiMetadata): void;
+export declare function readSpec(workspaceRoot: string, slug: string): Record<string, unknown> | null;
+export declare function writeSpec(workspaceRoot: string, slug: string, spec: Record<string, unknown>): void;
+export declare function listSpecs(workspaceRoot: string): string[];
+export declare function slugify(name: string): string;