@orcalang/orca-lang 0.1.0

package/src/auth/store.ts

@@ -0,0 +1,75 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { AuthProfileStore, AuthProfile } from './types.js';
+
+const STORE_VERSION = 1;
+
+export function getOrcaDir(): string {
+  return join(homedir(), '.orca');
+}
+
+export function getAuthStorePath(): string {
+  return join(getOrcaDir(), 'auth_profiles.json');
+}
+
+export function ensureOrcaDir(): void {
+  const dir = getOrcaDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { mode: 0o700, recursive: true });
+  }
+}
+
+export function loadAuthStore(): AuthProfileStore {
+  const path = getAuthStorePath();
+  ensureOrcaDir();
+
+  if (!existsSync(path)) {
+    return { version: STORE_VERSION, profiles: {} };
+  }
+
+  try {
+    const content = readFileSync(path, 'utf-8');
+    const store = JSON.parse(content) as AuthProfileStore;
+    return {
+      version: store.version ?? STORE_VERSION,
+      profiles: store.profiles ?? {},
+    };
+  } catch {
+    return { version: STORE_VERSION, profiles: {} };
+  }
+}
+
+export function saveAuthStore(store: AuthProfileStore): void {
+  const path = getAuthStorePath();
+  ensureOrcaDir();
+
+  // Set restrictive permissions (owner read/write only)
+  writeFileSync(path, JSON.stringify(store, null, 2), { mode: 0o600 });
+}
+
+export function getAuthProfile(profileId: string): AuthProfile | null {
+  const store = loadAuthStore();
+  return store.profiles[profileId] ?? null;
+}
+
+export function setAuthProfile(profileId: string, profile: AuthProfile): void {
+  const store = loadAuthStore();
+  store.profiles[profileId] = profile;
+  saveAuthStore(store);
+}
+
+export function deleteAuthProfile(profileId: string): boolean {
+  const store = loadAuthStore();
+  if (store.profiles[profileId]) {
+    delete store.profiles[profileId];
+    saveAuthStore(store);
+    return true;
+  }
+  return false;
+}
+
+export function listAuthProfiles(): string[] {
+  const store = loadAuthStore();
+  return Object.keys(store.profiles);
+}

package/src/auth/types.ts

@@ -0,0 +1,62 @@
+export type AuthMode = 'api_key' | 'oauth' | 'token';
+
+export interface ApiKeyCredential {
+  type: 'api_key';
+  provider: string;
+  key: string;
+  email?: string;
+}
+
+export interface OAuthCredential {
+  type: 'oauth';
+  provider: string;
+  access: string;
+  refresh: string;
+  expires: number; // Unix timestamp
+  email?: string;
+}
+
+export interface TokenCredential {
+  type: 'token';
+  provider: string;
+  token: string;
+  expires?: number; // Unix timestamp
+  email?: string;
+}
+
+export type AuthCredential = ApiKeyCredential | OAuthCredential | TokenCredential;
+
+export interface AuthProfile {
+  mode: AuthMode;
+  provider: string;
+  email?: string;
+  // api_key mode
+  key?: string;
+  keyRef?: string;
+  // token mode
+  token?: string;
+  tokenRef?: string;
+  // oauth mode
+  access?: string;
+  refresh?: string;
+  expires?: number;
+}
+
+export interface AuthProfileStore {
+  version: number;
+  profiles: Record<string, AuthProfile>;
+}
+
+export interface AuthProfileResult {
+  apiKey: string;
+  provider: string;
+  email?: string;
+}
+
+export type OAuthProvider = 'anthropic' | 'minimax';
+
+export interface TokenRefreshResult {
+  access: string;
+  refresh?: string;
+  expires: number;
+}

package/src/compiler/mermaid.ts

@@ -0,0 +1,109 @@
+import { MachineDef, StateDef } from '../parser/ast.js';
+
+export function compileToMermaid(machine: MachineDef): string {
+  const lines: string[] = [];
+
+  lines.push(`stateDiagram-v2`);
+  lines.push(`  direction LR`);
+  lines.push(``);
+
+  // Add initial state transition
+  lines.push(`  [*] --> ${getInitialStateName(machine)}`);
+
+  // Add termination transitions for top-level final states
+  for (const state of machine.states) {
+    if (state.isFinal) {
+      lines.push(`  ${state.name} --> [*]`);
+    }
+  }
+
+  lines.push(``);
+
+  // Render compound/parallel state bodies
+  for (const state of machine.states) {
+    renderStateBody(state, machine, lines, '  ');
+  }
+
+  // Add transitions
+  for (const t of machine.transitions) {
+    let label = t.event;
+    if (t.guard) {
+      label += ` [${t.guard.negated ? '!' : ''}${t.guard.name}]`;
+    }
+    if (t.action && t.action !== '_') {
+      label += ` / ${t.action}`;
+    }
+    lines.push(`  ${t.source} --> ${t.target} : ${label}`);
+  }
+
+  return lines.join('\n');
+}
+
+function renderStateBody(state: StateDef, machine: MachineDef, lines: string[], indent: string): void {
+  // Hierarchical compound states
+  if (state.contains && state.contains.length > 0) {
+    lines.push(`${indent}state ${state.name} {`);
+    const inner = indent + '  ';
+
+    // Initial child transition
+    const initialChild = state.contains.find(s => s.isInitial) || state.contains[0];
+    lines.push(`${inner}[*] --> ${initialChild.name}`);
+
+    // Final child transitions
+    for (const child of state.contains) {
+      if (child.isFinal) {
+        lines.push(`${inner}${child.name} --> [*]`);
+      }
+    }
+
+    // Recurse into children that are themselves compound/parallel
+    for (const child of state.contains) {
+      renderStateBody(child, machine, lines, inner);
+    }
+
+    lines.push(`${indent}}`);
+  }
+
+  // Parallel states
+  if (state.parallel) {
+    lines.push(`${indent}state ${state.name} {`);
+    const inner = indent + '  ';
+
+    for (let i = 0; i < state.parallel.regions.length; i++) {
+      const region = state.parallel.regions[i];
+
+      // Region separator between regions
+      if (i > 0) {
+        lines.push(`${inner}--`);
+      }
+
+      lines.push(`${inner}state ${region.name} {`);
+      const regionInner = inner + '  ';
+
+      // Initial child transition within region
+      const initialChild = region.states.find(s => s.isInitial) || region.states[0];
+      lines.push(`${regionInner}[*] --> ${initialChild.name}`);
+
+      // Final child transitions within region
+      for (const child of region.states) {
+        if (child.isFinal) {
+          lines.push(`${regionInner}${child.name} --> [*]`);
+        }
+      }
+
+      // Recurse into children
+      for (const child of region.states) {
+        renderStateBody(child, machine, lines, regionInner);
+      }
+
+      lines.push(`${inner}}`);
+    }
+
+    lines.push(`${indent}}`);
+  }
+}
+
+function getInitialStateName(machine: MachineDef): string {
+  const initial = machine.states.find(s => s.isInitial);
+  return initial?.name || machine.states[0]?.name || 'unknown';
+}