@theatrical/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1303 @@
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/utils/output.ts
+import chalk from "chalk";
+function success(message) {
+  return chalk.green(`\u2713 ${message}`);
+}
+function error(message) {
+  return chalk.red(`\u2717 ${message}`);
+}
+function info(message) {
+  return chalk.blue(`\u2139 ${message}`);
+}
+function dim(message) {
+  return chalk.dim(message);
+}
+function highlight(message) {
+  return chalk.cyan(message);
+}
+function printBanner(version) {
+  const width = 32;
+  const top = `\u250C${"\u2500".repeat(width)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(width)}\u2518`;
+  const pad = (text, len) => text + " ".repeat(Math.max(0, len - stripAnsi(text).length));
+  console.log(chalk.dim(top));
+  console.log(
+    chalk.dim("\u2502") + "  " + pad(chalk.bold(`\u{1F3AC} Theatrical CLI v${version}`), width - 2) + chalk.dim("\u2502")
+  );
+  console.log(
+    chalk.dim("\u2502") + "  " + pad(chalk.dim("Cinema Platform Dev Tools"), width - 2) + chalk.dim("\u2502")
+  );
+  console.log(chalk.dim(bottom));
+}
+function keyValue(key, value) {
+  return `${chalk.bold(key)}: ${chalk.cyan(value)}`;
+}
+function heading(text) {
+  return `
+${chalk.bold.white(text)}
+${chalk.dim("\u2500".repeat(text.length))}`;
+}
+function stripAnsi(str) {
+  return str.replace(
+    // eslint-disable-next-line no-control-regex
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    ""
+  );
+}
+
+// src/utils/config.ts
+import { cosmiconfig } from "cosmiconfig";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+var DEFAULTS = {
+  apiUrl: "https://api.vista.co/ocapi/v1",
+  outputFormat: "pretty",
+  verbose: false,
+  color: true
+};
+var ENV_PREFIX = "THEATRICAL_";
+var CONFIG_DIR = ".config/theatrical";
+var CONFIG_FILE = "config.json";
+async function resolveConfig(overrides = {}) {
+  const fileConfig = await loadFileConfig();
+  const envConfig = loadEnvConfig();
+  return {
+    ...DEFAULTS,
+    ...fileConfig,
+    ...envConfig,
+    ...stripUndefined(overrides)
+  };
+}
+async function loadFileConfig() {
+  const explorer = cosmiconfig("theatrical", {
+    searchPlaces: [
+      ".theatricalrc",
+      ".theatricalrc.json",
+      ".theatricalrc.yaml",
+      ".theatricalrc.yml",
+      "theatrical.config.js",
+      "theatrical.config.cjs",
+      "theatrical.config.mjs",
+      "package.json"
+    ]
+  });
+  try {
+    const result = await explorer.search();
+    if (result && !result.isEmpty) {
+      return result.config;
+    }
+  } catch {
+  }
+  return loadUserConfig();
+}
+function loadUserConfig() {
+  const configPath = path.join(os.homedir(), CONFIG_DIR, CONFIG_FILE);
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function loadEnvConfig() {
+  const config = {};
+  const apiUrl = process.env[`${ENV_PREFIX}API_URL`];
+  if (apiUrl) config.apiUrl = apiUrl;
+  const apiKey = process.env[`${ENV_PREFIX}API_KEY`];
+  if (apiKey) config.apiKey = apiKey;
+  const siteId = process.env[`${ENV_PREFIX}DEFAULT_SITE_ID`];
+  if (siteId) config.defaultSiteId = siteId;
+  const format = process.env[`${ENV_PREFIX}OUTPUT_FORMAT`];
+  if (format === "json" || format === "table" || format === "pretty") {
+    config.outputFormat = format;
+  }
+  const verbose = process.env[`${ENV_PREFIX}VERBOSE`];
+  if (verbose === "1" || verbose === "true") config.verbose = true;
+  const color = process.env[`${ENV_PREFIX}NO_COLOR`];
+  if (color === "1" || color === "true") config.color = false;
+  return config;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/commands/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { Command } from "commander";
+function createInitCommand() {
+  const cmd = new Command("init");
+  cmd.argument("[project-name]", "Name of the project to create").description("Scaffold a new cinema platform project").option("-t, --template <template>", "Project template (default, fullstack, worker)", "default").option("--api-key <key>", "Vista API key to include in .env").option("--no-install", "Skip automatic dependency installation").option("-d, --directory <dir>", "Target directory (defaults to project name)").action(async (projectName, opts) => {
+    const resolvedConfig = cmd.parent?.opts().resolvedConfig;
+    const options = resolveInitOptions(projectName, opts, resolvedConfig);
+    await executeInit(options);
+  });
+  return cmd;
+}
+function resolveInitOptions(projectName, flags, config) {
+  const name = projectName ?? "my-cinema-app";
+  const template = validateTemplate(flags.template);
+  return {
+    projectName: name,
+    template,
+    apiKey: flags.apiKey ?? config?.apiKey,
+    skipInstall: flags.install === false,
+    directory: flags.directory ?? name
+  };
+}
+function validateTemplate(template) {
+  const valid = ["default", "fullstack", "worker"];
+  if (valid.includes(template)) {
+    return template;
+  }
+  console.warn(error(`Unknown template "${template}". Using "default".`));
+  return "default";
+}
+async function executeInit(options) {
+  const targetDir = path2.resolve(process.cwd(), options.directory);
+  console.log(heading("Theatrical \u2014 Project Scaffolding"));
+  console.log();
+  console.log(keyValue("Project", options.projectName));
+  console.log(keyValue("Template", options.template));
+  console.log(keyValue("Directory", targetDir));
+  console.log();
+  if (fs2.existsSync(targetDir)) {
+    const entries = fs2.readdirSync(targetDir);
+    if (entries.length > 0) {
+      console.log(error(`Directory "${options.directory}" already exists and is not empty.`));
+      console.log(dim("  Use a different project name or remove the existing directory."));
+      process.exit(1);
+    }
+  }
+  fs2.mkdirSync(targetDir, { recursive: true });
+  fs2.mkdirSync(path2.join(targetDir, "src"), { recursive: true });
+  const template = getTemplate(options);
+  let filesWritten = 0;
+  for (const file of template.files) {
+    const filePath = path2.join(targetDir, file.path);
+    const dir = path2.dirname(filePath);
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(filePath, file.content, "utf-8");
+    console.log(dim(`  created ${file.path}`));
+    filesWritten++;
+  }
+  console.log();
+  console.log(success(`Scaffolded ${filesWritten} files`));
+  if (!options.skipInstall) {
+    console.log();
+    console.log(info("To install dependencies:"));
+    console.log(dim(`  cd ${options.directory}`));
+    console.log(dim("  npm install"));
+  }
+  console.log();
+  console.log(highlight("Next steps:"));
+  console.log(dim(`  cd ${options.directory}`));
+  if (options.apiKey) {
+    console.log(dim("  # API key is configured in .env"));
+  } else {
+    console.log(dim("  # Add your Vista API key to .env"));
+  }
+  console.log(dim("  npx theatrical inspect sessions list --site <your-site-id>"));
+  console.log();
+}
+function getTemplate(options) {
+  const templates = {
+    default: () => defaultTemplate(options),
+    fullstack: () => fullstackTemplate(options),
+    worker: () => workerTemplate(options)
+  };
+  return templates[options.template]();
+}
+function defaultTemplate(options) {
+  return {
+    name: "default",
+    description: "Minimal TypeScript project with Theatrical SDK",
+    files: [
+      {
+        path: "package.json",
+        content: JSON.stringify(
+          {
+            name: options.projectName,
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: {
+              build: "tsc",
+              dev: "tsx watch src/index.ts",
+              start: "node dist/index.js"
+            },
+            dependencies: {
+              "@theatrical/sdk": "^0.1.0"
+            },
+            devDependencies: {
+              typescript: "^5.4.0",
+              tsx: "^4.0.0",
+              "@types/node": "^20.0.0"
+            }
+          },
+          null,
+          2
+        ) + "\n"
+      },
+      {
+        path: "tsconfig.json",
+        content: JSON.stringify(
+          {
+            compilerOptions: {
+              target: "ES2022",
+              module: "ESNext",
+              moduleResolution: "bundler",
+              strict: true,
+              esModuleInterop: true,
+              outDir: "dist",
+              rootDir: "src",
+              declaration: true
+            },
+            include: ["src/**/*"]
+          },
+          null,
+          2
+        ) + "\n"
+      },
+      {
+        path: ".env",
+        content: [
+          "# Theatrical SDK Configuration",
+          `THEATRICAL_API_KEY=${options.apiKey ?? "your-api-key-here"}`,
+          "THEATRICAL_API_URL=https://api.vista.co/ocapi/v1",
+          ""
+        ].join("\n")
+      },
+      {
+        path: ".env.example",
+        content: [
+          "# Theatrical SDK Configuration",
+          "THEATRICAL_API_KEY=your-api-key-here",
+          "THEATRICAL_API_URL=https://api.vista.co/ocapi/v1",
+          ""
+        ].join("\n")
+      },
+      {
+        path: ".gitignore",
+        content: ["node_modules", "dist", ".env", "coverage", "*.log", ""].join("\n")
+      },
+      {
+        path: "src/index.ts",
+        content: [
+          "import { TheatricalClient } from '@theatrical/sdk';",
+          "",
+          "// Initialize the SDK client",
+          "const client = TheatricalClient.create({",
+          "  apiKey: process.env.THEATRICAL_API_KEY ?? '',",
+          "  baseUrl: process.env.THEATRICAL_API_URL ?? 'https://api.vista.co/ocapi/v1',",
+          "});",
+          "",
+          "async function main() {",
+          "  // List films currently showing",
+          "  const films = await client.films.list({ nowShowing: true });",
+          "  console.log('Now Showing:', films);",
+          "",
+          "  // Find nearby cinema sites",
+          "  // const sites = await client.sites.nearby(-41.2924, 174.7787, 10);",
+          "  // console.log('Nearby Sites:', sites);",
+          "}",
+          "",
+          "main().catch(console.error);",
+          ""
+        ].join("\n")
+      }
+    ]
+  };
+}
+function fullstackTemplate(options) {
+  const base = defaultTemplate(options);
+  return {
+    name: "fullstack",
+    description: "Express API + React frontend with Theatrical SDK",
+    files: [
+      ...base.files,
+      {
+        path: "src/server.ts",
+        content: [
+          "import express from 'express';",
+          "import { TheatricalClient } from '@theatrical/sdk';",
+          "",
+          "const app = express();",
+          "const port = process.env.PORT ?? 3000;",
+          "",
+          "const client = TheatricalClient.create({",
+          "  apiKey: process.env.THEATRICAL_API_KEY ?? '',",
+          "});",
+          "",
+          "app.get('/api/films', async (_req, res) => {",
+          "  const films = await client.films.list({ nowShowing: true });",
+          "  res.json(films);",
+          "});",
+          "",
+          "app.get('/api/sessions/:siteId', async (req, res) => {",
+          "  const sessions = await client.sessions.list({",
+          "    siteId: req.params.siteId,",
+          "  });",
+          "  res.json(sessions);",
+          "});",
+          "",
+          "app.listen(port, () => {",
+          "  console.log(`\u{1F3AC} Cinema API running on http://localhost:${port}`);",
+          "});",
+          ""
+        ].join("\n")
+      }
+    ]
+  };
+}
+function workerTemplate(options) {
+  const base = defaultTemplate(options);
+  return {
+    name: "worker",
+    description: "Background worker for cinema event processing",
+    files: [
+      ...base.files,
+      {
+        path: "src/worker.ts",
+        content: [
+          "import { TheatricalClient } from '@theatrical/sdk';",
+          "",
+          "const client = TheatricalClient.create({",
+          "  apiKey: process.env.THEATRICAL_API_KEY ?? '',",
+          "});",
+          "",
+          "/** Poll interval in milliseconds */",
+          "const POLL_INTERVAL = 30_000;",
+          "",
+          "async function processEvents() {",
+          "  console.log('\u{1F3AC} Cinema event worker starting...');",
+          "",
+          "  // Example: poll for session changes",
+          "  setInterval(async () => {",
+          "    try {",
+          "      // Check for updated sessions, availability changes, etc.",
+          "      console.log(`[${new Date().toISOString()}] Polling for updates...`);",
+          "    } catch (err) {",
+          "      console.error('Poll error:', err);",
+          "    }",
+          "  }, POLL_INTERVAL);",
+          "}",
+          "",
+          "processEvents().catch(console.error);",
+          ""
+        ].join("\n")
+      }
+    ]
+  };
+}
+
+// src/commands/codegen.ts
+import fs3 from "fs";
+import path3 from "path";
+import { Command as Command2 } from "commander";
+
+// src/codegen/parser.ts
+var OpenAPIParser = class {
+  /**
+   * Parse an OpenAPI 3.x specification object.
+   * Supports JSON and YAML (if pre-parsed to objects).
+   *
+   * @param spec - Raw OpenAPI specification object
+   * @returns Parsed specification ready for code generation
+   * @throws Error if spec is invalid or missing required fields
+   */
+  parse(spec) {
+    if (!spec || typeof spec !== "object") {
+      throw new Error("OpenAPI spec must be a valid object");
+    }
+    if (!spec.info) {
+      throw new Error("OpenAPI spec missing required field: info");
+    }
+    if (!spec.info.title) {
+      throw new Error("OpenAPI spec missing required field: info.title");
+    }
+    if (!spec.info.version) {
+      throw new Error("OpenAPI spec missing required field: info.version");
+    }
+    const paths = this.parsePaths(spec.paths || {});
+    const schemas = this.parseSchemas(spec.components?.schemas || {});
+    return {
+      title: spec.info.title,
+      description: spec.info.description,
+      version: spec.info.version,
+      paths,
+      schemas
+    };
+  }
+  /**
+   * Parse OpenAPI paths (endpoints).
+   */
+  parsePaths(pathsObj) {
+    return Object.entries(pathsObj).map(([path4, pathItem]) => ({
+      path: path4,
+      operations: this.parseOperations(pathItem)
+    }));
+  }
+  /**
+   * Parse operations (HTTP methods) for a path item.
+   */
+  parseOperations(pathItem) {
+    const methods = ["get", "post", "put", "delete", "patch", "head", "options"];
+    const operations = [];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (operation && typeof operation === "object") {
+        operations.push({
+          method: method.toUpperCase(),
+          operationId: operation.operationId || `${method}_unknown`,
+          summary: operation.summary,
+          description: operation.description,
+          requestBody: operation.requestBody ? this.parseRequestBody(operation.requestBody) : void 0,
+          responses: this.parseResponses(operation.responses || {}),
+          parameters: this.parseParameters(operation.parameters || [])
+        });
+      }
+    }
+    return operations;
+  }
+  /**
+   * Parse request body definition.
+   */
+  parseRequestBody(requestBody) {
+    if (!requestBody.content) {
+      throw new Error("Request body missing content");
+    }
+    const jsonContent = requestBody.content["application/json"];
+    if (!jsonContent) {
+      throw new Error("Request body missing application/json content type");
+    }
+    return this.parseSchemaObject(jsonContent.schema, "RequestBody");
+  }
+  /**
+   * Parse response definitions.
+   */
+  parseResponses(responsesObj) {
+    const responses = {};
+    for (const [status, response] of Object.entries(responsesObj)) {
+      if (response && typeof response === "object" && response.content) {
+        const jsonContent = response.content["application/json"];
+        if (jsonContent) {
+          responses[status] = this.parseSchemaObject(jsonContent.schema, `Response${status}`);
+        }
+      }
+    }
+    return responses;
+  }
+  /**
+   * Parse parameters (query, path, header, cookie).
+   */
+  parseParameters(parameters) {
+    return parameters.map((param) => ({
+      name: param.name,
+      in: param.in,
+      required: param.required === true,
+      type: this.schemaToTypeString(param.schema),
+      description: param.description
+    }));
+  }
+  /**
+   * Parse a schema object (from definitions or inline).
+   */
+  parseSchemaObject(schema, defaultName) {
+    if (!schema) {
+      return { name: defaultName, type: "object" };
+    }
+    if (schema.$ref) {
+      const refName = schema.$ref.split("/").pop() || defaultName;
+      return {
+        name: refName,
+        type: "object",
+        isReference: true
+      };
+    }
+    if (Array.isArray(schema.enum)) {
+      return {
+        name: defaultName,
+        type: "enum",
+        description: schema.description,
+        enumValues: schema.enum.map(String)
+      };
+    }
+    if (schema.type === "array") {
+      return {
+        name: defaultName,
+        type: "array",
+        description: schema.description,
+        items: schema.items ? this.parseSchemaObject(schema.items, `${defaultName}Item`) : void 0
+      };
+    }
+    if (schema.type === "object" || schema.properties) {
+      const properties = {};
+      const required = schema.required || [];
+      if (schema.properties) {
+        for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+          properties[propName] = {
+            name: propName,
+            required: required.includes(propName),
+            schema: this.parseSchemaObject(propSchema, propName),
+            description: propSchema?.description
+          };
+        }
+      }
+      return {
+        name: defaultName,
+        type: "object",
+        description: schema.description,
+        properties,
+        required
+      };
+    }
+    return {
+      name: defaultName,
+      type: schema.type || "object",
+      description: schema.description
+    };
+  }
+  /**
+   * Parse schema definitions (components/schemas).
+   */
+  parseSchemas(schemasObj) {
+    return Object.entries(schemasObj).map(([name, schema]) => {
+      const parsed = this.parseSchemaObject(schema, name);
+      parsed.name = name;
+      return parsed;
+    });
+  }
+  /**
+   * Convert a schema to a TypeScript type string (for parameters).
+   */
+  schemaToTypeString(schema) {
+    if (!schema) return "unknown";
+    if (schema.type === "string") {
+      if (Array.isArray(schema.enum)) {
+        return schema.enum.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    }
+    if (schema.type === "number" || schema.type === "integer") {
+      return "number";
+    }
+    if (schema.type === "boolean") {
+      return "boolean";
+    }
+    if (schema.type === "array") {
+      return `${this.schemaToTypeString(schema.items)}[]`;
+    }
+    return "unknown";
+  }
+};
+
+// src/codegen/generator.ts
+var CodeGenerator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Generate TypeScript and Zod code from a parsed OpenAPI spec.
+   */
+  generate(spec) {
+    const types = this.generateTypes(spec);
+    const zod = this.config.includeZod ? this.generateZod(spec) : void 0;
+    const barrel = this.generateBarrel(spec);
+    return { types, zod, barrel };
+  }
+  /**
+   * Generate TypeScript type definitions.
+   */
+  generateTypes(spec) {
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * Generated from ${spec.title} v${spec.version}`);
+    if (spec.description) {
+      lines.push(` * ${spec.description}`);
+    }
+    lines.push(" */");
+    lines.push("");
+    for (const schema of spec.schemas) {
+      if (this.config.includeJSDoc) {
+        lines.push("/**");
+        lines.push(` * ${schema.description || schema.name}`);
+        lines.push(" */");
+      }
+      lines.push(...this.generateSchemaType(schema));
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate a single schema as a TypeScript type.
+   */
+  generateSchemaType(schema) {
+    const lines = [];
+    if (schema.type === "enum") {
+      lines.push(`export type ${schema.name} = ${schema.enumValues?.map((v) => `'${v}'`).join(" | ")};`);
+      return lines;
+    }
+    if (schema.type === "object" && schema.properties) {
+      lines.push(`export interface ${schema.name} {`);
+      for (const [propName, prop] of Object.entries(schema.properties)) {
+        if (this.config.includeJSDoc && prop.description) {
+          lines.push(`  /** ${prop.description} */`);
+        }
+        const optional = prop.required ? "" : "?";
+        const typeStr = this.schemaPropertyToTypeString(prop.schema);
+        lines.push(`  ${propName}${optional}: ${typeStr};`);
+      }
+      lines.push("}");
+      return lines;
+    }
+    if (schema.type === "array" && schema.items) {
+      const itemType = this.schemaToTypeString(schema.items);
+      lines.push(`export type ${schema.name} = ${itemType}[];`);
+      return lines;
+    }
+    lines.push(`export type ${schema.name} = unknown;`);
+    return lines;
+  }
+  /**
+   * Generate Zod schemas.
+   */
+  generateZod(spec) {
+    const lines = [];
+    lines.push('import { z } from "zod";');
+    lines.push("");
+    for (const schema of spec.schemas) {
+      lines.push(`export const ${this.toSchemeName(schema.name)} = z.`);
+      lines.push(...this.generateZodSchema(schema, ""));
+      lines.push(";");
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate a Zod schema definition.
+   */
+  generateZodSchema(schema, indent) {
+    const lines = [];
+    if (schema.type === "enum" && schema.enumValues) {
+      const values = schema.enumValues.map((v) => `'${v}'`).join(", ");
+      lines.push(`enum([${values}])`);
+      return lines;
+    }
+    if (schema.type === "object" && schema.properties) {
+      lines.push("object({");
+      for (const [propName, prop] of Object.entries(schema.properties)) {
+        const propZod = this.generateZodSchemaForProperty(prop);
+        const optional = prop.required ? "" : ".optional()";
+        lines.push(`  ${propName}: ${propZod}${optional},`);
+      }
+      lines.push("})");
+      return lines;
+    }
+    if (schema.type === "array" && schema.items) {
+      const itemZod = this.schemaToZodString(schema.items);
+      lines.push(`array(${itemZod})`);
+      return lines;
+    }
+    lines.push("unknown()");
+    return lines;
+  }
+  /**
+   * Generate Zod for a property within an object.
+   */
+  generateZodSchemaForProperty(prop) {
+    return this.schemaToZodString(prop.schema);
+  }
+  /**
+   * Convert a schema to a Zod schema string.
+   */
+  schemaToZodString(schema) {
+    switch (schema.type) {
+      case "string":
+        return "z.string()";
+      case "number":
+        return "z.number()";
+      case "boolean":
+        return "z.boolean()";
+      case "enum":
+        if (schema.enumValues) {
+          const values = schema.enumValues.map((v) => `'${v}'`).join(", ");
+          return `z.enum([${values}])`;
+        }
+        return "z.string()";
+      case "array":
+        if (schema.items) {
+          const itemZod = this.schemaToZodString(schema.items);
+          return `z.array(${itemZod})`;
+        }
+        return "z.array(z.unknown())";
+      case "object":
+        if (schema.properties) {
+          const entries = Object.entries(schema.properties).map(([name, prop]) => {
+            const propZod = this.schemaToZodString(prop.schema);
+            const optional = prop.required ? "" : ".optional()";
+            return `${name}: ${propZod}${optional}`;
+          }).join(", ");
+          return `z.object({ ${entries} })`;
+        }
+        return "z.object({})";
+      default:
+        return "z.unknown()";
+    }
+  }
+  /**
+   * Convert a schema to a TypeScript type string.
+   */
+  schemaToTypeString(schema) {
+    switch (schema.type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "enum":
+        return schema.enumValues?.map((v) => `'${v}'`).join(" | ") || "string";
+      case "array":
+        return schema.items ? `${this.schemaToTypeString(schema.items)}[]` : "unknown[]";
+      case "object":
+        if (schema.isReference) {
+          return schema.name;
+        }
+        if (schema.properties) {
+          const entries = Object.entries(schema.properties).map(([name, prop]) => {
+            const optional = prop.required ? "" : "?";
+            const typeStr = this.schemaToTypeString(prop.schema);
+            return `${name}${optional}: ${typeStr}`;
+          }).join("; ");
+          return `{ ${entries} }`;
+        }
+        return "object";
+      default:
+        return "unknown";
+    }
+  }
+  /**
+   * Convert a schema property to a TypeScript type string.
+   */
+  schemaPropertyToTypeString(schema) {
+    return this.schemaToTypeString(schema);
+  }
+  /**
+   * Generate a barrel export file.
+   */
+  generateBarrel(spec) {
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * Generated barrel export for ${spec.title}`);
+    lines.push(" */");
+    lines.push("");
+    for (const schema of spec.schemas) {
+      lines.push(`export type { ${schema.name} } from './${this.toFileName(schema.name)}';`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Convert a schema name to a file name.
+   */
+  toFileName(name) {
+    return name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  }
+  /**
+   * Convert a schema name to a Zod schema name.
+   */
+  toSchemeName(name) {
+    return `${name.charAt(0).toLowerCase()}${name.slice(1)}Schema`;
+  }
+};
+
+// src/commands/codegen.ts
+function createCodegenCommand() {
+  return new Command2("codegen").description("Generate TypeScript types from OpenAPI specifications").argument("<spec>", "Path or URL to OpenAPI spec (JSON or YAML)").option("--output <dir>", "Output directory", "./src/generated").option("--zod", "Include Zod schemas", false).option("--jsdoc", "Include JSDoc comments", true).option("--package-name <name>", "Package name for imports", void 0).action(async (spec, options) => {
+    try {
+      await runCodegen(spec, options);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      console.error(`Error: ${message}`);
+      process.exit(1);
+    }
+  });
+}
+async function runCodegen(specInput, options) {
+  let specContent;
+  if (specInput.startsWith("http://") || specInput.startsWith("https://")) {
+    specContent = await fetchSpec(specInput);
+  } else {
+    specContent = fs3.readFileSync(specInput, "utf-8");
+  }
+  let specObj;
+  try {
+    specObj = JSON.parse(specContent);
+  } catch {
+    throw new Error("Failed to parse spec \u2014 ensure it is valid JSON (YAML not yet supported)");
+  }
+  const parser = new OpenAPIParser();
+  const parsedSpec = parser.parse(specObj);
+  const config = {
+    outputDir: options.output,
+    includeZod: options.zod === true,
+    includeJSDoc: options.jsdoc !== false,
+    packageName: options.packageName
+  };
+  if (!fs3.existsSync(config.outputDir)) {
+    fs3.mkdirSync(config.outputDir, { recursive: true });
+  }
+  const generator = new CodeGenerator(config);
+  const generated = generator.generate(parsedSpec);
+  const typesPath = path3.join(config.outputDir, "index.ts");
+  fs3.writeFileSync(typesPath, generated.types, "utf-8");
+  console.log(`\u2713 Generated types: ${typesPath}`);
+  if (generated.zod && config.includeZod) {
+    const zodPath = path3.join(config.outputDir, "schemas.ts");
+    fs3.writeFileSync(zodPath, generated.zod, "utf-8");
+    console.log(`\u2713 Generated Zod schemas: ${zodPath}`);
+  }
+  if (generated.barrel) {
+    const barrelPath = path3.join(config.outputDir, "index.ts");
+    fs3.appendFileSync(barrelPath, "\n\n" + generated.barrel, "utf-8");
+  }
+  console.log(`
+Codegen complete. Generated ${config.includeZod ? "types and schemas" : "types"} in ${config.outputDir}`);
+}
+async function fetchSpec(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    return await response.text();
+  } catch (error2) {
+    throw new Error(`Failed to fetch spec from ${url}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+}
+
+// src/commands/inspect.ts
+import fs4 from "fs";
+import { Command as Command3 } from "commander";
+
+// src/inspect/routes.ts
+var ROUTES = {
+  sessions: {
+    list: {
+      method: "GET",
+      path: "/ocapi/v1/sessions",
+      description: "List sessions with optional site and date filters"
+    },
+    get: {
+      method: "GET",
+      path: "/ocapi/v1/sessions/:id",
+      description: "Get a specific session by ID"
+    },
+    search: {
+      method: "GET",
+      path: "/ocapi/v1/sessions",
+      description: "Search sessions by film, site, or date"
+    }
+  },
+  sites: {
+    list: {
+      method: "GET",
+      path: "/ocapi/v1/sites",
+      description: "List all cinema sites"
+    },
+    get: {
+      method: "GET",
+      path: "/ocapi/v1/sites/:id",
+      description: "Get detailed site information"
+    },
+    search: {
+      method: "GET",
+      path: "/ocapi/v1/sites",
+      description: "Search sites by name or location"
+    }
+  },
+  films: {
+    list: {
+      method: "GET",
+      path: "/ocapi/v1/films",
+      description: "List films \u2014 now showing and coming soon"
+    },
+    get: {
+      method: "GET",
+      path: "/ocapi/v1/films/:id",
+      description: "Get full film details with cast and crew"
+    },
+    search: {
+      method: "GET",
+      path: "/ocapi/v1/films",
+      description: "Search films by title, genre, or rating"
+    }
+  },
+  orders: {
+    list: {
+      method: "GET",
+      path: "/ocapi/v1/orders",
+      description: "List orders for a member or site"
+    },
+    get: {
+      method: "GET",
+      path: "/ocapi/v1/orders/:id",
+      description: "Get order details with line items"
+    },
+    search: {
+      method: "GET",
+      path: "/ocapi/v1/orders",
+      description: "Search orders by date range or status"
+    }
+  },
+  loyalty: {
+    list: {
+      method: "GET",
+      path: "/ocapi/v1/loyalty/members",
+      description: "List loyalty members"
+    },
+    get: {
+      method: "GET",
+      path: "/ocapi/v1/loyalty/members/:id",
+      description: "Get loyalty member profile and points balance"
+    },
+    search: {
+      method: "GET",
+      path: "/ocapi/v1/loyalty/members",
+      description: "Search loyalty members by name or email"
+    }
+  }
+};
+var VALID_RESOURCES = Object.keys(ROUTES);
+var VALID_ACTIONS = ["list", "get", "search"];
+function resolveRoute(resource, action) {
+  const resourceRoutes = ROUTES[resource];
+  if (!resourceRoutes) return null;
+  const route = resourceRoutes[action];
+  return route ?? null;
+}
+function buildRequestUrl(route, baseUrl, options, id) {
+  let path4 = route.path;
+  if (path4.includes(":id")) {
+    if (!id) {
+      throw new Error(
+        `Route ${route.method} ${route.path} requires an id argument`
+      );
+    }
+    path4 = path4.replace(":id", encodeURIComponent(id));
+  }
+  const url = new URL(path4, baseUrl);
+  if (options.site) {
+    url.searchParams.set("siteId", options.site);
+  }
+  if (options.date) {
+    url.searchParams.set("date", options.date);
+  }
+  if (options.query) {
+    url.searchParams.set("q", options.query);
+  }
+  if (options.limit) {
+    url.searchParams.set("limit", String(options.limit));
+  }
+  return url.toString();
+}
+
+// src/inspect/formatter.ts
+import chalk2 from "chalk";
+function formatResponse(data, options = {}) {
+  const parts = [];
+  if (options.method || options.url || options.statusCode) {
+    parts.push(formatResponseHeader(options));
+    parts.push("");
+  }
+  parts.push(highlightJSON(data, options));
+  if (options.timing) {
+    const durationMs = options.timing.endMs - options.timing.startMs;
+    parts.push("");
+    parts.push(chalk2.dim(`\u23F1  ${formatDuration(durationMs)}`));
+  }
+  return parts.join("\n");
+}
+function highlightJSON(data, options = {}) {
+  const indent = options.indent ?? 2;
+  const useColor = options.color !== false;
+  const maxStr = options.maxStringLength ?? 120;
+  if (!useColor) {
+    return JSON.stringify(data, null, indent);
+  }
+  return colorize(data, 0, indent, maxStr);
+}
+function formatResponseHeader(options) {
+  const parts = [];
+  if (options.method) {
+    parts.push(chalk2.bold.white(options.method.toUpperCase()));
+  }
+  if (options.url) {
+    parts.push(chalk2.cyan.underline(options.url));
+  }
+  if (options.statusCode) {
+    const statusStr = String(options.statusCode);
+    if (options.statusCode >= 200 && options.statusCode < 300) {
+      parts.push(chalk2.green(`${statusStr} OK`));
+    } else if (options.statusCode >= 400 && options.statusCode < 500) {
+      parts.push(chalk2.yellow(`${statusStr} Client Error`));
+    } else if (options.statusCode >= 500) {
+      parts.push(chalk2.red(`${statusStr} Server Error`));
+    } else {
+      parts.push(chalk2.dim(statusStr));
+    }
+  }
+  if (options.timing) {
+    const durationMs = options.timing.endMs - options.timing.startMs;
+    parts.push(chalk2.dim(`(${formatDuration(durationMs)})`));
+  }
+  return parts.join(" ");
+}
+function colorize(value, depth, indent, maxStr) {
+  const pad = " ".repeat(depth * indent);
+  const innerPad = " ".repeat((depth + 1) * indent);
+  if (value === null) {
+    return chalk2.dim("null");
+  }
+  if (value === void 0) {
+    return chalk2.dim("undefined");
+  }
+  if (typeof value === "string") {
+    const truncated = value.length > maxStr ? value.slice(0, maxStr) : value;
+    const display = value.length > maxStr ? JSON.stringify(truncated).slice(0, -1) + chalk2.dim('\u2026"') : JSON.stringify(truncated);
+    return chalk2.green(display);
+  }
+  if (typeof value === "number") {
+    return chalk2.cyan(String(value));
+  }
+  if (typeof value === "boolean") {
+    return chalk2.yellow(String(value));
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return chalk2.dim("[]");
+    }
+    const items = value.map(
+      (item) => `${innerPad}${colorize(item, depth + 1, indent, maxStr)}`
+    );
+    return [
+      chalk2.dim("["),
+      items.join(chalk2.dim(",") + "\n"),
+      `${pad}${chalk2.dim("]")}`
+    ].join("\n");
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return chalk2.dim("{}");
+    }
+    const lines = entries.map(([key, val]) => {
+      const colorizedKey = chalk2.bold.white(`"${key}"`);
+      const colorizedVal = colorize(val, depth + 1, indent, maxStr);
+      return `${innerPad}${colorizedKey}${chalk2.dim(":")} ${colorizedVal}`;
+    });
+    return [
+      chalk2.dim("{"),
+      lines.join(chalk2.dim(",") + "\n"),
+      `${pad}${chalk2.dim("}")}`
+    ].join("\n");
+  }
+  return String(value);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatCount(data) {
+  if (Array.isArray(data)) {
+    return chalk2.dim(`(${data.length} item${data.length === 1 ? "" : "s"})`);
+  }
+  if (typeof data === "object" && data !== null) {
+    const count = Object.keys(data).length;
+    return chalk2.dim(`(${count} field${count === 1 ? "" : "s"})`);
+  }
+  return "";
+}
+function formatTable(rows, columns) {
+  if (rows.length === 0) {
+    return chalk2.dim("(no results)");
+  }
+  const cols = columns ?? Object.keys(rows[0]);
+  const widths = cols.map((col) => {
+    const values = rows.map((row) => String(row[col] ?? ""));
+    return Math.max(col.length, ...values.map((v) => v.length));
+  });
+  const header = cols.map((col, i) => chalk2.bold(col.padEnd(widths[i]))).join("  ");
+  const separator = widths.map((w) => chalk2.dim("\u2500".repeat(w))).join("  ");
+  const bodyLines = rows.map(
+    (row) => cols.map((col, i) => String(row[col] ?? "").padEnd(widths[i])).join("  ")
+  );
+  return [header, separator, ...bodyLines].join("\n");
+}
+
+// src/commands/inspect.ts
+var DEFAULT_API_URL = "https://api.vista.co";
+function createInspectCommand() {
+  return new Command3("inspect").description("Interactive API explorer with formatted output").argument("<resource>", `API resource: ${VALID_RESOURCES.join(", ")}`).argument("<action>", `Action: ${VALID_ACTIONS.join(", ")}`).argument("[id]", 'Resource ID (required for "get" action)').option("--site <id>", "Cinema site ID for scoping requests").option("--date <date>", "Date filter (YYYY-MM-DD)").option("-q, --query <text>", "Search query string").option("-o, --output <file>", "Save response to file (JSON)").option("-n, --limit <count>", "Maximum results to return", parseInt).option("--table", "Display results as a table (for list actions)").action(async function(resource, action, id, cmdOptions, command) {
+    try {
+      await runInspect(resource, action, id, cmdOptions, command);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      console.error(error(message));
+      process.exit(1);
+    }
+  });
+}
+async function runInspect(resource, action, id, cmdOptions, command) {
+  if (!VALID_RESOURCES.includes(resource)) {
+    throw new Error(
+      `Unknown resource "${resource}". Valid resources: ${VALID_RESOURCES.join(", ")}`
+    );
+  }
+  if (!VALID_ACTIONS.includes(action)) {
+    throw new Error(
+      `Unknown action "${action}". Valid actions: ${VALID_ACTIONS.join(", ")}`
+    );
+  }
+  if (action === "get" && !id) {
+    throw new Error(
+      `The "get" action requires a resource ID. Usage: theatrical inspect ${resource} get <id>`
+    );
+  }
+  const route = resolveRoute(resource, action);
+  if (!route) {
+    throw new Error(`No route defined for ${resource} ${action}`);
+  }
+  const options = {
+    site: cmdOptions.site,
+    date: cmdOptions.date,
+    query: cmdOptions.query,
+    output: cmdOptions.output,
+    limit: cmdOptions.limit,
+    noColor: cmdOptions.noColor
+  };
+  const parentOpts = command.parent?.opts() ?? {};
+  const apiUrl = parentOpts.apiUrl ?? DEFAULT_API_URL;
+  const apiKey = parentOpts.apiKey;
+  const url = buildRequestUrl(route, apiUrl, options, id);
+  console.log(heading(`${route.method} ${resource}/${action}`));
+  console.log(dim(route.description));
+  console.log(keyValue("URL", url));
+  console.log("");
+  const result = await executeRequest(url, route.method, apiKey);
+  if (cmdOptions.table && Array.isArray(result.data)) {
+    console.log(formatCount(result.data));
+    console.log(formatTable(result.data));
+  } else {
+    const formatted = formatResponse(result.data, {
+      color: !options.noColor,
+      method: result.method,
+      url: result.url,
+      statusCode: result.status,
+      timing: { startMs: 0, endMs: result.durationMs }
+    });
+    console.log(formatted);
+  }
+  if (options.output) {
+    const json = JSON.stringify(result.data, null, 2);
+    fs4.writeFileSync(options.output, json, "utf-8");
+    console.log("");
+    console.log(success(`Response saved to ${options.output}`));
+  }
+}
+async function executeRequest(url, method, apiKey) {
+  const headers = {
+    "Accept": "application/json",
+    "User-Agent": "theatrical-cli/0.1.0"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const startMs = performance.now();
+  const response = await fetch(url, {
+    method,
+    headers
+  });
+  const endMs = performance.now();
+  const durationMs = endMs - startMs;
+  let data;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    data = await response.json();
+  } else {
+    const text = await response.text();
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = { _raw: text };
+    }
+  }
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  return {
+    status: response.status,
+    headers: responseHeaders,
+    data,
+    durationMs,
+    url,
+    method
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function createProgram() {
+  const program = new Command4();
+  program.name("theatrical").description("Developer toolkit for cinema platform APIs").version(VERSION, "-v, --version", "Display the CLI version").option("--no-color", "Disable colored output").option("--verbose", "Enable verbose logging").option(
+    "--format <format>",
+    "Output format: json, table, or pretty",
+    "pretty"
+  ).option("--config <path>", "Path to config file").option("--api-url <url>", "Override the API base URL").option("--api-key <key>", "API authentication key").hook("preAction", async (thisCommand) => {
+    const opts = thisCommand.opts();
+    const config = await resolveConfig({
+      verbose: opts.verbose ?? void 0,
+      color: opts.color ?? void 0,
+      outputFormat: opts.format ?? void 0,
+      apiUrl: opts.apiUrl ?? void 0,
+      apiKey: opts.apiKey ?? void 0
+    });
+    thisCommand.setOptionValue("resolvedConfig", config);
+    if (config.verbose) {
+      printBanner(VERSION);
+    }
+  });
+  program.addCommand(createInitCommand());
+  program.addCommand(createCodegenCommand());
+  program.addCommand(createInspectCommand());
+  return program;
+}
+async function run(argv = process.argv) {
+  const program = createProgram();
+  await program.parseAsync(argv);
+}
+export {
+  createProgram,
+  run
+};