@baselineos/frame 0.1.0

package/src/system.ts

@@ -0,0 +1,677 @@
+/**
+ * Baseline Frame System
+ *
+ * The context and control layer of the Baseline Protocol that manages
+ * intent recognition, mode switching, environment context, and authority
+ * management.
+ *
+ * @license Apache-2.0
+ */
+
+import frameSystemConfig from './config/frame-system-config.json' with { type: 'json' };
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface FrameSystemConfig {
+  system: { name: string; version: string; description: string };
+  modes: Record<string, ModeConfig>;
+  contexts: Record<string, ContextConfig>;
+  authorities: Record<string, AuthorityConfig>;
+  environments?: Record<string, EnvironmentEntry>;
+}
+
+export interface ModeConfig {
+  description: string;
+  permissions: string[];
+  environment: string;
+  features: string[];
+}
+
+export interface ContextConfig {
+  description: string;
+  mode: string;
+  environment: string;
+  permissions: string[];
+  authority?: string;
+}
+
+export interface AuthorityConfig {
+  level: number;
+  permissions: string[];
+  description: string;
+}
+
+export interface ContextEntry {
+  name: string;
+  description: string;
+  mode: string;
+  environment: string;
+  permissions: string[];
+  authority: string;
+  status: 'active' | 'inactive' | 'archived';
+  createdAt: number;
+  updatedAt: number;
+  lastActivatedAt?: number;
+  archivedAt?: number;
+}
+
+export interface ModeEntry {
+  name: string;
+  description: string;
+  permissions: string[];
+  environment: string;
+  features: string[];
+}
+
+export interface AuthorityEntry {
+  name: string;
+  level: number;
+  permissions: string[];
+  description: string;
+}
+
+export interface EnvironmentEntry {
+  name: string;
+  type: string;
+  description: string;
+  variables: Record<string, string>;
+  features?: string[];
+}
+
+export interface FrameCommandResult {
+  success: boolean;
+  command?: string;
+  context?: string;
+  mode?: string | ModeEntry | null;
+  authority?: string;
+  environment?: string;
+  result?: unknown;
+  error?: string;
+  details?: string;
+  required?: string[];
+  current?: string;
+  available?: string[];
+  description?: string;
+  permissions?: string[] | { context: string[]; mode: string[] };
+  timestamp?: string;
+}
+
+export interface FrameStatus {
+  initialized: boolean;
+  contextHistory: number;
+  currentMode: ModeEntry | null;
+  currentEnvironment: string | undefined;
+  activeContexts: number;
+  systemName: string;
+  version: string;
+  currentAuthority?: string | null;
+}
+
+function extractRequiredPermissions(options: Record<string, unknown>): string[] | null {
+  const candidate = options.requiredPermissions;
+  if (!Array.isArray(candidate)) {
+    return null;
+  }
+  if (candidate.every(permission => typeof permission === 'string')) {
+    return candidate;
+  }
+  return null;
+}
+
+// ─── Context Manager ────────────────────────────────────────────────
+
+export class ContextManager {
+  private contexts = new Map<string, ContextEntry>();
+  private currentContext: ContextEntry | null = null;
+  private history: Array<{ name: string; action: 'create' | 'activate' | 'archive'; timestamp: number }> = [];
+
+  initialize(contextConfig: Record<string, ContextConfig>): void {
+    for (const [name, config] of Object.entries(contextConfig)) {
+      this.contexts.set(name, {
+        name,
+        description: config.description,
+        mode: config.mode,
+        environment: config.environment,
+        permissions: config.permissions,
+        authority: config.authority || 'user',
+        status: 'inactive',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+    }
+  }
+
+  createContext(name: string, config: ContextConfig): boolean {
+    if (this.contexts.has(name)) return false;
+    this.contexts.set(name, {
+      name,
+      description: config.description,
+      mode: config.mode,
+      environment: config.environment,
+      permissions: config.permissions,
+      authority: config.authority || 'user',
+      status: 'inactive',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    this.history.push({ name, action: 'create', timestamp: Date.now() });
+    return true;
+  }
+
+  setContext(contextName: string): boolean {
+    return this.activateContext(contextName);
+  }
+
+  activateContext(contextName: string): boolean {
+    const ctx = this.contexts.get(contextName);
+    if (!ctx || ctx.status === 'archived') return false;
+    // deactivate current
+    if (this.currentContext) {
+      this.currentContext.status = 'inactive';
+      this.currentContext.updatedAt = Date.now();
+    }
+    ctx.status = 'active';
+    ctx.updatedAt = Date.now();
+    ctx.lastActivatedAt = Date.now();
+    this.currentContext = ctx;
+    this.history.push({ name: contextName, action: 'activate', timestamp: Date.now() });
+    return true;
+  }
+
+  archiveContext(contextName: string): boolean {
+    const ctx = this.contexts.get(contextName);
+    if (!ctx) return false;
+    ctx.status = 'archived';
+    ctx.archivedAt = Date.now();
+    ctx.updatedAt = Date.now();
+    if (this.currentContext?.name === contextName) {
+      this.currentContext = null;
+    }
+    this.history.push({ name: contextName, action: 'archive', timestamp: Date.now() });
+    return true;
+  }
+
+  getCurrentContext(): ContextEntry | null {
+    return this.currentContext;
+  }
+
+  getContext(contextName: string): ContextEntry | undefined {
+    return this.contexts.get(contextName);
+  }
+
+  listContexts(): string[] {
+    return Array.from(this.contexts.keys());
+  }
+
+  getContextHistory(): string[] {
+    return this.history.map(item => item.name);
+  }
+
+  getActiveContexts(): ContextEntry[] {
+    return this.currentContext ? [this.currentContext] : [];
+  }
+
+  getContextTimeline(): Array<{ name: string; action: 'create' | 'activate' | 'archive'; timestamp: number }> {
+    return [...this.history];
+  }
+}
+
+// ─── Mode Manager ───────────────────────────────────────────────────
+
+export class ModeManager {
+  private modes = new Map<string, ModeEntry>();
+  private currentMode: ModeEntry | null = null;
+
+  initialize(modeConfig: Record<string, ModeConfig>): void {
+    for (const [name, config] of Object.entries(modeConfig)) {
+      this.modes.set(name, {
+        name,
+        description: config.description,
+        permissions: config.permissions,
+        environment: config.environment,
+        features: config.features,
+      });
+    }
+  }
+
+  setMode(modeName: string): boolean {
+    if (this.modes.has(modeName)) {
+      this.currentMode = this.modes.get(modeName)!;
+      return true;
+    }
+    return false;
+  }
+
+  getCurrentMode(): ModeEntry | null {
+    return this.currentMode;
+  }
+
+  getMode(modeName: string): ModeEntry | undefined {
+    return this.modes.get(modeName);
+  }
+
+  processInMode(
+    modeName: string,
+    command: string,
+    options: Record<string, unknown>,
+    args: string[],
+  ): Record<string, unknown> {
+    const mode = this.modes.get(modeName);
+    if (!mode) {
+      throw new Error(`Mode "${modeName}" not found`);
+    }
+
+    return {
+      mode: modeName,
+      command,
+      options,
+      arguments: args,
+      permissions: mode.permissions,
+      environment: mode.environment,
+      result: `Command executed in ${modeName} mode`,
+    };
+  }
+}
+
+// ─── Authority Manager ──────────────────────────────────────────────
+
+export class AuthorityManager {
+  private authorities = new Map<string, AuthorityEntry>();
+  private currentAuthority: AuthorityEntry | null = null;
+
+  initialize(authorityConfig: Record<string, AuthorityConfig>): void {
+    for (const [name, config] of Object.entries(authorityConfig)) {
+      this.authorities.set(name, {
+        name,
+        level: config.level,
+        permissions: config.permissions,
+        description: config.description,
+      });
+    }
+    this.currentAuthority = this.authorities.get('user') || null;
+  }
+
+  getCurrentAuthority(): AuthorityEntry | null {
+    return this.currentAuthority;
+  }
+
+  setAuthority(authorityName: string): boolean {
+    if (this.authorities.has(authorityName)) {
+      this.currentAuthority = this.authorities.get(authorityName)!;
+      return true;
+    }
+    return false;
+  }
+
+  checkPermission(
+    authorityName: string,
+    command: string,
+    options: Record<string, unknown>,
+  ): boolean {
+    const authority = this.authorities.get(authorityName);
+    if (!authority) return false;
+    const required = this.getRequiredPermissions(command, options);
+    return required.every(perm => authority.permissions.includes(perm));
+  }
+
+  getRequiredPermissions(command: string, options?: Record<string, unknown>): string[] {
+    if (options) {
+      const fromOptions = extractRequiredPermissions(options);
+      if (fromOptions) {
+        return fromOptions;
+      }
+    }
+
+    const cmd = command.toLowerCase();
+    if (cmd.includes('admin') || cmd.includes('system') || cmd.includes('override')) {
+      return ['admin'];
+    }
+    if (cmd.includes('deploy')) {
+      return ['deploy'];
+    }
+    if (cmd.includes('write') || cmd.includes('create') || cmd.includes('set') || cmd.includes('update') || cmd.includes('archive')) {
+      return ['write'];
+    }
+    if (cmd.includes('run') || cmd.includes('execute') || cmd.includes('start')) {
+      return ['execute'];
+    }
+    return ['read'];
+  }
+}
+
+// ─── Environment Manager ────────────────────────────────────────────
+
+export class EnvironmentManager {
+  private environments = new Map<string, EnvironmentEntry>();
+  private currentEnvironment: EnvironmentEntry | null = null;
+
+  initialize(envConfig?: Record<string, EnvironmentEntry>): void {
+    if (envConfig && Object.keys(envConfig).length > 0) {
+      for (const [name, env] of Object.entries(envConfig)) {
+        this.environments.set(name, env);
+      }
+      this.currentEnvironment = this.environments.values().next().value ?? null;
+      return;
+    }
+
+    this.environments.set('dev', {
+      name: 'dev',
+      type: 'development',
+      description: 'Development environment',
+      variables: { NODE_ENV: 'development', DEBUG: 'true', LOG_LEVEL: 'debug' },
+    });
+
+    this.environments.set('prod', {
+      name: 'prod',
+      type: 'production',
+      description: 'Production environment',
+      variables: { NODE_ENV: 'production', DEBUG: 'false', LOG_LEVEL: 'info' },
+    });
+
+    this.environments.set('test', {
+      name: 'test',
+      type: 'testing',
+      description: 'Testing environment',
+      variables: { NODE_ENV: 'test', DEBUG: 'true', LOG_LEVEL: 'debug' },
+    });
+
+    this.currentEnvironment = this.environments.get('dev') || null;
+  }
+
+  getCurrentEnvironment(): EnvironmentEntry | null {
+    return this.currentEnvironment;
+  }
+
+  setEnvironment(envName: string): boolean {
+    if (this.environments.has(envName)) {
+      this.currentEnvironment = this.environments.get(envName)!;
+      return true;
+    }
+    return false;
+  }
+
+  getEnvironmentVariable(name: string): string | undefined {
+    return this.currentEnvironment?.variables[name];
+  }
+}
+
+// ─── Baseline Frame System ──────────────────────────────────────────
+
+export class BaselineFrameSystem {
+  private config: FrameSystemConfig;
+  private context: ContextManager;
+  private modeManager: ModeManager;
+  private authorityManager: AuthorityManager;
+  private environmentManager: EnvironmentManager;
+  private initialized = false;
+
+  constructor() {
+    this.config = this.loadConfiguration();
+    this.context = new ContextManager();
+    this.modeManager = new ModeManager();
+    this.authorityManager = new AuthorityManager();
+    this.environmentManager = new EnvironmentManager();
+    this.initializeSystem();
+  }
+
+  private loadConfiguration(): FrameSystemConfig {
+    const cfg = frameSystemConfig as {
+      system?: Record<string, string>;
+      modes?: Record<string, { description?: string; permissions?: string[]; environment?: string; features?: string[] }>;
+      contexts?: Record<string, { description?: string; mode?: string; environment?: string; permissions?: string[] }>;
+      authorities?: Record<string, { level?: number; permissions?: string[]; description?: string }>;
+      environments?: Record<string, EnvironmentEntry>;
+    };
+
+    const modes: FrameSystemConfig['modes'] = {};
+    for (const [name, mode] of Object.entries(cfg.modes ?? {})) {
+      modes[name] = {
+        description: mode.description ?? '',
+        permissions: mode.permissions ?? [],
+        environment: mode.environment ?? 'dev',
+        features: mode.features ?? [],
+      };
+    }
+
+    const contexts: FrameSystemConfig['contexts'] = {};
+    for (const [name, ctx] of Object.entries(cfg.contexts ?? {})) {
+      contexts[name] = {
+        description: ctx.description ?? '',
+        mode: ctx.mode ?? 'development',
+        environment: ctx.environment ?? 'dev',
+        permissions: ctx.permissions ?? [],
+      };
+    }
+
+    const authorities: FrameSystemConfig['authorities'] = {};
+    for (const [name, auth] of Object.entries(cfg.authorities ?? {})) {
+      authorities[name] = {
+        level: auth.level ?? 1,
+        permissions: auth.permissions ?? [],
+        description: auth.description ?? '',
+      };
+    }
+
+    return {
+      system: {
+        name: cfg.system?.name ?? 'Baseline Frame System',
+        version: cfg.system?.version ?? '1.0.0',
+        description: cfg.system?.description ?? 'Context and control layer for Baseline Protocol',
+      },
+      modes,
+      contexts,
+      authorities,
+      environments: cfg.environments ?? {},
+    };
+  }
+
+  private initializeSystem(): void {
+    this.context.initialize(this.config.contexts);
+    this.modeManager.initialize(this.config.modes);
+    this.authorityManager.initialize(this.config.authorities);
+    this.environmentManager.initialize(this.config.environments);
+    this.context.setContext('default');
+
+    const defaultContext = this.context.getCurrentContext();
+    if (defaultContext?.mode) {
+      this.modeManager.setMode(defaultContext.mode);
+    } else {
+      this.modeManager.setMode('development');
+    }
+
+    if (defaultContext?.authority) {
+      this.authorityManager.setAuthority(defaultContext.authority);
+    }
+
+    if (defaultContext?.environment) {
+      this.environmentManager.setEnvironment(defaultContext.environment);
+    }
+
+    this.initialized = true;
+  }
+
+  processCommand(
+    command: string,
+    options: Record<string, unknown> = {},
+    args: string[] = [],
+  ): FrameCommandResult {
+    try {
+      const currentContext = this.context.getCurrentContext();
+      if (!currentContext) {
+        return { success: false, error: 'No context set' };
+      }
+
+      const hasPermission = this.authorityManager.checkPermission(
+        currentContext.authority,
+        command,
+        options,
+      );
+
+      if (!hasPermission) {
+        return {
+          success: false,
+          error: 'Insufficient permissions for this command',
+          context: currentContext.name,
+          required: this.authorityManager.getRequiredPermissions(command),
+          current: currentContext.authority,
+        };
+      }
+
+      const requiredPermissions = this.authorityManager.getRequiredPermissions(command, options);
+      const currentMode = this.modeManager.getCurrentMode();
+      const modePermissions = currentMode?.permissions ?? [];
+      const contextPermissions = currentContext.permissions ?? [];
+      const missingFromContext = requiredPermissions.filter(p => !contextPermissions.includes(p));
+      const missingFromMode = requiredPermissions.filter(p => !modePermissions.includes(p));
+
+      if (missingFromContext.length > 0 || missingFromMode.length > 0) {
+        return {
+          success: false,
+          error: 'Permission denied by context/mode',
+          context: currentContext.name,
+          required: requiredPermissions,
+          current: currentContext.authority,
+          permissions: {
+            context: contextPermissions,
+            mode: modePermissions,
+          },
+        };
+      }
+
+      const result = this.modeManager.processInMode(
+        currentContext.mode,
+        command,
+        options,
+        args,
+      );
+
+      return {
+        success: true,
+        command,
+        context: currentContext.name,
+        mode: currentContext.mode,
+        result,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: 'Command processing failed',
+        details: msg,
+        context: this.context.getCurrentContext()?.name || 'unknown',
+      };
+    }
+  }
+
+  switchContext(contextName: string): FrameCommandResult {
+    const target = this.context.getContext(contextName);
+    if (!target || target.status === 'archived') {
+      return {
+        success: false,
+        error: `Context "${contextName}" not found`,
+        available: Object.keys(this.config.contexts),
+      };
+    }
+
+    const mode = this.modeManager.getMode(target.mode);
+    if (!mode) {
+      return {
+        success: false,
+        error: `Mode "${target.mode}" not found`,
+        available: Object.keys(this.config.modes),
+      };
+    }
+
+    if (mode.environment !== target.environment) {
+      return {
+        success: false,
+        error: `Context environment "${target.environment}" does not match mode environment "${mode.environment}"`,
+      };
+    }
+
+    const success = this.context.activateContext(contextName);
+    if (!success) {
+      return {
+        success: false,
+        error: `Context "${contextName}" not found`,
+        available: Object.keys(this.config.contexts),
+      };
+    }
+
+    const newContext = this.context.getCurrentContext()!;
+    this.authorityManager.setAuthority(newContext.authority);
+    this.modeManager.setMode(newContext.mode);
+    this.environmentManager.setEnvironment(newContext.environment);
+
+    return {
+      success: true,
+      context: newContext.name,
+      mode: newContext.mode,
+      authority: newContext.authority,
+      environment: newContext.environment,
+    };
+  }
+
+  switchMode(modeName: string): FrameCommandResult {
+    const currentMode = this.modeManager.getCurrentMode();
+    const success = this.modeManager.setMode(modeName);
+
+    if (!success) {
+      return {
+        success: false,
+        error: `Mode "${modeName}" not found`,
+        available: Object.keys(this.config.modes),
+      };
+    }
+
+    const newMode = this.modeManager.getCurrentMode()!;
+    const currentContext = this.context.getCurrentContext();
+    if (currentContext && currentContext.environment !== newMode.environment) {
+      // revert
+      if (currentMode) this.modeManager.setMode(currentMode.name);
+      return {
+        success: false,
+        error: `Mode environment "${newMode.environment}" does not match context environment "${currentContext.environment}"`,
+      };
+    }
+
+    this.environmentManager.setEnvironment(newMode.environment);
+    return {
+      success: true,
+      mode: newMode,
+      description: newMode.description,
+      permissions: newMode.permissions,
+      environment: newMode.environment,
+    };
+  }
+
+  getStatus(): FrameStatus {
+    return {
+      initialized: this.initialized,
+      contextHistory: this.context.getContextHistory().length,
+      currentMode: this.modeManager.getCurrentMode(),
+      currentEnvironment: this.environmentManager.getCurrentEnvironment()?.name,
+      activeContexts: this.context.getActiveContexts().length,
+      systemName: this.config.system.name,
+      version: this.config.system.version,
+      currentAuthority: this.authorityManager.getCurrentAuthority()?.name ?? null,
+    };
+  }
+
+  getContextManager(): ContextManager {
+    return this.context;
+  }
+
+  getModeManager(): ModeManager {
+    return this.modeManager;
+  }
+
+  getAuthorityManager(): AuthorityManager {
+    return this.authorityManager;
+  }
+
+  getEnvironmentManager(): EnvironmentManager {
+    return this.environmentManager;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}