@orcalang/orca-lang 0.1.0

package/src/config/loader.ts

@@ -0,0 +1,122 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import yaml from 'js-yaml';
+import { OrcaConfig, DEFAULT_CONFIG } from './types.js';
+
+let envLoaded = false;
+
+function loadEnvFile(): void {
+  if (envLoaded) return;
+  envLoaded = true;
+
+  // Load from project root .env
+  const cwd = process.cwd();
+  const envPath = join(cwd, '.env');
+  if (existsSync(envPath)) {
+    const content = readFileSync(envPath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const eqIndex = trimmed.indexOf('=');
+      if (eqIndex === -1) continue;
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+      // Remove surrounding quotes
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+      if (key && !process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+function interpolateEnvVars(obj: unknown): unknown {
+  if (typeof obj === 'string') {
+    // Replace ${VAR_NAME} with environment variable value
+    return obj.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+      const value = process.env[varName];
+      if (value === undefined) {
+        throw new Error(`Environment variable ${varName} is not set`);
+      }
+      return value;
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(interpolateEnvVars);
+  }
+  if (obj !== null && typeof obj === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateEnvVars(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+function deepMerge(target: OrcaConfig, source: Partial<OrcaConfig>): OrcaConfig {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== undefined && value !== null) {
+      (result as Record<string, unknown>)[key] = value;
+    }
+  }
+  return result;
+}
+
+export function loadConfig(configPath?: string): OrcaConfig {
+  loadEnvFile();
+  const configs: Partial<OrcaConfig>[] = [];
+
+  // 1. Global default
+  const globalConfigPath = join(homedir(), '.orca', 'default.yaml');
+  if (existsSync(globalConfigPath)) {
+    const content = readFileSync(globalConfigPath, 'utf-8');
+    const parsed = yaml.load(content) as Record<string, unknown>;
+    configs.push(interpolateEnvVars(parsed) as Partial<OrcaConfig>);
+  }
+
+  // 2. Project config (current working directory or specified path)
+  const projectConfigPath = configPath || findProjectConfig();
+  if (projectConfigPath && existsSync(projectConfigPath)) {
+    const content = readFileSync(projectConfigPath, 'utf-8');
+    const parsed = yaml.load(content) as Record<string, unknown>;
+    configs.push(interpolateEnvVars(parsed) as Partial<OrcaConfig>);
+  }
+
+  // 3. Merge all configs in order (later ones override earlier)
+  let result = DEFAULT_CONFIG;
+  for (const config of configs) {
+    result = deepMerge(result, config);
+  }
+
+  return result;
+}
+
+function findProjectConfig(): string | undefined {
+  const cwd = process.cwd();
+  const possiblePaths = [
+    join(cwd, 'orca.yaml'),
+    join(cwd, '.orca.yaml'),
+    join(cwd, 'orca', 'orca.yaml'),
+  ];
+
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+
+  return undefined;
+}
+
+export function resolveConfigOverrides(
+  config: OrcaConfig,
+  overrides: Partial<OrcaConfig>
+): OrcaConfig {
+  return deepMerge(config, overrides);
+}

package/src/config/types.ts

@@ -0,0 +1,21 @@
+export type LLMProviderType = 'anthropic' | 'openai' | 'ollama' | 'grok';
+
+export type CodeGeneratorType = 'typescript' | 'python' | 'rust' | 'go';
+
+export interface OrcaConfig {
+  provider: LLMProviderType;
+  model: string;
+  api_key?: string;
+  base_url?: string;
+  code_generator: CodeGeneratorType;
+  max_tokens?: number;
+  temperature?: number;
+}
+
+export const DEFAULT_CONFIG: OrcaConfig = {
+  provider: 'anthropic',
+  model: 'claude-sonnet-4-6',
+  code_generator: 'typescript',
+  max_tokens: 4096,
+  temperature: 0.7,
+};

package/src/generators/index.ts

@@ -0,0 +1,6 @@
+export type { CodeGenerator } from './registry.js';
+export { registerCodeGenerator, getCodeGenerator, listCodeGenerators } from './registry.js';
+export { TypeScriptCodeGenerator } from './typescript.js';
+
+// Import to register generators
+import './typescript.js';

package/src/generators/registry.ts

@@ -0,0 +1,27 @@
+import { ActionScaffold } from '../skills.js';
+import { MachineDef } from '../parser/ast.js';
+import { CodeGeneratorType } from '../config/types.js';
+
+export interface CodeGenerator {
+  name(): string;
+  generate(actions: ActionScaffold[], machine: MachineDef): string;
+  generateAction(action: ActionScaffold, machine: MachineDef): string;
+}
+
+const generators = new Map<CodeGeneratorType, () => CodeGenerator>();
+
+export function registerCodeGenerator(type: CodeGeneratorType, factory: () => CodeGenerator): void {
+  generators.set(type, factory);
+}
+
+export function getCodeGenerator(type: CodeGeneratorType): CodeGenerator {
+  const factory = generators.get(type);
+  if (!factory) {
+    throw new Error(`No code generator registered for type: ${type}`);
+  }
+  return factory();
+}
+
+export function listCodeGenerators(): CodeGeneratorType[] {
+  return Array.from(generators.keys());
+}

package/src/generators/typescript.ts

@@ -0,0 +1,67 @@
+import { CodeGenerator } from './registry.js';
+import { ActionScaffold } from '../skills.js';
+import { MachineDef } from '../parser/ast.js';
+
+export class TypeScriptCodeGenerator implements CodeGenerator {
+  name(): string {
+    return 'typescript';
+  }
+
+  generate(actions: ActionScaffold[], machine: MachineDef): string {
+    const lines: string[] = [
+      `// Generated by Orca`,
+      `// Machine: ${machine.name}`,
+      '',
+      `export interface Context {`,
+    ];
+
+    // Generate context type from machine context
+    for (const field of machine.context) {
+      if (field.type) {
+        lines.push(`  ${field.name}: ${field.type};`);
+      } else {
+        lines.push(`  ${field.name}: string | number | boolean;`);
+      }
+    }
+
+    lines.push('}');
+    lines.push('');
+
+    // Generate event types
+    lines.push(`export type ${machine.name}Event = ${machine.events.map(e => `'${e}'`).join(' | ')};`);
+    lines.push('');
+
+    // Generate action functions
+    for (const action of actions) {
+      lines.push(this.generateAction(action, machine));
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  generateAction(action: ActionScaffold, machine: MachineDef): string {
+    const ctxType = 'Context';
+
+    if (action.hasEffect && action.effectType) {
+      return `// Action: ${action.name}
+// Effect: ${action.effectType}
+
+export function ${action.name}(ctx: ${ctxType}, event: { type: ${machine.name}Event }): [${ctxType}, Effect<${action.effectType}>] {
+  // TODO: Implement action
+  return [ctx, { type: '${action.effectType}', payload: {} }];
+}`;
+    }
+
+    return `// Action: ${action.name}
+
+export function ${action.name}(ctx: ${ctxType}): ${ctxType} {
+  // TODO: Implement action
+  return { ...ctx };
+}`;
+  }
+}
+
+// Register the TypeScript code generator
+import { registerCodeGenerator } from './registry.js';
+registerCodeGenerator('typescript', () => new TypeScriptCodeGenerator());