@baselineos/frame 0.1.0

package/dist/index.js

@@ -0,0 +1,800 @@
+// src/config/frame-system-config.json
+var frame_system_config_default = {
+  system: {
+    name: "Baseline Frame System",
+    version: "1.0.0",
+    description: "Context and control layer for Baseline Protocol",
+    type: "frame-layer",
+    architecture: "context-control"
+  },
+  modes: {
+    development: {
+      description: "Development mode with full access and debugging capabilities",
+      permissions: ["read", "write", "execute", "debug", "test"],
+      environment: "dev",
+      features: ["hot-reload", "debugging", "testing", "profiling", "logging"],
+      security: "relaxed",
+      performance: "development"
+    },
+    production: {
+      description: "Production mode with restricted access and security focus",
+      permissions: ["read", "execute", "monitor"],
+      environment: "prod",
+      features: ["monitoring", "logging", "security", "performance", "scalability"],
+      security: "strict",
+      performance: "optimized"
+    },
+    testing: {
+      description: "Testing mode for validation and quality assurance",
+      permissions: ["read", "write", "execute", "test"],
+      environment: "test",
+      features: ["validation", "testing", "reporting", "coverage", "mocking"],
+      security: "moderate",
+      performance: "testing"
+    },
+    maintenance: {
+      description: "Maintenance mode for system operations and administration",
+      permissions: ["read", "write", "execute", "admin", "system"],
+      environment: "maintenance",
+      features: ["backup", "restore", "upgrade", "repair", "diagnostics"],
+      security: "elevated",
+      performance: "maintenance"
+    },
+    staging: {
+      description: "Staging mode for pre-production testing and validation",
+      permissions: ["read", "write", "execute", "test", "monitor"],
+      environment: "staging",
+      features: ["validation", "testing", "monitoring", "performance", "security"],
+      security: "moderate",
+      performance: "production-like"
+    }
+  },
+  contexts: {
+    default: {
+      description: "Default application context for general operations",
+      mode: "development",
+      environment: "dev",
+      permissions: ["read", "write", "execute"],
+      authority: "user",
+      scope: "application"
+    },
+    user: {
+      description: "User-specific context with personalized settings",
+      mode: "development",
+      environment: "dev",
+      permissions: ["read", "write", "execute"],
+      authority: "user",
+      scope: "user"
+    },
+    system: {
+      description: "System-level context for core operations",
+      mode: "production",
+      environment: "prod",
+      permissions: ["read", "execute", "monitor"],
+      authority: "system",
+      scope: "system"
+    },
+    admin: {
+      description: "Administrative context for system management",
+      mode: "maintenance",
+      environment: "maintenance",
+      permissions: ["read", "write", "execute", "admin"],
+      authority: "admin",
+      scope: "system"
+    },
+    developer: {
+      description: "Developer context for development and testing",
+      mode: "development",
+      environment: "dev",
+      permissions: ["read", "write", "execute", "debug", "test"],
+      authority: "developer",
+      scope: "development"
+    },
+    tester: {
+      description: "Testing context for quality assurance",
+      mode: "testing",
+      environment: "test",
+      permissions: ["read", "write", "execute", "test"],
+      authority: "developer",
+      scope: "testing"
+    },
+    deployment: {
+      description: "Deployment context for release management",
+      mode: "staging",
+      environment: "staging",
+      permissions: ["read", "write", "execute", "deploy"],
+      authority: "admin",
+      scope: "deployment"
+    }
+  },
+  authorities: {
+    user: {
+      level: 1,
+      permissions: ["read", "write"],
+      description: "Standard user permissions for basic operations",
+      scope: "user",
+      restrictions: ["system", "admin"]
+    },
+    developer: {
+      level: 2,
+      permissions: ["read", "write", "execute", "debug", "test"],
+      description: "Developer permissions for development and testing",
+      scope: "development",
+      restrictions: ["system", "admin"]
+    },
+    admin: {
+      level: 3,
+      permissions: ["read", "write", "execute", "admin", "deploy"],
+      description: "Administrative permissions for system management",
+      scope: "system",
+      restrictions: ["system"]
+    },
+    system: {
+      level: 4,
+      permissions: ["read", "write", "execute", "admin", "system", "core"],
+      description: "System-level permissions for core operations",
+      scope: "core",
+      restrictions: []
+    },
+    superuser: {
+      level: 5,
+      permissions: ["read", "write", "execute", "admin", "system", "core", "override"],
+      description: "Superuser permissions with override capabilities",
+      scope: "all",
+      restrictions: []
+    }
+  },
+  environments: {
+    dev: {
+      name: "dev",
+      type: "development",
+      description: "Development environment for active development",
+      variables: {
+        NODE_ENV: "development",
+        DEBUG: "true",
+        LOG_LEVEL: "debug",
+        API_URL: "http://localhost:3000",
+        DATABASE_URL: "mongodb://localhost:27017/dev",
+        CACHE_TTL: "300"
+      },
+      features: ["hot-reload", "debugging", "profiling"]
+    },
+    test: {
+      name: "test",
+      type: "testing",
+      description: "Testing environment for quality assurance",
+      variables: {
+        NODE_ENV: "test",
+        DEBUG: "true",
+        LOG_LEVEL: "debug",
+        API_URL: "http://localhost:3001",
+        DATABASE_URL: "mongodb://localhost:27017/test",
+        CACHE_TTL: "60"
+      },
+      features: ["testing", "mocking", "coverage"]
+    },
+    staging: {
+      name: "staging",
+      type: "staging",
+      description: "Staging environment for pre-production validation",
+      variables: {
+        NODE_ENV: "staging",
+        DEBUG: "false",
+        LOG_LEVEL: "info",
+        API_URL: "https://staging-api.example.com",
+        DATABASE_URL: "mongodb://staging-db:27017/staging",
+        CACHE_TTL: "1800"
+      },
+      features: ["monitoring", "validation", "performance"]
+    },
+    prod: {
+      name: "prod",
+      type: "production",
+      description: "Production environment for live operations",
+      variables: {
+        NODE_ENV: "production",
+        DEBUG: "false",
+        LOG_LEVEL: "warn",
+        API_URL: "https://api.example.com",
+        DATABASE_URL: "mongodb://prod-db:27017/production",
+        CACHE_TTL: "3600"
+      },
+      features: ["monitoring", "security", "scalability"]
+    },
+    maintenance: {
+      name: "maintenance",
+      type: "maintenance",
+      description: "Maintenance environment for system operations",
+      variables: {
+        NODE_ENV: "maintenance",
+        DEBUG: "true",
+        LOG_LEVEL: "info",
+        API_URL: "http://localhost:3002",
+        DATABASE_URL: "mongodb://localhost:27017/maintenance",
+        CACHE_TTL: "0"
+      },
+      features: ["backup", "restore", "diagnostics"]
+    }
+  },
+  permissions: {
+    read: {
+      description: "Read access to resources and data",
+      scope: "data",
+      level: 1
+    },
+    write: {
+      description: "Write access to resources and data",
+      scope: "data",
+      level: 2
+    },
+    execute: {
+      description: "Execute commands and operations",
+      scope: "operations",
+      level: 2
+    },
+    debug: {
+      description: "Debug and development capabilities",
+      scope: "development",
+      level: 2
+    },
+    test: {
+      description: "Testing and validation capabilities",
+      scope: "testing",
+      level: 2
+    },
+    monitor: {
+      description: "Monitoring and observation capabilities",
+      scope: "monitoring",
+      level: 1
+    },
+    admin: {
+      description: "Administrative and management capabilities",
+      scope: "system",
+      level: 3
+    },
+    deploy: {
+      description: "Deployment and release capabilities",
+      scope: "deployment",
+      level: 3
+    },
+    system: {
+      description: "System-level capabilities",
+      scope: "core",
+      level: 4
+    },
+    core: {
+      description: "Core system capabilities",
+      scope: "core",
+      level: 4
+    },
+    override: {
+      description: "Override and emergency capabilities",
+      scope: "all",
+      level: 5
+    }
+  },
+  security: {
+    authentication: {
+      required: true,
+      methods: ["token", "oauth", "sso"],
+      timeout: 3600
+    },
+    authorization: {
+      required: true,
+      method: "role-based",
+      audit: true
+    },
+    encryption: {
+      data_at_rest: true,
+      data_in_transit: true,
+      algorithm: "AES-256"
+    },
+    logging: {
+      enabled: true,
+      level: "info",
+      retention: "90d"
+    }
+  },
+  performance: {
+    caching: {
+      enabled: true,
+      strategy: "lru",
+      max_size: "100MB"
+    },
+    monitoring: {
+      enabled: true,
+      metrics: ["cpu", "memory", "response_time"],
+      alerts: true
+    },
+    optimization: {
+      enabled: true,
+      strategies: ["compression", "minification", "bundling"]
+    }
+  }
+};
+
+// src/system.ts
+function extractRequiredPermissions(options) {
+  const candidate = options.requiredPermissions;
+  if (!Array.isArray(candidate)) {
+    return null;
+  }
+  if (candidate.every((permission) => typeof permission === "string")) {
+    return candidate;
+  }
+  return null;
+}
+var ContextManager = class {
+  contexts = /* @__PURE__ */ new Map();
+  currentContext = null;
+  history = [];
+  initialize(contextConfig) {
+    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, config) {
+    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) {
+    return this.activateContext(contextName);
+  }
+  activateContext(contextName) {
+    const ctx = this.contexts.get(contextName);
+    if (!ctx || ctx.status === "archived") return false;
+    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) {
+    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() {
+    return this.currentContext;
+  }
+  getContext(contextName) {
+    return this.contexts.get(contextName);
+  }
+  listContexts() {
+    return Array.from(this.contexts.keys());
+  }
+  getContextHistory() {
+    return this.history.map((item) => item.name);
+  }
+  getActiveContexts() {
+    return this.currentContext ? [this.currentContext] : [];
+  }
+  getContextTimeline() {
+    return [...this.history];
+  }
+};
+var ModeManager = class {
+  modes = /* @__PURE__ */ new Map();
+  currentMode = null;
+  initialize(modeConfig) {
+    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) {
+    if (this.modes.has(modeName)) {
+      this.currentMode = this.modes.get(modeName);
+      return true;
+    }
+    return false;
+  }
+  getCurrentMode() {
+    return this.currentMode;
+  }
+  getMode(modeName) {
+    return this.modes.get(modeName);
+  }
+  processInMode(modeName, command, options, args) {
+    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`
+    };
+  }
+};
+var AuthorityManager = class {
+  authorities = /* @__PURE__ */ new Map();
+  currentAuthority = null;
+  initialize(authorityConfig) {
+    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() {
+    return this.currentAuthority;
+  }
+  setAuthority(authorityName) {
+    if (this.authorities.has(authorityName)) {
+      this.currentAuthority = this.authorities.get(authorityName);
+      return true;
+    }
+    return false;
+  }
+  checkPermission(authorityName, command, options) {
+    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, options) {
+    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"];
+  }
+};
+var EnvironmentManager = class {
+  environments = /* @__PURE__ */ new Map();
+  currentEnvironment = null;
+  initialize(envConfig) {
+    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() {
+    return this.currentEnvironment;
+  }
+  setEnvironment(envName) {
+    if (this.environments.has(envName)) {
+      this.currentEnvironment = this.environments.get(envName);
+      return true;
+    }
+    return false;
+  }
+  getEnvironmentVariable(name) {
+    return this.currentEnvironment?.variables[name];
+  }
+};
+var BaselineFrameSystem = class {
+  config;
+  context;
+  modeManager;
+  authorityManager;
+  environmentManager;
+  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();
+  }
+  loadConfiguration() {
+    const cfg = frame_system_config_default;
+    const 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 = {};
+    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 = {};
+    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 ?? {}
+    };
+  }
+  initializeSystem() {
+    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, options = {}, args = []) {
+    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: (/* @__PURE__ */ 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) {
+    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) {
+    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) {
+      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() {
+    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() {
+    return this.context;
+  }
+  getModeManager() {
+    return this.modeManager;
+  }
+  getAuthorityManager() {
+    return this.authorityManager;
+  }
+  getEnvironmentManager() {
+    return this.environmentManager;
+  }
+};
+export {
+  AuthorityManager,
+  BaselineFrameSystem,
+  ContextManager,
+  EnvironmentManager,
+  ModeManager
+};
+/**
+ * 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
+ */