create-principles-disciple 1.95.0 → 1.97.0

package/plugin/dist/core/evolution-migration.js

@@ -1,65 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { stableContentHash } from './evolution-reducer.js';
-import { SystemLogger } from './system-logger.js';
-function appendEvent(streamPath, event) {
-    fs.appendFileSync(streamPath, `${JSON.stringify(event)}\n`, 'utf8');
-}
-function loadImportedHashes(streamPath, workspaceDir) {
-    if (!fs.existsSync(streamPath))
-        return new Set();
-    const raw = fs.readFileSync(streamPath, 'utf8').trim();
-    if (!raw)
-        return new Set();
-    const hashes = new Set();
-    for (const line of raw.split('\n')) {
-        try {
-            const event = JSON.parse(line);
-            if (event.type !== 'legacy_import')
-                continue;
-            const hash = event.data.contentHash;
-            if (typeof hash === 'string')
-                hashes.add(hash);
-        }
-        catch (e) {
-            SystemLogger.log(workspaceDir, 'MIGRATION_WARN', `skip malformed line: ${String(e)}`);
-        }
-    }
-    return hashes;
-}
-export function migrateLegacyEvolutionData(workspaceDir) {
-    const streamPath = path.join(workspaceDir, 'memory', 'evolution.jsonl');
-    fs.mkdirSync(path.dirname(streamPath), { recursive: true });
-    const candidates = [
-        path.join(workspaceDir, 'memory', 'ISSUE_LOG.md'),
-        path.join(workspaceDir, 'memory', 'DECISIONS.md'),
-        path.join(workspaceDir, '.principles', 'PRINCIPLES.md'),
-    ];
-    const existingHashes = loadImportedHashes(streamPath, workspaceDir);
-    let importedEvents = 0;
-    for (const sourceFile of candidates) {
-        if (!fs.existsSync(sourceFile)) {
-            continue;
-        }
-        const content = fs.readFileSync(sourceFile, 'utf8').trim();
-        if (!content) {
-            continue;
-        }
-        const contentHash = stableContentHash(`${sourceFile}:${content}`);
-        if (existingHashes.has(contentHash)) {
-            continue;
-        }
-        appendEvent(streamPath, {
-            ts: new Date().toISOString(),
-            type: 'legacy_import',
-            data: {
-                sourceFile: path.relative(workspaceDir, sourceFile),
-                content,
-                contentHash,
-            },
-        });
-        importedEvents += 1;
-        existingHashes.add(contentHash);
-    }
-    return { importedEvents, streamPath };
-}

package/plugin/dist/core/risk-calculator.d.ts

@@ -1,22 +0,0 @@
-export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-export interface FileModification {
-    toolName: string;
-    params: Record<string, unknown>;
-}
-export declare function estimateLineChanges(modification: FileModification): number;
-export declare function assessRiskLevel(filePath: string, modification: FileModification, riskPaths: string[]): RiskLevel;
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export declare function getTargetFileLineCount(absoluteFilePath: string): number | null;
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export declare function calculatePercentageThreshold(targetLineCount: number, percentage: number, minLines: number, maxLines?: number): number;

package/plugin/dist/core/risk-calculator.js

@@ -1,88 +0,0 @@
-/* global NodeJS */
-import * as fs from 'fs';
-import { isRisky } from '../utils/io.js';
-export function estimateLineChanges(modification) {
-    const { toolName, params } = modification;
-    if (toolName === 'write_file' || toolName === 'write') {
-        const content = params.content || '';
-        return content.split('\n').length;
-    }
-    if (toolName === 'replace' || toolName === 'edit') {
-        const newContent = params.new_string || params.newText || '';
-        return newContent.split('\n').length;
-    }
-    if (toolName === 'apply_patch' || toolName === 'patch') {
-        const patch = params.patch || '';
-        // Rough estimate for patch files
-        return patch.split('\n').filter((l) => l.startsWith('+') || l.startsWith('-')).length;
-    }
-    if (toolName === 'delete_file') {
-        // Deleting a file is considered a significant change, but we don't know the size. 
-        // We'll treat it as a medium-to-large size change.
-        return 50;
-    }
-    return 0;
-}
-export function assessRiskLevel(filePath, modification, riskPaths) {
-    const isRiskPath = isRisky(filePath, riskPaths);
-    const estimatedLines = estimateLineChanges(modification);
-    if (isRiskPath) {
-        if (estimatedLines > 100)
-            return 'CRITICAL';
-        return 'HIGH';
-    }
-    else {
-        if (estimatedLines > 100)
-            return 'HIGH';
-        if (estimatedLines > 10)
-            return 'MEDIUM';
-        return 'LOW';
-    }
-}
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export function getTargetFileLineCount(absoluteFilePath) {
-    try {
-        if (!fs.existsSync(absoluteFilePath)) {
-            return null; // File genuinely doesn't exist
-        }
-        const stats = fs.statSync(absoluteFilePath);
-        if (!stats.isFile()) {
-            return null; // Not a regular file (directory, device, etc.)
-        }
-        const content = fs.readFileSync(absoluteFilePath, 'utf-8');
-        return content.split('\n').length;
-    }
-    catch (e) {
-        // Log error before falling back to null - this is intentional for security gates
-        const error = e instanceof Error ? e : new Error(String(e));
-        const errorCode = e.code;
-        console.error(`[PD:RISK_CALC] Failed to read file for line count: ${absoluteFilePath}`, {
-            code: errorCode,
-            message: error.message,
-        });
-        return null;
-    }
-}
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export function calculatePercentageThreshold(targetLineCount, percentage, minLines, maxLines) {
-    // Clamp percentage to valid range [0, 100]
-    const clampedPercentage = Math.max(0, Math.min(100, percentage));
-    const calculated = Math.round(targetLineCount * (clampedPercentage / 100));
-    let effectiveLimit = Math.max(calculated, minLines);
-    // Apply optional upper bound
-    if (maxLines !== undefined && maxLines > 0) {
-        effectiveLimit = Math.min(effectiveLimit, maxLines);
-    }
-    return effectiveLimit;
-}

package/plugin/dist/core/rule-host-helpers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export type { RuleHostHelpers } from '@principles/core/runtime-v2';
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-helpers.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-types.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export type { RuleHostInput, RuleHostDecision, RuleHostMeta, RuleHostResult, LoadedImplementation, } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-types.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export {};

package/plugin/dist/core/schema/db-types.d.ts

@@ -1,11 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-/** Minimal interface for better-sqlite3 Database instances. */
-export interface Db {
-    exec(_sql: string): unknown;
-    get<T = unknown>(_sql: string, ..._params: unknown[]): T | undefined;
-    run(_sql: string, ..._params: unknown[]): unknown;
-    close(): void;
-}

package/plugin/dist/core/schema/db-types.js

@@ -1,5 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-export {};

package/plugin/dist/core/schema/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';
-export type { Db } from './db-types.js';
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog, } from './migration-runner.js';

package/plugin/dist/core/schema/index.js

@@ -1,15 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';

package/plugin/dist/core/schema/migration-runner.d.ts

@@ -1,53 +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 { type DbType } from './schema-definitions.js';
-import type { Db } from './db-types.js';
-export declare class MigrationRunner {
-    private readonly db;
-    constructor(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[];
-    /**
-     * 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;
-    /**
-     * Get the current migration version.
-     * Returns '000' if no version is set (fresh database).
-     */
-    getCurrentVersion(): string;
-    /**
-     * Get all available migration info for a database type.
-     */
-    getMigrationInfo(migrations: Migration[], dbType: DbType): {
-        id: string;
-        name: string;
-        applied: boolean;
-    }[];
-    /**
-     * Rollback the latest migration (if down migration is defined).
-     */
-    rollback(migrations: Migration[], dbType: DbType): string | null;
-    private ensureVersionTable;
-    private setVersion;
-}
-/**
- * Factory: create a MigrationRunner and apply schema catalog for a given database.
- * This is the main entry point for database classes.
- */
-export declare function ensureDatabaseSchema(db: Db, dbType: DbType): void;
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog } from './schema-definitions.js';

package/plugin/dist/core/schema/migration-runner.js

@@ -1,170 +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 { getCatalog } from './schema-definitions.js';
-export class MigrationRunner {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Run all pending migrations for a given database type.
-     * @returns Array of migration names that were applied
-     */
-    runMigrations(migrations, _dbType) {
-        // 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 = [];
-        // 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) {
-        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() {
-        try {
-            const row = this.db.get('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, dbType) {
-        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, dbType) {
-        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
-    // -----------------------------------------------------------------------
-    ensureVersionTable() {
-        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('SELECT COUNT(*) as cnt FROM schema_version');
-        if (!count || count.cnt === 0) {
-            this.db.exec("INSERT INTO schema_version (version) VALUES ('000')");
-        }
-    }
-    setVersion(version) {
-        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, dbType) {
-    const runner = new MigrationRunner(db);
-    runner.applySchemaCatalog(dbType);
-}

package/plugin/dist/core/schema/migrations/001-init-trajectory.d.ts

@@ -1,6 +0,0 @@
-/**
- * Migration: Initialize trajectory.db tables
- * This creates all core event store tables.
- */
-import type { Migration } from '../migration-runner.js';
-export declare const migration: Migration;