principles-disciple 1.126.0 → 1.128.0

package/src/core/rule-implementation-runtime.ts

@@ -1,145 +0,0 @@
-import { nodeVm } from '../utils/node-vm-polyfill.js';
-import { spawnSync } from 'node:child_process';
-
-export interface RuleImplementationModuleExports {
-  meta?: unknown;
-  evaluate?: unknown;
-  /**
-   * Call evaluate(input, helpers) INSIDE the vm context with a time boundary.
-   *
-   * PRI-437: The evaluate() function extracted from a vm context executes in
-   * the vm realm, but a direct host-realm call has NO timeout protection —
-   * an infinite loop in RuleCode would hang the host process forever.
-   *
-   * callEvaluate runs the invocation inside the vm context via
-   * Script.runInContext({ timeout }), which terminates infinite loops.
-   *
-   * Throws on timeout, compilation error, or if evaluate is missing.
-   */
-  callEvaluate?: (input: unknown, helpers: unknown) => unknown;
-}
-
-/** Timeout (ms) for compiling RuleCode (defining evaluate + meta). */
-const COMPILE_TIMEOUT_MS = 1000;
-
-/** Timeout (ms) for executing evaluate(input, helpers) inside the vm. */
-const EVALUATE_PROCESS_TIMEOUT_MS = 3000;
-const EVALUATE_PROCESS_OUTPUT_BYTES = 1024 * 1024;
-
-const EVALUATION_PROCESS_SOURCE = String.raw`
-const vm = require('node:vm');
-try {
-  const workerData = JSON.parse(require('node:fs').readFileSync(0, 'utf8'));
-  const context = vm.createContext(Object.create(null));
-  new vm.Script(workerData.source, { filename: workerData.filename }).runInContext(context, { timeout: 1000 });
-  const input = workerData.input;
-  const helpers = Object.freeze({
-    isRiskPath: () => input.workspace.isRiskPath,
-    getToolName: () => input.action.toolName,
-    getEstimatedLineChanges: () => input.derived.estimatedLineChanges,
-    getBashRisk: () => input.derived.bashRisk,
-    hasPlanFile: () => input.workspace.hasPlanFile,
-    getPlanStatus: () => input.workspace.planStatus,
-    getEpTier: () => input.evolution.epTier,
-  });
-  context.__pdCallInput = input;
-  context.__pdCallHelpers = helpers;
-  const result = new vm.Script('__pdRuleModule.evaluate(__pdCallInput, __pdCallHelpers)', { filename: workerData.filename + '.call' })
-    .runInContext(context, { timeout: 1000 });
-  process.stdout.write(JSON.stringify({ ok: true, result }));
-} catch (error) {
-  process.stdout.write(JSON.stringify({ ok: false, error: String(error) }));
-  process.exitCode = 1;
-}
-`;
-
-function normalizeImplementationSource(sourceCode: string): string {
-  const withoutExports = sourceCode
-    .replace(/export\s+const\s+meta\s*=/, 'const meta =')
-    .replace(/export\s+function\s+evaluate\s*\(/, 'function evaluate(');
-
-  return `${withoutExports}
-globalThis.__pdRuleModule = {
-  meta: typeof meta === 'undefined' ? undefined : meta,
-  evaluate: typeof evaluate === 'undefined' ? undefined : evaluate,
-};`;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-export function loadRuleImplementationModule(
-  sourceCode: string,
-  filename: string,
-): RuleImplementationModuleExports {
-  const context = nodeVm.createContext(Object.create(null));
-  const script = new nodeVm.Script(normalizeImplementationSource(sourceCode), {
-    filename,
-  });
-
-  // Compile phase: define evaluate + meta (timeout-bounded)
-  script.runInContext(context, {
-    timeout: COMPILE_TIMEOUT_MS,
-    displayErrors: true,
-  });
-
-  const moduleExports = (context as { __pdRuleModule?: RuleImplementationModuleExports }).__pdRuleModule;
-  // Note: keep __pdRuleModule on the context so callEvaluate can reference it.
-  // We do NOT delete it here — it's needed for subsequent evaluate calls.
-
-  const hasEvaluate = typeof moduleExports?.evaluate === 'function';
-  const meta = moduleExports?.meta;
-
-  if (!hasEvaluate) {
-    // No evaluate function — return early with no callEvaluate
-    return { meta, evaluate: moduleExports?.evaluate };
-  }
-
-  // PRI-437: Create a context-aware caller that runs evaluate INSIDE the vm
-  // context with a time boundary. This terminates infinite loops and
-  // excessive computation that would otherwise hang the host process.
-  //
-  // The callEvaluate function:
-  //   1. Sets input and helpers as context globals (sandboxed)
-  //   2. Compiles a tiny call script
-  //   3. Runs it in the context with EVALUATE_TIMEOUT_MS
-  //   4. Cleans up globals
-  //   5. Returns the raw result (validation happens in the caller)
-  const normalizedSource = normalizeImplementationSource(sourceCode);
-  const callEvaluate = (input: unknown, _helpers: unknown): unknown => {
-    const child = spawnSync(process.execPath, [
-      '--max-old-space-size=32',
-      '-e',
-      EVALUATION_PROCESS_SOURCE,
-    ], {
-      input: JSON.stringify({ source: normalizedSource, filename, input }),
-      encoding: 'utf8',
-      timeout: EVALUATE_PROCESS_TIMEOUT_MS,
-      maxBuffer: EVALUATE_PROCESS_OUTPUT_BYTES,
-      windowsHide: true,
-    });
-    if (child.error) {
-      throw new Error(`RuleCode process failed: ${child.error.message}`);
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(child.stdout);
-    } catch {
-      const stderr = child.stderr.trim().slice(0, 500);
-      throw new Error(`RuleCode process exited without a valid result${stderr ? `: ${stderr}` : ''}`);
-    }
-    if (!isRecord(parsed) || !Object.hasOwn(parsed, 'ok') || parsed['ok'] !== true || !Object.hasOwn(parsed, 'result')) {
-      const reason = isRecord(parsed) && Object.hasOwn(parsed, 'error') && typeof parsed['error'] === 'string'
-        ? parsed['error'] : 'RuleCode process failed';
-      throw new Error(reason);
-    }
-    return parsed['result'];
-  };
-
-  return {
-    meta,
-    evaluate: moduleExports?.evaluate,
-    callEvaluate,
-  };
-}

package/src/core/runtime-v2-prompt-activation-reader.ts

@@ -1,114 +0,0 @@
-import { SqliteConnection, SqliteActivationStateStore, computeFeatureFlagsFromConfig, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
-import type { FeatureFlagsResult, ActivatedPrinciple, PromptActivationReaderResult } from '@principles/core/runtime-v2';
-import { loadPdConfigForPlugin } from './pd-config-loader.js';
-
-export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
-export type { ActivatedPrinciple, PromptActivationReaderResult };
-
-export interface PromptActivationReaderDeps {
-  logger?: { warn?: (msg: string) => void; info?: (msg: string) => void; error?: (msg: string) => void };
-}
-
-export class PromptActivationReader {
-  private readonly workspaceDir: string;
-  private readonly deps: PromptActivationReaderDeps;
-
-  constructor(workspaceDir: string, deps?: PromptActivationReaderDeps) {
-    this.workspaceDir = workspaceDir;
-    this.deps = deps ?? {};
-  }
-
-  async readActivatedPrinciples(): Promise<PromptActivationReaderResult> {
-    const warnings: string[] = [];
-    const principles: ActivatedPrinciple[] = [];
-
-    const flags = this.loadFeatureFlags();
-    const promptFlag = flags.flags['prompt'];
-    if (!promptFlag || !promptFlag.enabled) {
-      this.deps.logger?.info?.(`[PD:RuntimeV2] Prompt feature flag disabled — skipping Runtime V2 activation read`);
-      return { principles, warnings: ['prompt_feature_disabled'], source: 'runtime_v2' };
-    }
-
-    let sqliteConn: SqliteConnection | null = null;
-    try {
-      sqliteConn = new SqliteConnection(this.workspaceDir);
-      const store = new SqliteActivationStateStore(sqliteConn);
-
-      const allActivations = await store.listPromptActivations();
-      const promptActivations = filterPromptActivations(allActivations);
-
-      for (const activation of promptActivations) {
-        let artifactRow: unknown | null;
-        try {
-          artifactRow = this.queryArtifactRow(sqliteConn, activation.artifactId);
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          const warning = `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`;
-          warnings.push(warning);
-          this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
-          continue;
-        }
-
-        if (artifactRow === null) {
-          const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table_or_remove_stale_activation`;
-          warnings.push(warning);
-          this.deps.logger?.info?.(`[PD:RuntimeV2] ${warning}`);
-          continue;
-        }
-
-        const result = resolvePrincipleFromArtifact(artifactRow, activation);
-        if (result.ok) {
-          principles.push(result.principle);
-        } else {
-          warnings.push(result.warning);
-          this.deps.logger?.warn?.(`[PD:RuntimeV2] ${result.warning}`);
-        }
-      }
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      const warning = `activation_db_unreadable: ${msg}; nextAction=check_workspace_pd_state_db`;
-      warnings.push(warning);
-      this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
-    } finally {
-      try {
-        sqliteConn?.close();
-      } catch {
-        // best-effort
-      }
-    }
-
-    return { principles, warnings, source: 'runtime_v2' };
-  }
-
-  private queryArtifactRow(sqliteConn: SqliteConnection, artifactId: string): unknown | null {
-    try {
-      const db = sqliteConn.getDb();
-      const row = db.prepare(`
-        SELECT artifact_id, artifact_kind, content_json, validation_status
-        FROM pi_artifacts
-        WHERE artifact_id = ?
-      `).get(artifactId);
-      return row ?? null;
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      throw new Error(`artifact_query_failed: artifactId=${artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`);
-    }
-  }
-
-  /**
-   * PRI-305/PRI-307: Load feature flags from .pd/config.yaml instead of .pd/feature-flags.yaml.
-   * Uses the shared plugin config loader for consistency.
-   */
-  private loadFeatureFlags(): FeatureFlagsResult {
-    const result = loadPdConfigForPlugin(this.workspaceDir);
-    const flags = computeFeatureFlagsFromConfig(result.effective);
-
-    if (!result.ok) {
-      for (const err of result.errors) {
-        this.deps.logger?.warn?.(`[PD:RuntimeV2] Config error at ${err.path}: ${err.reason}`);
-      }
-    }
-
-    return flags;
-  }
-}

package/src/core/schema/migration-runner.ts

@@ -1,207 +0,0 @@
-/**
- * Migration Runner — Executes and tracks schema migrations.
- *
- * Each migration is versioned. The runner reads the current version from
- * the `schema_version` table and only executes migrations with higher IDs.
- *
- * Usage:
- *   const runner = new MigrationRunner(db);
- *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
- */
-
-import type { Migration } from './schema-definitions.js';
-import { getCatalog, type DbType } from './schema-definitions.js';
-import type { Db } from './db-types.js';
-
-export class MigrationRunner {
-  private readonly db: Db;
-
-  constructor(db: Db) {
-    this.db = db;
-  }
-
-  /**
-   * Run all pending migrations for a given database type.
-   * @returns Array of migration names that were applied
-   */
-  runMigrations(migrations: Migration[], _dbType: DbType): string[] {
-    // NOTE: _dbType is kept for API signature compatibility but migrations are pre-filtered by caller
-    void _dbType;
-    // Ensure schema_version table exists before anything else
-    this.ensureVersionTable();
-
-    const currentVersion = this.getCurrentVersion();
-    const applied: string[] = [];
-
-    // Filter to pending migrations (higher ID than current)
-    const pending = migrations
-      .filter(m => m.id > currentVersion)
-      .sort((a, b) => a.id.localeCompare(b.id));
-
-    for (const migration of pending) {
-       
-      console.log(`[MigrationRunner] Applying ${migration.id}-${migration.name}...`);
-      try {
-        migration.up(this.db);
-        this.setVersion(migration.id);
-        applied.push(`${migration.id}-${migration.name}`);
-      } catch (err) {
-        throw new Error(
-          `Migration ${migration.id}-${migration.name} failed: ${String(err)}`,
-          { cause: err }
-        );
-      }
-    }
-
-    if (applied.length > 0) {
-       
-      console.log(`[MigrationRunner] Applied ${applied.length} migration(s): ${applied.join(', ')}`);
-    }
-
-    return applied;
-  }
-
-  /**
-   * Apply all schema definitions (tables, indexes, views, FTS) for a database.
-   * This is a convenience method that creates everything from the schema catalog.
-   * Used for initial setup when no migrations exist yet.
-   */
-  applySchemaCatalog(dbType: DbType): void {
-    this.ensureVersionTable();
-
-    const catalog = getCatalog(dbType);
-
-    // Tables
-    for (const [key, table] of Object.entries(catalog.tables)) {
-      try {
-        this.db.exec(table.ddl);
-      } catch (err) {
-        throw new Error(`Failed to create table ${key}: ${String(err)}`, { cause: err });
-      }
-      // Indexes
-      for (const indexDdl of table.indexes ?? []) {
-        try {
-          this.db.exec(indexDdl);
-        } catch (err) {
-          throw new Error(`Failed to create index for ${key}: ${String(err)}`, { cause: err });
-        }
-      }
-    }
-
-    // Views
-    for (const [key, view] of Object.entries(catalog.views)) {
-      try {
-        this.db.exec(view.ddl);
-      } catch (err) {
-        throw new Error(`Failed to create view ${key}: ${String(err)}`, { cause: err });
-      }
-    }
-
-    // FTS5 virtual tables
-    for (const [key, fts] of Object.entries(catalog.fts)) {
-      try {
-        this.db.exec(fts.ddl);
-      } catch (err) {
-        throw new Error(`Failed to create FTS table ${key}: ${String(err)}`, { cause: err });
-      }
-    }
-  }
-
-  /**
-   * Get the current migration version.
-   * Returns '000' if no version is set (fresh database).
-   */
-  getCurrentVersion(): string {
-    try {
-      const row = this.db.get<{ version: string }>(
-        'SELECT version FROM schema_version ORDER BY version DESC LIMIT 1'
-      );
-      return row?.version ?? '000';
-    } catch {
-      return '000';
-    }
-  }
-
-  /**
-   * Get all available migration info for a database type.
-   */
-  getMigrationInfo(migrations: Migration[], dbType: DbType): {
-    id: string;
-    name: string;
-    applied: boolean;
-  }[] {
-    const currentVersion = this.getCurrentVersion();
-    return migrations
-      .filter(m => m.db === dbType)
-      .sort((a, b) => a.id.localeCompare(b.id))
-      .map(m => ({
-        id: m.id,
-        name: m.name,
-        applied: m.id <= currentVersion,
-      }));
-  }
-
-  /**
-   * Rollback the latest migration (if down migration is defined).
-   */
-  rollback(migrations: Migration[], dbType: DbType): string | null {
-    const currentVersion = this.getCurrentVersion();
-    if (currentVersion === '000') return null;
-
-    const migration = migrations.find(
-      m => m.db === dbType && m.id === currentVersion
-    );
-    if (!migration) return null;
-    if (!migration.down) {
-      throw new Error(`Migration ${migration.id}-${migration.name} has no down migration`);
-    }
-
-     
-    console.log(`[MigrationRunner] Rolling back ${migration.id}-${migration.name}...`);
-    migration.down(this.db);
-
-    // Set version to previous migration
-    const previousMigrations = migrations
-      .filter(m => m.db === dbType && m.id < currentVersion)
-      .sort((a, b) => b.id.localeCompare(a.id));
-    const newVersion = previousMigrations[0]?.id ?? '000';
-    this.setVersion(newVersion);
-
-     
-    console.log(`[MigrationRunner] Rolled back to ${newVersion}`);
-    return migration.id;
-  }
-
-  // -----------------------------------------------------------------------
-  // Private helpers
-  // -----------------------------------------------------------------------
-
-  private ensureVersionTable(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_version (
-        version TEXT NOT NULL DEFAULT '000'
-      )
-    `);
-    // Ensure at least one row exists
-    const count = this.db.get<{ cnt: number }>('SELECT COUNT(*) as cnt FROM schema_version');
-    if (!count || count.cnt === 0) {
-      this.db.exec("INSERT INTO schema_version (version) VALUES ('000')");
-    }
-  }
-
-  private setVersion(version: string): void {
-    this.db.exec(`UPDATE schema_version SET version = '${version}'`);
-  }
-}
-
-/**
- * Factory: create a MigrationRunner and apply schema catalog for a given database.
- * This is the main entry point for database classes.
- */
-export function ensureDatabaseSchema(db: Db, dbType: DbType): void {
-  const runner = new MigrationRunner(db);
-  runner.applySchemaCatalog(dbType);
-}
-
-// Re-export types
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog } from './schema-definitions.js';