@facetlayer/prism-framework 0.4.0

package/.claude/settings.local.json

@@ -0,0 +1,20 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git mv:*)",
+      "Bash(prism-endpoint:*)",
+      "Bash(pnpm build:*)",
+      "Bash(pnpm install:*)",
+      "Bash(pnpm typecheck:*)",
+      "Skill(vibe-code-cleanup)",
+      "Bash(node build.mts:*)",
+      "Bash(pnpm test:*)",
+      "Bash(node dist/cli.js:*)",
+      "Bash(mkdir:*)",
+      "Bash(node /Users/andy/node-libraries/prism-framework-tools/dist/cli.js generate-api-clients:*)",
+      "Bash(pnpm local:install:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/CHANGELOG

@@ -0,0 +1,28 @@
+
+0.4.0
+ - Renamed from @facetlayer/prism-framework-tools to @facetlayer/prism-framework
+
+0.3.0
+ - Add config file support (.prism.qc) with parent directory search
+ - Fix API client type generation issues
+ - Add generate-api-clients-config documentation
+ - Add endpoint-tools and env-files documentation
+ - Safety checks for Zod schemas incompatible with OpenAPI
+ - Improve getting-started docs
+
+0.2.5
+ - Add list-docs and get-doc (with doc-files-helper)
+ 
+0.2.4
+ - Handle JSONish params in 'call' command
+ - generate-api-clients now uses --out param
+ 
+0.2.3
+ - Fix for list-endpoints
+
+0.2.1
+ - Add list-endpoints command
+ - Call endpoint - don't fail on response schema failure
+
+0.1.0
+ - initial version

package/CLAUDE.md

@@ -0,0 +1,44 @@
+# prism-framework
+
+Base library and CLI tools for the Prism app framework ecosystem.
+
+## Important Files and Directories
+
+### Source Code (`src/`)
+- `cli.ts` - Main CLI entry point, uses yargs for argument parsing
+- `call-command.ts` - Logic for calling endpoints, handles JSON parsing of arguments
+- `generate-api-clients.ts` - Generates TypeScript types from OpenAPI schema
+- `list-endpoints-command.ts` - Lists available endpoints from the API server
+- `loadEnv.ts` - Environment variable loading and validation
+- `getPorts.ts` - Port number utilities
+
+### Documentation (`docs/`)
+
+Markdown files for documentation.
+
+Run `doc-files list-docs` to understand the format.
+
+- `getting-started.md` - Setup guide for Prism Framework projects
+- `run-endpoint-tool.md` - Detailed CLI usage documentation
+- `env-files.md` - Environment configuration strategy
+
+### Tests (`test/`)
+- `call-command.test.ts` - Unit tests for argument parsing logic
+
+### Build Output
+- `dist/cli.js` - Compiled CLI executable (ES modules)
+
+## Build Commands
+
+```bash
+pnpm build      # Build the project
+pnpm test       # Run tests with Vitest
+pnpm typecheck  # TypeScript type checking
+```
+
+## Key Dependencies
+
+- `yargs` - CLI argument parsing
+- `dotenv` - Environment variable loading
+- `@facetlayer/doc-files-helper` - Documentation file management
+- `@facetlayer/prism-framework-api` - Prism API framework types

package/README.md

@@ -0,0 +1,47 @@
+# @facetlayer/prism-framework
+
+Base library and CLI tools for the Prism app framework.
+
+## Installation
+
+```bash
+npm install @facetlayer/prism-framework
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `prism list-endpoints` | List all available endpoints from the API server |
+| `prism call [METHOD] [PATH] [--args]` | Call an endpoint on the running API server |
+| `prism generate-api-clients --out <file>` | Generate TypeScript types from OpenAPI schema |
+| `prism list-docs` | List available documentation |
+| `prism get-doc <name>` | Display a specific documentation file |
+
+### Examples
+
+```bash
+# List all endpoints
+prism list-endpoints
+
+# Call endpoints
+prism call /api/users                              # GET request
+prism call POST /api/users --name "John"           # POST with body
+prism call POST /api/data --config '{"timeout":30}'  # JSON arguments
+
+# Generate TypeScript types
+prism generate-api-clients --out ./src/api-types.ts
+
+# Access documentation
+prism list-docs
+prism get-doc getting-started
+```
+
+## Documentation
+
+Once installed, the CLI has `prism list-docs` and `prism get-doc ...` commands to browse through the documentation files.
+
+Run `prism list-docs` to see available documentation topics, including:
+- `getting-started` - Setup guide for Prism Framework projects
+- `run-endpoint-tool` - Detailed CLI usage documentation
+- `env-files` - Environment configuration strategy

package/build.mts

@@ -0,0 +1,8 @@
+#! /usr/bin/env node
+
+import { runBuildTool } from '@facetlayer/build-config-nodejs';
+import { cpSync } from 'fs';
+
+await runBuildTool({
+  entryPoints: ['src/cli.ts'],
+});

package/dist/call-command.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+export interface CallEndpointLooseOptions {
+    baseUrl: string;
+    positionalArgs: string[];
+    namedArgs: Record<string, any>;
+    quiet?: boolean;
+}
+export declare function parseNamedArgs(namedArgs: Record<string, any>): Record<string, any>;
+/**
+ * Make an HTTP request to the local Prism API server
+ */
+export declare function callEndpoint(looseOptions: CallEndpointLooseOptions): Promise<any>;
+//# sourceMappingURL=call-command.d.ts.map

package/dist/call-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-command.d.ts","sourceRoot":"","sources":["../src/call-command.ts"],"names":[],"mappings":";AAIA,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAAC,CAAA;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAmCD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAMlF;AAkCD;;GAEG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,wBAAwB,gBA2DxE"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/loadEnv.ts
+import * as path from "path";
+import * as fs from "fs";
+import { config } from "dotenv";
+function loadEnv(cwd) {
+  const envPath = path.resolve(cwd, ".env");
+  if (!fs.existsSync(envPath)) {
+    throw new Error(
+      `No .env file found at ${envPath}
+
+Please create a .env file with PRISM_API_PORT defined.
+Example:
+  PRISM_API_PORT=3000`
+    );
+  }
+  const result = config({ path: envPath });
+  if (result.error) {
+    throw new Error(`Failed to load .env file: ${result.error.message}`);
+  }
+  const port = process.env.PRISM_API_PORT;
+  if (!port) {
+    throw new Error(
+      "PRISM_API_PORT is not defined in .env file\n\nPlease add PRISM_API_PORT to your .env file.\nExample:\n  PRISM_API_PORT=3000"
+    );
+  }
+  const portNumber = parseInt(port, 10);
+  if (isNaN(portNumber) || portNumber <= 0 || portNumber > 65535) {
+    throw new Error(
+      `Invalid PRISM_API_PORT value: ${port}
+
+Port must be a number between 1 and 65535`
+    );
+  }
+  return {
+    port: portNumber,
+    baseUrl: `http://localhost:${portNumber}`
+  };
+}
+
+// src/call-command.ts
+var EVERY_METHOD = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+function parseValue(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return value;
+      }
+    }
+  } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = parseValue(v);
+    }
+    return result;
+  }
+  return value;
+}
+function parseNamedArgs(namedArgs) {
+  const result = {};
+  for (const [key, value] of Object.entries(namedArgs)) {
+    result[key] = parseValue(value);
+  }
+  return result;
+}
+function parseOptions(looseOptions) {
+  const result = {
+    baseUrl: looseOptions.baseUrl,
+    method: "GET",
+    path: "/",
+    requestBody: parseNamedArgs(looseOptions.namedArgs)
+  };
+  for (const positional of looseOptions.positionalArgs) {
+    if (positional.startsWith("/")) {
+      result.path = positional;
+      continue;
+    }
+    if (EVERY_METHOD.has(positional.toUpperCase())) {
+      result.method = positional.toUpperCase();
+      continue;
+    }
+    if (positional.startsWith("http:") || positional.startsWith("https:")) {
+      result.baseUrl = positional;
+      continue;
+    }
+    throw new Error("unrecognized positional arg:" + positional);
+  }
+  return result;
+}
+async function callEndpoint(looseOptions) {
+  const options = parseOptions(looseOptions);
+  const url = `${options.baseUrl}${options.path}`;
+  const requestOptions = {
+    method: options.method,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  if (["POST", "PUT", "PATCH", "DELETE"].includes(options.method) && options.requestBody && Object.keys(options.requestBody).length > 0) {
+    requestOptions.body = JSON.stringify(options.requestBody);
+  }
+  try {
+    const response = await fetch(url, requestOptions);
+    if (!looseOptions.quiet)
+      console.log("Response status: " + response.status);
+    const responseText = await response.text();
+    if (!looseOptions.quiet)
+      console.log("Response: ", responseText);
+    let responseData;
+    try {
+      responseData = responseText ? JSON.parse(responseText) : null;
+    } catch {
+      responseData = responseText;
+    }
+    if (!response.ok) {
+      throw new Error(
+        `HTTP ${response.status} ${response.statusText}
+Response: ${JSON.stringify(responseData, null, 2)}`
+      );
+    }
+    return responseData;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED")) {
+        throw new Error(
+          `Failed to connect to ${url}
+
+Make sure your Prism API server is running.
+The server should be listening on the port specified in .env (PRISM_API_PORT)`
+        );
+      }
+    }
+    throw error;
+  }
+}
+
+// src/list-endpoints-command.ts
+async function listEndpoints(baseUrl) {
+  try {
+    const response = await callEndpoint({
+      baseUrl,
+      positionalArgs: ["GET", "/endpoints.json"],
+      namedArgs: {},
+      quiet: true
+    });
+    const endpoints = response.endpoints;
+    console.log("Available endpoints:\n");
+    if (Array.isArray(endpoints)) {
+      for (const endpoint of endpoints) {
+        const fullPath = `${endpoint.method} ${endpoint.path}`;
+        console.log(`  ${fullPath}`);
+        if (endpoint.description) {
+          console.log(`    ${endpoint.description}`);
+        }
+      }
+    } else {
+      console.log(JSON.stringify(endpoints, null, 2));
+    }
+  } catch (error) {
+    console.error("Could not list endpoints. The server may not support the /api/endpoints introspection endpoint.");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/generate-api-clients.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function convertToExpressPath(openApiPath) {
+  return openApiPath.replace(/\{([^}]+)\}/g, ":$1");
+}
+function schemaToTypeScript(schema, components, indent = 0) {
+  if (!schema) {
+    return "unknown";
+  }
+  const indentStr = "  ".repeat(indent);
+  if (schema.$ref) {
+    const refName = schema.$ref.split("/").pop();
+    return refName;
+  }
+  if (schema.type === "array") {
+    const itemType = schemaToTypeScript(schema.items, components, indent);
+    return `Array<${itemType}>`;
+  }
+  if (schema.type === "object" || schema.properties) {
+    const properties = schema.properties || {};
+    const required = schema.required || [];
+    if (Object.keys(properties).length === 0) {
+      return "Record<string, unknown>";
+    }
+    const props = Object.entries(properties).map(([key, value]) => {
+      const isRequired = required.includes(key);
+      const propType = schemaToTypeScript(value, components, indent + 1);
+      const optional = isRequired ? "" : "?";
+      return `${indentStr}  ${key}${optional}: ${propType};`;
+    });
+    return `{
+${props.join("\n")}
+${indentStr}}`;
+  }
+  switch (schema.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return "unknown";
+  }
+}
+async function generateApiClients(baseUrl, outputFiles) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (outputFiles.length === 0) {
+    throw new Error("At least one --out file must be specified");
+  }
+  try {
+    const response = await fetch(`${baseUrl}/openapi.json`);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch OpenAPI schema: ${response.status} ${response.statusText}
+Make sure the Prism API server is running at ${baseUrl}`
+      );
+    }
+    const schema = await response.json();
+    const lines = [];
+    const endpointMap = [];
+    if ((_a = schema.components) == null ? void 0 : _a.schemas) {
+      lines.push("// Component Schemas");
+      for (const [name, componentSchema] of Object.entries(schema.components.schemas)) {
+        const typeStr = schemaToTypeScript(componentSchema, schema.components.schemas);
+        lines.push(`export type ${name} = ${typeStr};
+`);
+      }
+      lines.push("");
+    }
+    lines.push("// Endpoint Types");
+    for (const [pathStr, pathItem] of Object.entries(schema.paths)) {
+      for (const [method, operation] of Object.entries(pathItem)) {
+        if (!operation.operationId) continue;
+        const typeName = capitalizeFirst(operation.operationId);
+        const expressPath = convertToExpressPath(pathStr);
+        endpointMap.push({ method: method.toLowerCase(), path: expressPath, operationId: operation.operationId });
+        const requestSchema = (_d = (_c = (_b = operation.requestBody) == null ? void 0 : _b.content) == null ? void 0 : _c["application/json"]) == null ? void 0 : _d.schema;
+        const requestType = requestSchema ? schemaToTypeScript(requestSchema, (_e = schema.components) == null ? void 0 : _e.schemas) : "void";
+        lines.push(`export type ${typeName}Request = ${requestType};
+`);
+        const responseSchema = (_i = (_h = (_g = (_f = operation.responses) == null ? void 0 : _f["200"]) == null ? void 0 : _g.content) == null ? void 0 : _h["application/json"]) == null ? void 0 : _i.schema;
+        const responseType = responseSchema ? schemaToTypeScript(responseSchema, (_j = schema.components) == null ? void 0 : _j.schemas) : "void";
+        lines.push(`export type ${typeName}Response = ${responseType};
+`);
+      }
+    }
+    lines.push("// Union type of all valid endpoints");
+    lines.push("export type ApiEndpoint =");
+    const endpointStrings = endpointMap.map(({ method, path: path2 }) => `  | "${method} ${path2}"`);
+    lines.push(endpointStrings.join("\n"));
+    lines.push(";\n");
+    lines.push("// Generic Request/Response Types by Endpoint");
+    lines.push("export type RequestType<T extends ApiEndpoint> =");
+    const requestCases = endpointMap.map(
+      ({ method, path: path2, operationId }) => `  T extends "${method} ${path2}" ? ${capitalizeFirst(operationId)}Request :`
+    );
+    lines.push(requestCases.join("\n"));
+    lines.push("  never;\n");
+    lines.push("export type ResponseType<T extends ApiEndpoint> =");
+    const responseCases = endpointMap.map(
+      ({ method, path: path2, operationId }) => `  T extends "${method} ${path2}" ? ${capitalizeFirst(operationId)}Response :`
+    );
+    lines.push(responseCases.join("\n"));
+    lines.push("  never;\n");
+    const output = lines.join("\n");
+    const header = `// Generated API client types
+// Auto-generated from OpenAPI schema - do not edit manually
+
+`;
+    const content = header + output;
+    for (const outputFile of outputFiles) {
+      const resolvedPath = resolve2(outputFile);
+      mkdirSync(dirname(resolvedPath), { recursive: true });
+      writeFileSync(resolvedPath, content, "utf-8");
+      console.log(`Written: ${resolvedPath}`);
+    }
+  } catch (error) {
+    console.error("\u274C Error generating client:", error);
+    throw error;
+  }
+}
+
+// src/config/loadConfig.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join, resolve as resolve3 } from "path";
+import { parseFile } from "@facetlayer/qc";
+var CONFIG_FILENAME = ".prism.qc";
+function loadConfig(cwd) {
+  let currentDir = resolve3(cwd);
+  while (true) {
+    const configPath = join(currentDir, CONFIG_FILENAME);
+    if (existsSync2(configPath)) {
+      const config2 = parseConfigFile(configPath);
+      return { config: config2, configDir: currentDir };
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function parseConfigFile(configPath) {
+  const content = readFileSync(configPath, "utf-8");
+  const queries = parseFile(content);
+  const generateApiClientTargets = [];
+  for (const query of queries) {
+    switch (query.command) {
+      case "generate-api-client": {
+        const outputFile = query.getStringValue("output-file");
+        generateApiClientTargets.push({ outputFile });
+        break;
+      }
+      default:
+        throw new Error(`Unknown command "${query.command}" in ${CONFIG_FILENAME}`);
+    }
+  }
+  return {
+    generateApiClientTargets
+  };
+}
+
+// src/cli.ts
+import { DocFilesHelper } from "@facetlayer/doc-files-helper";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname3(__filename);
+var __packageRoot = join2(__dirname, "..");
+var packageJson = JSON.parse(
+  readFileSync2(join2(__packageRoot, "package.json"), "utf-8")
+);
+var docFiles = new DocFilesHelper({
+  dirs: [join2(__packageRoot, "docs")],
+  files: [join2(__packageRoot, "README.md")]
+});
+async function main() {
+  const args = yargs(hideBin(process.argv)).command(
+    "list-endpoints",
+    "List all available endpoints",
+    {},
+    async () => {
+      try {
+        const cwd = process.cwd();
+        const config2 = loadEnv(cwd);
+        console.log(`Using API server at: ${config2.baseUrl}
+`);
+        await listEndpoints(config2.baseUrl);
+      } catch (error) {
+        if (error instanceof Error && error.stack) {
+          console.error(error.stack);
+        } else {
+          console.error("Error:", error instanceof Error ? error.message : String(error));
+        }
+        process.exit(1);
+      }
+    }
+  ).command(
+    "call <positionals...>",
+    "Call an endpoint. Named args starting with { } or [ ] are parsed as JSON.",
+    (yargs2) => {
+      return yargs2;
+    },
+    async (argv) => {
+      try {
+        const cwd = process.cwd();
+        const config2 = loadEnv(cwd);
+        const requestData = {};
+        for (const [key, value] of Object.entries(argv)) {
+          if (["positionals", "_", "$0"].includes(key)) {
+            continue;
+          }
+          requestData[key] = value;
+        }
+        try {
+          const result = await callEndpoint({
+            baseUrl: config2.baseUrl,
+            positionalArgs: argv.positionals,
+            namedArgs: requestData
+          });
+        } catch (error) {
+          console.error("Error calling endpoint:");
+          if (error instanceof Error) {
+            console.error(error.message);
+            if (error.stack) {
+              console.error("\nStack trace:");
+              console.error(error.stack);
+            }
+          } else {
+            console.error(String(error));
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.stack) {
+          console.error(error.stack);
+        } else {
+          console.error("Error:", error instanceof Error ? error.message : String(error));
+        }
+        process.exit(1);
+      }
+    }
+  ).command(
+    "generate-api-clients",
+    "Generate TypeScript API client types from OpenAPI schema",
+    (yargs2) => {
+      return yargs2.option("out", {
+        type: "string",
+        array: true,
+        describe: "Output file path(s) to write generated types to"
+      });
+    },
+    async (argv) => {
+      try {
+        const cwd = process.cwd();
+        const envConfig = loadEnv(cwd);
+        console.log(`Using API server at: ${envConfig.baseUrl}
+`);
+        let outputFiles = [];
+        if (argv.out && argv.out.length > 0) {
+          outputFiles = argv.out;
+        } else {
+          const result = loadConfig(cwd);
+          if (!result || result.config.generateApiClientTargets.length === 0) {
+            console.error("Error: No output files specified.");
+            console.error("Either use --out to specify output files, or configure targets in .prism.qc:");
+            console.error("  generate-api-client-target out=./src/api-types.ts");
+            process.exit(1);
+          }
+          outputFiles = result.config.generateApiClientTargets.map((t) => t.outputFile);
+        }
+        await generateApiClients(envConfig.baseUrl, outputFiles);
+      } catch (error) {
+        if (error instanceof Error && error.stack) {
+          console.error(error.stack);
+        } else {
+          console.error("Error:", error instanceof Error ? error.message : String(error));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  docFiles.yargsSetup(args);
+  args.strictCommands().demandCommand(1, "You must specify a command").help().alias("help", "h").version(packageJson.version).alias("version", "v").example([
+    ["$0 list-endpoints", "List all available endpoints"],
+    ["$0 call /api/users", "Call GET /api/users"],
+    ['$0 call POST /api/users --name "John" --email "john@example.com"', "call POST with data"],
+    [`$0 call POST /api/users --config '{"timeout":30}'`, "pass JSON objects as args"],
+    ["$0 generate-api-clients --out ./api-types.ts", "Generate API client types to a file"],
+    ["$0 generate-api-clients --out ./types.ts --out ./backup/types.ts", "Write to multiple files"]
+  ]).parse();
+}
+main();

package/dist/config/ConfigFile.d.ts

@@ -0,0 +1,7 @@
+export interface GenerateApiClientTarget {
+    outputFile: string;
+}
+export interface ConfigFile {
+    generateApiClientTargets: GenerateApiClientTarget[];
+}
+//# sourceMappingURL=ConfigFile.d.ts.map

package/dist/config/ConfigFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigFile.d.ts","sourceRoot":"","sources":["../../src/config/ConfigFile.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,wBAAwB,EAAE,uBAAuB,EAAE,CAAC;CACrD"}

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export type { ConfigFile, GenerateApiClientTarget } from './ConfigFile.ts';
+export type { LoadConfigResult } from './loadConfig.ts';
+export { loadConfig } from './loadConfig.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigFile } from './ConfigFile.ts';
+export interface LoadConfigResult {
+    config: ConfigFile;
+    configDir: string;
+}
+/**
+ * Find and load the .prism.qc config file.
+ * Searches in the provided directory and parent directories until found or root is reached.
+ */
+export declare function loadConfig(cwd: string): LoadConfigResult | null;
+//# sourceMappingURL=loadConfig.d.ts.map

package/dist/config/loadConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadConfig.d.ts","sourceRoot":"","sources":["../../src/config/loadConfig.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AAI3E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAkB/D"}