@m6d/cortex-cli 0.12.1 → 0.14.0

package/src/graph/validate.ts

@@ -1,78 +0,0 @@
-import type { ConceptDef, DomainDef, RuleDef } from "@cortex/contracts/graph";
-
-/**
- * Checks a domain for the two mistakes that survive the type system: a name used
- * twice, and an entity nothing points at.
- *
- * Cross-domain references are allowed — a concept, endpoint or service may be
- * defined in another module — so local membership is deliberately not enforced.
- */
-export function validateDomain(data: DomainDef) {
-    const referenced = collectReferences(data);
-
-    return [
-        ...duplicateNames(data.concepts, "concept"),
-        ...duplicateNames(data.endpoints, "endpoint"),
-        ...duplicateNames(data.services, "service"),
-        ...duplicateNames(data.rules, "rule"),
-        ...unreferenced(
-            data.concepts,
-            referenced.concepts,
-            (name) => `Concept "${name}" is never referenced by any endpoint or service`,
-        ),
-        ...unreferenced(
-            data.rules,
-            referenced.rules,
-            (name) => `Rule "${name}" is never referenced by any endpoint, service, or concept`,
-        ),
-    ];
-}
-
-function duplicateNames(items: { name: string }[] | undefined, kind: string) {
-    const seen = new Set<string>();
-
-    return (items ?? []).flatMap((item) => {
-        const duplicate = seen.has(item.name);
-        seen.add(item.name);
-
-        return duplicate ? [`Duplicate ${kind} name: "${item.name}"`] : [];
-    });
-}
-
-function unreferenced(
-    items: { name: string }[] | undefined,
-    referenced: Set<string>,
-    message: (name: string) => string,
-) {
-    return (items ?? [])
-        .filter((item) => !referenced.has(item.name))
-        .map((item) => message(item.name));
-}
-
-/** Gathers every name pointed at from anywhere in the domain. */
-function collectReferences(data: DomainDef) {
-    const concepts = new Set<string>();
-    const rules = new Set<string>();
-    const addRules = (governedBy: RuleDef[] | undefined) =>
-        governedBy?.forEach((rule) => rules.add(rule.name));
-    const addConcept = (concept: ConceptDef | undefined) => concept && concepts.add(concept.name);
-
-    for (const endpoint of data.endpoints ?? []) {
-        endpoint.queries?.forEach(addConcept);
-        endpoint.mutates?.forEach(addConcept);
-        endpoint.returns?.forEach((returned) => addConcept(returned.concept));
-        addRules(endpoint.governedBy);
-    }
-
-    for (const service of data.services ?? []) {
-        addConcept(service.belongsTo);
-        addRules(service.governedBy);
-    }
-
-    for (const concept of data.concepts ?? []) {
-        addConcept(concept.parentConcept);
-        addRules(concept.governedBy);
-    }
-
-    return { concepts, rules };
-}

package/src/scaffold/features.ts

@@ -1,190 +0,0 @@
-/**
- * The five features `cortex new` toggles. A feature is not a
- * config key: it is a bundle of a `cortex.config.ts` fragment, a block of env
- * keys, and sometimes a compose service. Fragments concatenate — there is no
- * merge engine — so every field here is plain text that gets joined.
- *
- * The grouping is what the server code already enforces. `vision` is inert
- * without `storage`, so attachments writes both; `seedGraph` throws unless it
- * has all of `neo4j`, `embedding` and `knowledge.domains`, so knowledge writes
- * all three plus the `src/domains/` tree the domainsDir convention assumes.
- */
-
-export type Feature = "attachments" | "redis" | "auth" | "knowledge" | "controlCenter";
-
-type Definition = {
-    /** One line, shown in `--help` and next to the option in the multi-select. */
-    hint: string;
-    /** Sits above the fragment in the generated config, commented either way. */
-    note: string;
-    /**
-     * The `cortex.config.ts` fragment, written at zero indentation: the assembler
-     * indents it into the object literal, or comments it out for a feature that
-     * was not selected. Conditional spread throughout, so an unfilled env var
-     * leaves the section *absent* rather than present-and-undefined.
-     */
-    config: string;
-    /** The `.env` block, identical in `.env` and `.env.example`. */
-    env: string;
-    /** The `docker-compose.yml` service, indented under `services:`. */
-    compose?: string;
-    /** The named volume that service mounts. */
-    volume?: string;
-    /** What `cd`-then-edit has to fill in before the project boots. */
-    secrets?: string;
-};
-
-export const FEATURES: Record<Feature, Definition> = {
-    attachments: {
-        hint: "MinIO storage for uploads, described by a vision model",
-        note: "Attachments: an S3-compatible bucket for uploads, plus an image-capable\nmodel that describes them. Vision does nothing without storage, which is\nwhy one toggle writes both.",
-        config: `...(process.env["CORTEX_MINIO_ENDPOINT"]
-    ? {
-          storage: {
-              endPoint: process.env["CORTEX_MINIO_ENDPOINT"],
-              port: Number(process.env["CORTEX_MINIO_PORT"] ?? {{port.minio}}),
-              useSSL: process.env["CORTEX_MINIO_USE_SSL"] === "true",
-              accessKey: process.env["CORTEX_MINIO_ACCESS_KEY"]!,
-              secretKey: process.env["CORTEX_MINIO_SECRET_KEY"]!,
-          },
-          vision: {
-              baseURL: process.env["CORTEX_VISION_URL"]!,
-              apiKey: process.env["CORTEX_VISION_KEY"]!,
-              modelName: process.env["CORTEX_VISION_MODEL"]!,
-          },
-      }
-    : {}),`,
-        env: `# --- Attachments -------------------------------------------------------------
-# S3-compatible object storage. docker-compose.yml runs MinIO on these values.
-CORTEX_MINIO_ENDPOINT=localhost
-CORTEX_MINIO_PORT={{port.minio}}
-CORTEX_MINIO_USE_SSL=false
-CORTEX_MINIO_ACCESS_KEY=minio
-CORTEX_MINIO_SECRET_KEY=minio-secret-key
-
-# An image-capable, OpenAI-compatible model. It describes uploaded images so the
-# agent can read them.
-CORTEX_VISION_URL=https://api.openai.com/v1
-CORTEX_VISION_KEY=your-vision-api-key
-CORTEX_VISION_MODEL=your-vision-model`,
-        compose: `    minio:
-        image: minio/minio:RELEASE.2025-04-22T22-12-26Z
-        command: server /data --console-address ":9001"
-        environment:
-            MINIO_ROOT_USER: minio
-            MINIO_ROOT_PASSWORD: minio-secret-key
-        ports:
-            - "{{port.minio}}:9000"
-            - "{{port.minioConsole}}:9001"
-        volumes:
-            - minio-data:/data`,
-        volume: "minio-data",
-        secrets: "CORTEX_VISION_*",
-    },
-
-    redis: {
-        hint: "resumable streams across restarts",
-        note: "Redis makes live runs survive a restart and reach every instance. Without\nit, an in-memory fallback covers this single process.",
-        config: `...(process.env["CORTEX_REDIS_URL"] ? { redis: { url: process.env["CORTEX_REDIS_URL"] } } : {}),`,
-        env: `# --- Redis -------------------------------------------------------------------
-# Resumable streams. docker-compose.yml runs one on this URL.
-CORTEX_REDIS_URL=redis://localhost:{{port.redis}}`,
-        compose: `    redis:
-        image: redis:7-alpine
-        ports:
-            - "{{port.redis}}:6379"`,
-    },
-
-    auth: {
-        hint: "JWT verification via JWKS",
-        note: "Bearer tokens verified against an identity provider's JWKS endpoint. The\nprovider is external, so there is no service for it.",
-        config: `...(process.env["CORTEX_AUTH_JWKS_URI"]
-    ? {
-          auth: {
-              kind: "jwks" as const,
-              jwksUri: process.env["CORTEX_AUTH_JWKS_URI"],
-              issuer: process.env["CORTEX_AUTH_ISSUER"]!,
-          },
-      }
-    : {}),`,
-        env: `# --- Auth --------------------------------------------------------------------
-# Your identity provider's JWKS endpoint, and the issuer it stamps on tokens.
-CORTEX_AUTH_JWKS_URI=https://your-idp.example.com/.well-known/jwks.json
-CORTEX_AUTH_ISSUER=https://your-idp.example.com/`,
-        secrets: "CORTEX_AUTH_*",
-    },
-
-    knowledge: {
-        hint: "Swagger + domains + Neo4j",
-        note: "The knowledge graph, which is three keys rather than one: Neo4j stores it,\nthe embedding endpoint makes it searchable, and the domain definitions under\nsrc/domains/ are what `cortex graph seed` loads into it.",
-        config: `...(process.env["CORTEX_NEO4J_URL"]
-    ? {
-          neo4j: {
-              url: process.env["CORTEX_NEO4J_URL"],
-              user: process.env["CORTEX_NEO4J_USER"]!,
-              password: process.env["CORTEX_NEO4J_PASSWORD"]!,
-          },
-          embedding: {
-              baseURL: process.env["CORTEX_EMBEDDING_URL"]!,
-              apiKey: process.env["CORTEX_EMBEDDING_KEY"]!,
-              modelName: process.env["CORTEX_EMBEDDING_MODEL"]!,
-              dimension: Number(process.env["CORTEX_EMBEDDING_DIMENSION"] ?? 1024),
-          },
-          knowledge: {
-              // swagger: { url: "https://api.example.com/swagger/v1/swagger.json" },
-              // Import the domains you write under src/domains/ and list them here.
-              domains: {},
-          },
-      }
-    : {}),`,
-        env: `# --- Knowledge graph ---------------------------------------------------------
-# Neo4j. docker-compose.yml runs one with exactly these credentials. The URL is
-# the HTTP endpoint, not the bolt one: the server talks to Neo4j over its HTTP
-# transaction API.
-CORTEX_NEO4J_URL=http://localhost:{{port.neo4j}}
-CORTEX_NEO4J_USER=neo4j
-CORTEX_NEO4J_PASSWORD=cortex-dev-password
-
-# An OpenAI-compatible embeddings endpoint — external, like the main model.
-# CORTEX_EMBEDDING_DIMENSION has to match what the model returns.
-CORTEX_EMBEDDING_URL=https://api.openai.com/v1
-CORTEX_EMBEDDING_KEY=your-embedding-api-key
-CORTEX_EMBEDDING_MODEL=your-embedding-model
-CORTEX_EMBEDDING_DIMENSION=1024`,
-        compose: `    neo4j:
-        image: neo4j:5-community
-        environment:
-            NEO4J_AUTH: neo4j/cortex-dev-password
-            # Neo4j Browser, served on the HTTP port, opens bolt at whatever this
-            # advertises. Without it the browser would offer 7687, which is the
-            # container's port and not the one published below.
-            NEO4J_server_bolt_advertised__address: ":{{port.neo4jBolt}}"
-        ports:
-            - "{{port.neo4j}}:7474"
-            - "{{port.neo4jBolt}}:7687"
-        volumes:
-            - neo4j-data:/data`,
-        volume: "neo4j-data",
-        secrets: "CORTEX_EMBEDDING_*",
-    },
-
-    controlCenter: {
-        hint: "serve agents published on a Control Center instance",
-        note: "The Control Center you point this server at. External, so no service here.",
-        config: `...(process.env["CORTEX_CONTROL_CENTER_URL"]
-    ? {
-          controlCenter: {
-              url: process.env["CORTEX_CONTROL_CENTER_URL"],
-              apiKey: process.env["CORTEX_CONTROL_CENTER_API_KEY"]!,
-          },
-      }
-    : {}),`,
-        env: `# --- Control Center ----------------------------------------------------------
-CORTEX_CONTROL_CENTER_URL=http://localhost:20000
-CORTEX_CONTROL_CENTER_API_KEY=cc_live_...`,
-        secrets: "CORTEX_CONTROL_CENTER_API_KEY",
-    },
-};
-
-/** Catalogue order, which is the order every generated file lists them in. */
-export const FEATURE_NAMES = Object.keys(FEATURES) as Feature[];

package/src/scaffold/templates/domains-README.md.txt

@@ -1,16 +0,0 @@
-# Domains
-
-Domain definitions live here, one directory each, and are what `cortex graph seed` loads into Neo4j.
-
-```
-src/domains/
-  leaves/
-    index.ts                            defineDomain({ concepts, endpoints, rules, services })
-    concepts/leave.concept.ts
-    endpoints/listLeaves.endpoint.ts
-    services/leaveRequests.service.ts
-```
-
-Export each domain from its `index.ts`, then list it under `knowledge.domains` in
-`cortex.config.ts`. `cortex swagger sync` fills in the params, body, and response of every
-`.endpoint.ts` from your Swagger spec.

package/src/scaffold/templates/index.ts.txt

@@ -1,18 +0,0 @@
-import { createCortex } from "@m6d/cortex-server";
-import config from "./cortex.config";
-
-const cortex = createCortex(config);
-
-const server = await cortex.serve();
-
-// Your own routes hang off the same Hono app the agent runtime serves from:
-// server.app.get("/hello", function (c) {
-//     return c.text("hello");
-// });
-
-export default {
-    port: server.port,
-    fetch: server.fetch,
-    websocket: server.websocket,
-    idleTimeout: 0,
-};

package/src/swagger/extract-endpoints.ts

@@ -1,269 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isRecord } from "@cortex/contracts/json";
-import type { Endpoint, HttpMethod, Obj } from "./types";
-import { dedupe, deref, obj, pickContent, schemaType, toProp, toProps } from "./openapi-schema";
-import { parseResponse } from "./parse-response";
-import { withGeneratedBlock } from "./generated-block";
-
-type ExtractEndpointsOptions = {
-    swaggerUrls: string[];
-    domainsDir: string;
-    write: boolean;
-};
-
-const METHODS = ["GET", "POST", "PUT", "DELETE"] as const satisfies readonly HttpMethod[];
-
-/**
- * ASP.NET conventions the extractor normalizes away so an `.endpoint.ts` path
- * matches the spec whichever way the API was mounted: routes are keyed without
- * the `/api` prefix (either side may carry it), and `JsonNode`-typed query
- * parameters, which Swagger expands into `Root.Options`, `Root.Parent` and
- * `Root.Root` dot-paths, collapse back to one object parameter.
- */
-const API_PREFIX = /^\/api(?=\/|$)/i;
-const JSON_NODE_MEMBER = /^(Options|Parent|Root)\b/;
-
-function toCamelCase(s: string) {
-    return s
-        .split(".")
-        .map((seg) => seg.replace(/^[A-Z]/, (c) => c.toLowerCase()))
-        .join(".");
-}
-
-/** `Root` for a dotted parameter like `Root.Options`; undefined for a plain one. */
-function dottedRoot(name: string) {
-    const dot = name.indexOf(".");
-    return dot < 0 ? undefined : name.slice(0, dot);
-}
-
-function normalizePath(raw: string) {
-    let p = raw.startsWith("/") ? raw : `/${raw}`;
-    p = p.replace(/\{([^}:?]+)(?::[^}]+)?\??\}/g, "{$1}").replace(API_PREFIX, "") || "/";
-    return p.length > 1 ? p.replace(/\/+$/, "") : p;
-}
-
-function walkFiles(dir: string) {
-    if (!fs.existsSync(dir)) return [];
-    const out: string[] = [];
-    function walk(d: string) {
-        for (const e of fs.readdirSync(d, { withFileTypes: true })) {
-            const p = path.join(d, e.name);
-            if (e.isDirectory()) walk(p);
-            else out.push(p);
-        }
-    }
-    walk(dir);
-    return out;
-}
-
-/**
- * The `method` and `path` an endpoint file declares, read the way the server's
- * own file walk reads them.
- */
-export function declaredRoute(source: string) {
-    return {
-        method: source.match(/^\s*method:\s*(['"])([^'"]+)\1/m)?.[2],
-        path: source.match(/^\s*path:\s*(['"])([^'"]+)\1/m)?.[2],
-    };
-}
-
-function endpointFiles(root: string) {
-    const out = new Map<string, string>();
-    for (const filePath of walkFiles(root).filter((p) => p.endsWith(".endpoint.ts"))) {
-        const { method, path: route } = declaredRoute(fs.readFileSync(filePath, "utf8"));
-        if (method && route) out.set(`${method}:${normalizePath(route)}`, filePath);
-    }
-    return out;
-}
-
-/**
- * Path and query parameters, path-level first, with each `JsonNode` parameter
- * collapsed back to one object.
- */
-function extractParams(doc: unknown, pathItem: Obj, operation: Obj) {
-    const rawParams = [
-        ...(Array.isArray(pathItem.parameters) ? (pathItem.parameters as unknown[]) : []),
-        ...(Array.isArray(operation.parameters) ? (operation.parameters as unknown[]) : []),
-    ]
-        .map((param) => deref(doc, param))
-        .filter(
-            (param): param is Obj & { name: string; in: string } =>
-                typeof param.name === "string" &&
-                typeof param.in === "string" &&
-                ["path", "query"].includes(param.in),
-        );
-
-    const jsonNodeRoots = new Set<string>();
-    for (const { name } of rawParams) {
-        const root = dottedRoot(name);
-        if (root !== undefined && JSON_NODE_MEMBER.test(name.slice(root.length + 1))) {
-            jsonNodeRoots.add(root);
-        }
-    }
-
-    return dedupe(
-        rawParams
-            .filter((param) => {
-                const root = dottedRoot(param.name);
-                return root === undefined || !jsonNodeRoots.has(root);
-            })
-            .map((param) =>
-                toProp(
-                    doc,
-                    toCamelCase(param.name),
-                    param.schema,
-                    param.in === "path" || param.required === true,
-                ),
-            )
-            .concat(
-                [...jsonNodeRoots].map((root) => ({
-                    name: toCamelCase(root),
-                    required: false,
-                    type: "object",
-                })),
-            ),
-    );
-}
-
-/** An object body contributes its own fields; anything else is one `items` or `body` field. */
-function extractBody(doc: unknown, operation: Obj) {
-    const requestBody = deref(doc, operation.requestBody);
-    const content = pickContent(requestBody.content);
-    if (!content) return [];
-    const schema = deref(doc, content.schema);
-    const type = schemaType(schema);
-    if (type === "object") return toProps(doc, schema);
-    const name = type === "array" ? "items" : "body";
-    return [toProp(doc, name, schema, requestBody.required === true)];
-}
-
-function extractEndpoint(
-    doc: unknown,
-    route: string,
-    method: HttpMethod,
-    pathItem: Obj,
-    operation: Obj,
-) {
-    const normalizedPath = normalizePath(route);
-    return {
-        key: `${method}:${normalizedPath}`,
-        method,
-        path: normalizedPath,
-        params: extractParams(doc, pathItem, operation),
-        body: extractBody(doc, operation),
-        ...parseResponse(doc, operation.responses),
-    } satisfies Endpoint;
-}
-
-function parseSwaggerEndpoints(swagger: unknown) {
-    const out = new Map<string, Endpoint>();
-    const doc = obj(swagger);
-    for (const [route, pathItemIn] of Object.entries(obj(doc.paths))) {
-        const pathItem = obj(pathItemIn);
-        for (const method of METHODS) {
-            const operation = pathItem[method.toLowerCase()];
-            if (!isRecord(operation)) continue;
-            const endpoint = extractEndpoint(doc, route, method, pathItem, operation);
-            out.set(endpoint.key, endpoint);
-        }
-    }
-    return out;
-}
-
-function formatGeneratedFiles(filePaths: string[]) {
-    if (!filePaths.length) return;
-    try {
-        // Absolute paths: a relative domainsDir yields paths relative to the
-        // process cwd, which a prettier run elsewhere would resolve wrongly.
-        Bun.spawnSync(["bunx", "prettier", "--write", ...filePaths.map((p) => path.resolve(p))], {
-            stdio: ["ignore", "ignore", "ignore"],
-        });
-    } catch {
-        // Formatting is cosmetic; a missing prettier must not fail the run.
-    }
-}
-
-async function fetchJson(url: string) {
-    const response = await fetch(url, {
-        headers: { Accept: "application/json" },
-    });
-    if (!response.ok) {
-        throw new Error(`Swagger request failed (${response.status})`);
-    }
-    return response.json();
-}
-
-function resolveEndpoint(key: string, extracted: Map<string, Endpoint>) {
-    const [method, route] = key.split(":");
-    if (!method || !route) return undefined;
-    return (
-        extracted.get(key) ??
-        extracted.get(`${method}:${normalizePath(`/api${route}`)}`) ??
-        (route.startsWith("/api/")
-            ? extracted.get(`${method}:${normalizePath(route.slice(4))}`)
-            : undefined)
-    );
-}
-
-// The post-write prettier pass reformats generated blocks, so an exact string
-// compare would report freshly synced files as drift forever. Compare modulo
-// the axes prettier varies: quote style, whitespace, and trailing commas.
-function sameModuloFormatting(a: string, b: string) {
-    function norm(s: string) {
-        return s
-            .replace(/['"]/g, '"')
-            .replace(/\s+/g, "")
-            .replace(/,(?=[}\])])/g, "");
-    }
-    return norm(a) === norm(b);
-}
-
-export async function extractEndpoints(options: ExtractEndpointsOptions) {
-    const { swaggerUrls, domainsDir, write } = options;
-
-    // Merge every document first: a file missing from one swagger doc may be
-    // matched by another. Last write wins on duplicate keys, so per-agent docs
-    // deliberately override the server-level one (`swaggerUrls` lists it first).
-    const extracted = new Map<string, Endpoint>();
-    for (const swaggerUrl of swaggerUrls) {
-        for (const [key, endpoint] of parseSwaggerEndpoints(await fetchJson(swaggerUrl))) {
-            extracted.set(key, endpoint);
-        }
-    }
-
-    let matched = 0;
-    const missing: string[] = [];
-    const drift: string[] = [];
-    const updated: string[] = [];
-    const updatedFiles: string[] = [];
-
-    for (const [key, filePath] of endpointFiles(domainsDir).entries()) {
-        const relativePath = path.relative(domainsDir, filePath);
-        const endpoint = resolveEndpoint(key, extracted);
-        if (!endpoint) {
-            missing.push(relativePath);
-            continue;
-        }
-
-        const current = fs.readFileSync(filePath, "utf8");
-        const next = withGeneratedBlock(current, endpoint);
-        if (next === null || next === current || sameModuloFormatting(next, current)) {
-            matched++;
-            continue;
-        }
-
-        if (!write) {
-            drift.push(relativePath);
-            continue;
-        }
-
-        fs.writeFileSync(filePath, next);
-        updatedFiles.push(filePath);
-        updated.push(relativePath);
-    }
-
-    if (write) formatGeneratedFiles(updatedFiles);
-
-    return { matched, missing, drift, updated };
-}

package/src/swagger/generated-block.ts

@@ -1,74 +0,0 @@
-/**
- * Splicing the generated block into an endpoint definition the developer also edits
- * by hand. The markers are the contract: everything between them belongs to the
- * generator, everything outside is the developer's.
- */
-import type { Endpoint, Prop } from "./types";
-
-const AUTO_START = "// @auto-generated-start";
-const AUTO_END = "// @auto-generated-end";
-
-function serializeProps(props: Prop[], depth: number) {
-    return props
-        .map((p) => {
-            const indent = "    ".repeat(depth);
-            const childIndent = "    ".repeat(depth + 1);
-            const typeLiteral = p.type.includes("'")
-                ? `"${p.type.replace(/"/g, '\\"')}"`
-                : `'${p.type}'`;
-
-            const parts = [`name: '${p.name}'`, `required: ${p.required}`, `type: ${typeLiteral}`];
-            if (p.isArray) parts.push("isArray: true");
-            if (p.properties?.length)
-                parts.push(
-                    `properties: [\n${serializeProps(p.properties, depth + 1)}\n${childIndent}]`,
-                );
-
-            return `${indent}    { ${parts.join(", ")} },`;
-        })
-        .join("\n");
-}
-
-function blockFor(endpoint: Endpoint) {
-    return `    autoGenerated: {
-        params: [
-${serializeProps(endpoint.params, 2)}
-        ] as const,
-        body: [
-${serializeProps(endpoint.body, 2)}
-        ] as const,
-        response: [
-${serializeProps(endpoint.response, 2)}
-        ] as const,
-        successStatus: ${endpoint.successStatus},
-        errorStatuses: [${endpoint.errorStatuses.join(", ")}],
-        responseKind: '${endpoint.responseKind}',
-    } as const,`;
-}
-
-/**
- * Replaces the marked region when it exists, otherwise inserts one just inside the
- * closing `});`. Returns null when there is nowhere to put it, which means the file
- * is not shaped like an endpoint definition.
- */
-export function withGeneratedBlock(current: string, endpoint: Endpoint) {
-    const start = current.indexOf(AUTO_START);
-    const end = current.indexOf(AUTO_END);
-
-    if (start >= 0 && end > start) {
-        return (
-            current.slice(0, start + AUTO_START.length) +
-            `\n${blockFor(endpoint)}\n    ` +
-            current.slice(end)
-        );
-    }
-
-    const closingIndex = current.lastIndexOf("});");
-    if (closingIndex < 0) return null;
-
-    return (
-        current.slice(0, closingIndex) +
-        `\n  ${AUTO_START}\n${blockFor(endpoint)}\n    ${AUTO_END}\n});` +
-        current.slice(closingIndex + 3)
-    );
-}