@cogitator-ai/self-modifying 0.1.0

package/src/constraints/index.ts

@@ -0,0 +1,23 @@
+export {
+  DEFAULT_SAFETY_CONSTRAINTS,
+  DEFAULT_CAPABILITY_CONSTRAINTS,
+  DEFAULT_RESOURCE_CONSTRAINTS,
+  createDefaultConstraints,
+  mergeSafetyConstraints,
+  mergeCapabilityConstraints,
+  mergeResourceConstraints,
+  mergeConstraints,
+} from './safety-constraints';
+
+export {
+  RollbackManager,
+  InMemoryCheckpointStore,
+  type CheckpointStore,
+  type RollbackManagerOptions,
+  type CheckpointDiff,
+} from './rollback-manager';
+
+export {
+  ModificationValidator,
+  type ModificationValidatorOptions,
+} from './modification-validator';

package/src/constraints/modification-validator.ts

@@ -0,0 +1,402 @@
+import type {
+  ModificationRequest,
+  ModificationValidationResult,
+  ModificationConstraints,
+  ConstraintCheckResult,
+  SafetyConstraint,
+  CapabilityConstraint,
+  ResourceConstraint,
+  CustomConstraint,
+  ConstraintRule,
+} from '@cogitator-ai/types';
+import { createDefaultConstraints, mergeConstraints } from './safety-constraints';
+
+export interface ModificationValidatorOptions {
+  constraints?: Partial<ModificationConstraints>;
+  strictMode?: boolean;
+}
+
+export class ModificationValidator {
+  private constraints: ModificationConstraints;
+  private strictMode: boolean;
+
+  constructor(options: ModificationValidatorOptions = {}) {
+    this.constraints = mergeConstraints(
+      createDefaultConstraints(),
+      options.constraints ?? {}
+    );
+    this.strictMode = options.strictMode ?? false;
+  }
+
+  async validate(request: ModificationRequest): Promise<ModificationValidationResult> {
+    const results: ConstraintCheckResult[] = [];
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    const safetyResults = await this.checkSafetyConstraints(request);
+    results.push(...safetyResults);
+
+    const capabilityResults = await this.checkCapabilityConstraints(request);
+    results.push(...capabilityResults);
+
+    const resourceResults = await this.checkResourceConstraints(request);
+    results.push(...resourceResults);
+
+    const customResults = await this.checkCustomConstraints(request);
+    results.push(...customResults);
+
+    for (const result of results) {
+      if (!result.satisfied) {
+        if (result.severity === 'critical' || result.severity === 'error') {
+          errors.push(result.message ?? `Constraint ${result.constraintName} violated`);
+        } else {
+          warnings.push(result.message ?? `Constraint ${result.constraintName} warning`);
+        }
+      }
+    }
+
+    const hasCriticalViolation = results.some(
+      (r) => !r.satisfied && r.severity === 'critical'
+    );
+    const hasErrorViolation = results.some(
+      (r) => !r.satisfied && r.severity === 'error'
+    );
+
+    const valid = this.strictMode
+      ? results.every((r) => r.satisfied)
+      : !hasCriticalViolation && !hasErrorViolation;
+
+    return {
+      valid,
+      constraintResults: results,
+      errors,
+      warnings,
+      rollbackRequired: hasCriticalViolation,
+    };
+  }
+
+  private async checkSafetyConstraints(
+    request: ModificationRequest
+  ): Promise<ConstraintCheckResult[]> {
+    const results: ConstraintCheckResult[] = [];
+
+    for (const constraint of this.constraints.safety) {
+      const satisfied = this.evaluateSafetyRule(constraint.rule, request);
+      results.push({
+        constraintId: constraint.id,
+        constraintName: constraint.name,
+        satisfied,
+        severity: constraint.severity,
+        message: satisfied ? undefined : constraint.description,
+      });
+    }
+
+    return results;
+  }
+
+  private evaluateSafetyRule(rule: ConstraintRule, request: ModificationRequest): boolean {
+    if (typeof rule === 'string') {
+      return this.evaluateExpression(rule, request.payload as Record<string, unknown>);
+    }
+
+    const payload = request.payload as Record<string, unknown>;
+
+    switch (rule.type) {
+      case 'invariant':
+        return this.evaluateExpression(rule.expression ?? '', payload);
+      case 'precondition':
+        return this.evaluateExpression(rule.expression ?? '', payload);
+      case 'postcondition':
+        return true;
+      case 'temporal':
+        if (rule.pattern?.source === 'never') {
+          return !this.evaluateExpression(rule.expression ?? '', payload);
+        }
+        return true;
+      default:
+        return true;
+    }
+  }
+
+  private evaluateExpression(expression: string, context: Record<string, unknown>): boolean {
+    const parts = expression.split(/\s+(AND|OR)\s+/i);
+    const conditions: boolean[] = [];
+    const operators: string[] = [];
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i].trim();
+      if (part.toUpperCase() === 'AND' || part.toUpperCase() === 'OR') {
+        operators.push(part.toUpperCase());
+      } else {
+        conditions.push(this.evaluateSimpleCondition(part, context));
+      }
+    }
+
+    if (conditions.length === 0) return true;
+
+    let result = conditions[0];
+    for (let i = 0; i < operators.length; i++) {
+      if (operators[i] === 'AND') {
+        result = result && conditions[i + 1];
+      } else {
+        result = result || conditions[i + 1];
+      }
+    }
+
+    return result;
+  }
+
+  private evaluateSimpleCondition(
+    condition: string,
+    context: Record<string, unknown>
+  ): boolean {
+    const operators = ['<=', '>=', '<', '>', '!=', '='];
+    for (const op of operators) {
+      const idx = condition.indexOf(op);
+      if (idx !== -1) {
+        const left = condition.substring(0, idx).trim();
+        const right = condition.substring(idx + op.length).trim();
+        const leftValue = this.resolveValue(left, context);
+        const rightValue = this.resolveValue(right, context);
+
+        switch (op) {
+          case '=':
+            return leftValue === rightValue;
+          case '!=':
+            return leftValue !== rightValue;
+          case '<':
+            return Number(leftValue) < Number(rightValue);
+          case '>':
+            return Number(leftValue) > Number(rightValue);
+          case '<=':
+            return Number(leftValue) <= Number(rightValue);
+          case '>=':
+            return Number(leftValue) >= Number(rightValue);
+        }
+      }
+    }
+
+    const value = this.resolveValue(condition, context);
+    return Boolean(value);
+  }
+
+  private resolveValue(expr: string, context: Record<string, unknown>): unknown {
+    if (expr === 'true') return true;
+    if (expr === 'false') return false;
+    if (/^\d+(\.\d+)?$/.test(expr)) return parseFloat(expr);
+
+    const keys = expr.split('.');
+    let current: unknown = context;
+    for (const key of keys) {
+      if (current && typeof current === 'object') {
+        current = (current as Record<string, unknown>)[key];
+      } else {
+        return undefined;
+      }
+    }
+    return current;
+  }
+
+  private async checkCapabilityConstraints(
+    request: ModificationRequest
+  ): Promise<ConstraintCheckResult[]> {
+    const results: ConstraintCheckResult[] = [];
+
+    if (request.type !== 'tool_generation') {
+      return results;
+    }
+
+    const payload = request.payload as { category?: string; complexity?: number };
+
+    for (const constraint of this.constraints.capability) {
+      let satisfied = true;
+      let message: string | undefined;
+
+      if (payload.category) {
+        if (constraint.forbidden?.includes(payload.category)) {
+          satisfied = false;
+          message = `Category '${payload.category}' is forbidden`;
+        } else if (
+          constraint.allowed?.length &&
+          !constraint.allowed.includes(payload.category)
+        ) {
+          satisfied = false;
+          message = `Category '${payload.category}' is not in allowed list`;
+        }
+      }
+
+      if (
+        satisfied &&
+        constraint.maxComplexity &&
+        payload.complexity &&
+        payload.complexity > constraint.maxComplexity
+      ) {
+        satisfied = false;
+        message = `Complexity ${payload.complexity} exceeds max ${constraint.maxComplexity}`;
+      }
+
+      results.push({
+        constraintId: constraint.id,
+        constraintName: constraint.name,
+        satisfied,
+        severity: 'error',
+        message,
+      });
+    }
+
+    return results;
+  }
+
+  private async checkResourceConstraints(
+    request: ModificationRequest
+  ): Promise<ConstraintCheckResult[]> {
+    const results: ConstraintCheckResult[] = [];
+    const payload = request.payload as {
+      tokensUsed?: number;
+      cost?: number;
+      activeTools?: number;
+    };
+
+    for (const constraint of this.constraints.resource) {
+      let satisfied = true;
+      let message: string | undefined;
+
+      if (
+        constraint.maxTokensPerRun &&
+        payload.tokensUsed &&
+        payload.tokensUsed > constraint.maxTokensPerRun
+      ) {
+        satisfied = false;
+        message = `Tokens ${payload.tokensUsed} exceeds max ${constraint.maxTokensPerRun}`;
+      }
+
+      if (
+        satisfied &&
+        constraint.maxCostPerRun &&
+        payload.cost &&
+        payload.cost > constraint.maxCostPerRun
+      ) {
+        satisfied = false;
+        message = `Cost ${payload.cost} exceeds max ${constraint.maxCostPerRun}`;
+      }
+
+      if (
+        satisfied &&
+        constraint.maxToolsActive &&
+        payload.activeTools &&
+        payload.activeTools > constraint.maxToolsActive
+      ) {
+        satisfied = false;
+        message = `Active tools ${payload.activeTools} exceeds max ${constraint.maxToolsActive}`;
+      }
+
+      results.push({
+        constraintId: constraint.id,
+        constraintName: constraint.name,
+        satisfied,
+        severity: 'error',
+        message,
+      });
+    }
+
+    return results;
+  }
+
+  private async checkCustomConstraints(
+    request: ModificationRequest
+  ): Promise<ConstraintCheckResult[]> {
+    const results: ConstraintCheckResult[] = [];
+
+    for (const constraint of this.constraints.custom ?? []) {
+      let satisfied: boolean;
+      try {
+        satisfied = await constraint.predicate(request);
+      } catch {
+        satisfied = false;
+      }
+
+      results.push({
+        constraintId: constraint.id,
+        constraintName: constraint.name,
+        satisfied,
+        severity: 'error',
+        message: satisfied ? undefined : constraint.description,
+      });
+    }
+
+    return results;
+  }
+
+  addSafetyConstraint(constraint: SafetyConstraint): void {
+    const idx = this.constraints.safety.findIndex((c) => c.id === constraint.id);
+    if (idx >= 0) {
+      this.constraints.safety[idx] = constraint;
+    } else {
+      this.constraints.safety.push(constraint);
+    }
+  }
+
+  addCapabilityConstraint(constraint: CapabilityConstraint): void {
+    const idx = this.constraints.capability.findIndex((c) => c.id === constraint.id);
+    if (idx >= 0) {
+      this.constraints.capability[idx] = constraint;
+    } else {
+      this.constraints.capability.push(constraint);
+    }
+  }
+
+  addResourceConstraint(constraint: ResourceConstraint): void {
+    const idx = this.constraints.resource.findIndex((c) => c.id === constraint.id);
+    if (idx >= 0) {
+      this.constraints.resource[idx] = constraint;
+    } else {
+      this.constraints.resource.push(constraint);
+    }
+  }
+
+  addCustomConstraint(constraint: CustomConstraint): void {
+    if (!this.constraints.custom) {
+      this.constraints.custom = [];
+    }
+    const idx = this.constraints.custom.findIndex((c) => c.id === constraint.id);
+    if (idx >= 0) {
+      this.constraints.custom[idx] = constraint;
+    } else {
+      this.constraints.custom.push(constraint);
+    }
+  }
+
+  removeConstraint(id: string): boolean {
+    const safetyIdx = this.constraints.safety.findIndex((c) => c.id === id);
+    if (safetyIdx >= 0) {
+      this.constraints.safety.splice(safetyIdx, 1);
+      return true;
+    }
+
+    const capIdx = this.constraints.capability.findIndex((c) => c.id === id);
+    if (capIdx >= 0) {
+      this.constraints.capability.splice(capIdx, 1);
+      return true;
+    }
+
+    const resIdx = this.constraints.resource.findIndex((c) => c.id === id);
+    if (resIdx >= 0) {
+      this.constraints.resource.splice(resIdx, 1);
+      return true;
+    }
+
+    if (this.constraints.custom) {
+      const customIdx = this.constraints.custom.findIndex((c) => c.id === id);
+      if (customIdx >= 0) {
+        this.constraints.custom.splice(customIdx, 1);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  getConstraints(): ModificationConstraints {
+    return { ...this.constraints };
+  }
+}

package/src/constraints/rollback-manager.ts

@@ -0,0 +1,173 @@
+import { nanoid } from 'nanoid';
+import type {
+  ModificationCheckpoint,
+  AppliedModification,
+  AgentConfig,
+  Tool,
+} from '@cogitator-ai/types';
+
+export interface CheckpointStore {
+  save(checkpoint: ModificationCheckpoint): Promise<void>;
+  get(id: string): Promise<ModificationCheckpoint | null>;
+  list(agentId: string): Promise<ModificationCheckpoint[]>;
+  delete(id: string): Promise<boolean>;
+  prune(agentId: string, keepCount: number): Promise<number>;
+}
+
+export class InMemoryCheckpointStore implements CheckpointStore {
+  private checkpoints = new Map<string, ModificationCheckpoint>();
+  private agentIndex = new Map<string, Set<string>>();
+
+  async save(checkpoint: ModificationCheckpoint): Promise<void> {
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    if (!this.agentIndex.has(checkpoint.agentId)) {
+      this.agentIndex.set(checkpoint.agentId, new Set());
+    }
+    this.agentIndex.get(checkpoint.agentId)!.add(checkpoint.id);
+  }
+
+  async get(id: string): Promise<ModificationCheckpoint | null> {
+    return this.checkpoints.get(id) ?? null;
+  }
+
+  async list(agentId: string): Promise<ModificationCheckpoint[]> {
+    const ids = this.agentIndex.get(agentId);
+    if (!ids) return [];
+    return [...ids]
+      .map((id) => this.checkpoints.get(id)!)
+      .filter(Boolean)
+      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const checkpoint = this.checkpoints.get(id);
+    if (!checkpoint) return false;
+    this.checkpoints.delete(id);
+    this.agentIndex.get(checkpoint.agentId)?.delete(id);
+    return true;
+  }
+
+  async prune(agentId: string, keepCount: number): Promise<number> {
+    const checkpoints = await this.list(agentId);
+    const toDelete = checkpoints.slice(keepCount);
+    for (const cp of toDelete) {
+      await this.delete(cp.id);
+    }
+    return toDelete.length;
+  }
+}
+
+export interface RollbackManagerOptions {
+  maxCheckpoints: number;
+  checkpointStore?: CheckpointStore;
+}
+
+export interface CheckpointDiff {
+  configChanges: Array<{ key: string; before: unknown; after: unknown }>;
+  toolsAdded: string[];
+  toolsRemoved: string[];
+  modificationsApplied: AppliedModification[];
+}
+
+export class RollbackManager {
+  private maxCheckpoints: number;
+  private store: CheckpointStore;
+
+  constructor(options: RollbackManagerOptions) {
+    this.maxCheckpoints = options.maxCheckpoints;
+    this.store = options.checkpointStore ?? new InMemoryCheckpointStore();
+  }
+
+  async createCheckpoint(
+    agentId: string,
+    agentConfig: AgentConfig,
+    tools: Tool[],
+    modifications: AppliedModification[]
+  ): Promise<ModificationCheckpoint> {
+    const checkpoint: ModificationCheckpoint = {
+      id: `ckpt_${nanoid(12)}`,
+      agentId,
+      timestamp: new Date(),
+      agentConfig: { ...agentConfig },
+      tools: tools.map((t) => ({ ...t })),
+      modifications: [...modifications],
+    };
+
+    await this.store.save(checkpoint);
+    await this.store.prune(agentId, this.maxCheckpoints);
+
+    return checkpoint;
+  }
+
+  async getCheckpoint(id: string): Promise<ModificationCheckpoint | null> {
+    return this.store.get(id);
+  }
+
+  async listCheckpoints(agentId: string): Promise<ModificationCheckpoint[]> {
+    return this.store.list(agentId);
+  }
+
+  async getLatestCheckpoint(agentId: string): Promise<ModificationCheckpoint | null> {
+    const checkpoints = await this.store.list(agentId);
+    return checkpoints[0] ?? null;
+  }
+
+  async rollbackTo(
+    checkpointId: string
+  ): Promise<{ agentConfig: AgentConfig; tools: Tool[] } | null> {
+    const checkpoint = await this.store.get(checkpointId);
+    if (!checkpoint) return null;
+
+    return {
+      agentConfig: checkpoint.agentConfig as unknown as AgentConfig,
+      tools: checkpoint.tools.map((t) => ({ ...t })),
+    };
+  }
+
+  async rollbackToLatest(
+    agentId: string
+  ): Promise<{ agentConfig: AgentConfig; tools: Tool[] } | null> {
+    const latest = await this.getLatestCheckpoint(agentId);
+    if (!latest) return null;
+    return this.rollbackTo(latest.id);
+  }
+
+  compareCheckpoints(
+    checkpointA: ModificationCheckpoint,
+    checkpointB: ModificationCheckpoint
+  ): CheckpointDiff {
+    const configChanges: CheckpointDiff['configChanges'] = [];
+    const keysA = Object.keys(checkpointA.agentConfig) as (keyof AgentConfig)[];
+    const keysB = Object.keys(checkpointB.agentConfig) as (keyof AgentConfig)[];
+    const allKeys = new Set([...keysA, ...keysB]);
+
+    for (const key of allKeys) {
+      const valA = checkpointA.agentConfig[key];
+      const valB = checkpointB.agentConfig[key];
+      if (JSON.stringify(valA) !== JSON.stringify(valB)) {
+        configChanges.push({ key, before: valA, after: valB });
+      }
+    }
+
+    const toolsA = new Set(checkpointA.tools.map((t) => t.name));
+    const toolsB = new Set(checkpointB.tools.map((t) => t.name));
+
+    const toolsAdded = [...toolsB].filter((t) => !toolsA.has(t));
+    const toolsRemoved = [...toolsA].filter((t) => !toolsB.has(t));
+
+    const modsBefore = new Set(checkpointA.modifications.map((m) => m.id));
+    const modificationsApplied = checkpointB.modifications.filter(
+      (m) => !modsBefore.has(m.id)
+    );
+
+    return { configChanges, toolsAdded, toolsRemoved, modificationsApplied };
+  }
+
+  async pruneCheckpoints(agentId: string, keepCount?: number): Promise<number> {
+    return this.store.prune(agentId, keepCount ?? this.maxCheckpoints);
+  }
+
+  async deleteCheckpoint(id: string): Promise<boolean> {
+    return this.store.delete(id);
+  }
+}

package/src/constraints/safety-constraints.ts

@@ -0,0 +1,103 @@
+import type {
+  SafetyConstraint,
+  CapabilityConstraint,
+  ResourceConstraint,
+  ModificationConstraints,
+} from '@cogitator-ai/types';
+import { DEFAULT_SAFETY_CONSTRAINTS } from '@cogitator-ai/types';
+
+export { DEFAULT_SAFETY_CONSTRAINTS };
+
+export const DEFAULT_CAPABILITY_CONSTRAINTS: CapabilityConstraint[] = [
+  {
+    id: 'allowed_tool_categories',
+    name: 'Allowed Tool Categories',
+    type: 'tool_category',
+    description: 'Allowed and forbidden tool categories',
+    allowed: ['math', 'text', 'utility', 'data'],
+    forbidden: ['system', 'network', 'file'],
+    maxComplexity: 100,
+  },
+];
+
+export const DEFAULT_RESOURCE_CONSTRAINTS: ResourceConstraint[] = [
+  {
+    id: 'default_resource_limits',
+    name: 'Default Resource Limits',
+    resource: 'runtime',
+    description: 'Default runtime resource limits',
+    maxMemory: 128,
+    maxTokensPerRun: 100000,
+    maxCostPerRun: 1.0,
+    maxToolsActive: 20,
+  },
+];
+
+export function createDefaultConstraints(): ModificationConstraints {
+  return {
+    safety: [...DEFAULT_SAFETY_CONSTRAINTS],
+    capability: [...DEFAULT_CAPABILITY_CONSTRAINTS],
+    resource: [...DEFAULT_RESOURCE_CONSTRAINTS],
+    custom: [],
+  };
+}
+
+export function mergeSafetyConstraints(
+  base: SafetyConstraint[],
+  additions: SafetyConstraint[]
+): SafetyConstraint[] {
+  const result = new Map<string, SafetyConstraint>();
+  for (const c of base) {
+    result.set(c.id, c);
+  }
+  for (const c of additions) {
+    result.set(c.id, c);
+  }
+  return [...result.values()];
+}
+
+export function mergeCapabilityConstraints(
+  base: CapabilityConstraint[],
+  additions: CapabilityConstraint[]
+): CapabilityConstraint[] {
+  const result = new Map<string, CapabilityConstraint>();
+  for (const c of base) {
+    result.set(c.id, c);
+  }
+  for (const c of additions) {
+    result.set(c.id, c);
+  }
+  return [...result.values()];
+}
+
+export function mergeResourceConstraints(
+  base: ResourceConstraint[],
+  additions: ResourceConstraint[]
+): ResourceConstraint[] {
+  const result = new Map<string, ResourceConstraint>();
+  for (const c of base) {
+    result.set(c.id, c);
+  }
+  for (const c of additions) {
+    result.set(c.id, c);
+  }
+  return [...result.values()];
+}
+
+export function mergeConstraints(
+  base: ModificationConstraints,
+  additions: Partial<ModificationConstraints>
+): ModificationConstraints {
+  return {
+    safety: additions.safety
+      ? mergeSafetyConstraints(base.safety, additions.safety)
+      : base.safety,
+    capability: additions.capability
+      ? mergeCapabilityConstraints(base.capability, additions.capability)
+      : base.capability,
+    resource: additions.resource
+      ? mergeResourceConstraints(base.resource, additions.resource)
+      : base.resource,
+    custom: [...(base.custom ?? []), ...(additions.custom ?? [])],
+  };
+}