aisp-validator 0.1.0 → 0.2.1

package/bin/cli.js

@@ -9,7 +9,7 @@ import { readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 
 const HELP = `
-AISP Validator - Validate AISP 5.1 documents
+AISP Validator v0.2.1 - Validate AISP 5.1 documents
 
 Usage:
   aisp-validator <command> [file]
@@ -19,6 +19,7 @@ Commands:
   validate <file>   Validate an AISP document
   tier <file>       Get quality tier (⊘ to ◊⁺⁺)
   density <file>    Get density score (δ)
+  debug <file>      Show detailed density breakdown
   help              Show this help message
 
 Quality Tiers:
@@ -28,10 +29,18 @@ Quality Tiers:
   ◊⁻   Bronze     δ ≥ 0.20
   ⊘    Reject     δ < 0.20
 
+Density Formulas:
+  δ (semantic) = (blockScore × 0.4) + (bindingScore × 0.6)
+  ρ (pure)     = |AISP_symbols| ÷ |non_ws_tokens|
+
+  blockScore: Required blocks present (⟦Ω⟧, ⟦Σ⟧, ⟦Γ⟧, ⟦Λ⟧, ⟦Ε⟧)
+  bindingScore: Semantic operators (≜, ≔, ∀, ∃, λ, ⇒, ∈, etc.)
+  pureDensity: Ratio of AISP symbols to total tokens
+
 Examples:
   npx aisp-validator validate spec.aisp
   npx aisp-validator tier spec.aisp
-  npx aisp-validator spec.aisp
+  npx aisp-validator debug spec.aisp
 `;
 
 async function main() {
@@ -42,11 +51,16 @@ async function main() {
         process.exit(0);
     }
 
+    if (args[0] === '--version' || args[0] === '-v') {
+        console.log('aisp-validator v0.2.1');
+        process.exit(0);
+    }
+
     let command = args[0];
     let file = args[1];
 
     // If first arg is a file (no command), default to validate
-    if (command && !['validate', 'tier', 'density'].includes(command)) {
+    if (command && !['validate', 'tier', 'density', 'debug'].includes(command)) {
         file = command;
         command = 'validate';
     }
@@ -65,34 +79,69 @@ async function main() {
     try {
         await AISP.init();
         const content = await readFile(file, 'utf-8');
-        const result = AISP.validate(content);
 
         switch (command) {
-            case 'validate':
+            case 'validate': {
+                const result = AISP.validate(content);
                 if (result.valid) {
                     console.log(`✓ VALID`);
-                    console.log(`  Tier: ${result.tier}`);
-                    console.log(`  Density (δ): ${result.delta.toFixed(3)}`);
-                    console.log(`  Ambiguity: ${result.ambiguity.toFixed(3)}`);
+                    console.log(`  Tier: ${result.tier} ${result.tierName}`);
+                    console.log(`  Semantic (δ): ${result.delta.toFixed(3)}`);
+                    console.log(`  Pure (ρ):     ${result.pureDensity.toFixed(3)}`);
+                    console.log(`  Ambiguity:    ${result.ambiguity.toFixed(3)}`);
                     process.exit(0);
                 } else {
                     console.log(`✗ INVALID`);
                     console.log(`  Error: ${result.error || `Error code ${result.errorCode}`}`);
                     if (result.tier) {
-                        console.log(`  Tier: ${result.tier}`);
-                        console.log(`  Density (δ): ${result.delta.toFixed(3)}`);
+                        console.log(`  Tier: ${result.tier} ${result.tierName}`);
+                        console.log(`  Semantic (δ): ${result.delta.toFixed(3)}`);
+                        console.log(`  Pure (ρ):     ${result.pureDensity.toFixed(3)}`);
                     }
                     process.exit(1);
                 }
                 break;
+            }
 
-            case 'tier':
-                console.log(result.tier);
+            case 'tier': {
+                const result = AISP.validate(content);
+                console.log(`${result.tier} ${result.tierName}`);
                 break;
+            }
 
-            case 'density':
+            case 'density': {
+                const result = AISP.validate(content);
                 console.log(result.delta.toFixed(4));
                 break;
+            }
+
+            case 'debug': {
+                const debug = AISP.debug(content);
+                console.log(`\nAISP Density Debug`);
+                console.log(`==================`);
+                console.log(`\nTier: ${debug.tier} ${debug.tierName}`);
+                console.log(`Semantic (δ): ${debug.delta.toFixed(3)}`);
+                console.log(`Pure (ρ):     ${debug.pureDensity.toFixed(3)}`);
+                console.log(`\nSemantic Score Breakdown:`);
+                console.log(`  Block Score:   ${(debug.blockScore * 100).toFixed(1)}% (weight: 40%)`);
+                console.log(`  Binding Score: ${(debug.bindingScore * 100).toFixed(1)}% (weight: 60%)`);
+                console.log(`\nBlocks Found: ${debug.breakdown.blocksFound}/${debug.breakdown.blocksRequired}`);
+                console.log(`  Required: ⟦Ω⟧, ⟦Σ⟧, ⟦Γ⟧, ⟦Λ⟧, ⟦Ε⟧`);
+                console.log(`\nSemantic Operators: ${debug.breakdown.totalBindings}`);
+                console.log(`  ≜ definitions:  ${debug.breakdown.definitions}`);
+                console.log(`  ≔ assignments:  ${debug.breakdown.assignments}`);
+                console.log(`  ∀∃ quantifiers: ${debug.breakdown.quantifiers}`);
+                console.log(`  λ lambdas:      ${debug.breakdown.lambdas}`);
+                console.log(`  ⇒⇔ implications: ${debug.breakdown.implications}`);
+                console.log(`  ∈⊆∩∪ set ops:   ${debug.breakdown.setOps}`);
+                console.log(`\nPure Density Breakdown:`);
+                console.log(`  AISP Symbols: ${debug.breakdown.symbolCount}`);
+                console.log(`  Total Tokens: ${debug.breakdown.tokenCount}`);
+                console.log(`\nFormulas:`);
+                console.log(`  δ = (${debug.blockScore.toFixed(2)} × 0.4) + (${debug.bindingScore.toFixed(2)} × 0.6) = ${debug.delta.toFixed(3)}`);
+                console.log(`  ρ = ${debug.breakdown.symbolCount} ÷ ${debug.breakdown.tokenCount} = ${debug.pureDensity.toFixed(3)}`);
+                break;
+            }
         }
     } catch (err) {
         console.error(`Error: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aisp-validator",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AISP 5.1 document validator - validates AI Symbolic Protocol specifications with <2% ambiguity",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -10,6 +10,127 @@ import { dirname, join } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+/**
+ * AISP Symbol Set (Σ_512 subset for density calculation)
+ * Formal symbols that define AISP semantic content
+ */
+const AISP_SYMBOLS = [
+    // Block delimiters
+    '⟦', '⟧',
+    // Operators
+    '≜', '≔', '≡', '≢',
+    // Quantifiers
+    '∀', '∃',
+    // Lambda
+    'λ',
+    // Logic
+    '⇒', '⇔', '→', '↔', '∧', '∨', '¬', '⊕',
+    // Sets
+    '∈', '∉', '⊆', '⊇', '∩', '∪', '∅', '𝒫',
+    // Relations
+    '≤', '≥', '<', '>',
+    // Types
+    'ℕ', 'ℤ', 'ℝ', '𝔹', '𝕊',
+    // Document
+    '𝔸',
+    // Tier symbols
+    '◊', '⊘',
+    // Angle brackets (tuples)
+    '⟨', '⟩',
+    // Greek letters (commonly used)
+    'α', 'β', 'γ', 'δ', 'ε', 'φ', 'τ', 'ρ', 'Ω', 'Σ', 'Γ', 'Λ', 'Ε', 'Θ', 'Χ', 'Δ', 'Π'
+];
+
+/**
+ * Calculate pure density: |AISP_symbols| ÷ |non_ws_tokens|
+ * @param {string} text - AISP source
+ * @returns {object} { pureDensity, symbolCount, tokenCount }
+ */
+function calculatePureDensity(text) {
+    // Count AISP symbols
+    let symbolCount = 0;
+    for (const symbol of AISP_SYMBOLS) {
+        const matches = text.split(symbol).length - 1;
+        symbolCount += matches;
+    }
+
+    // Count non-whitespace tokens (split on whitespace, filter empty)
+    const tokens = text.split(/\s+/).filter(t => t.length > 0);
+    const tokenCount = tokens.length;
+
+    // Pure density: ratio of AISP symbols to tokens
+    const pureDensity = tokenCount > 0 ? symbolCount / tokenCount : 0;
+
+    return {
+        pureDensity,
+        symbolCount,
+        tokenCount
+    };
+}
+
+/**
+ * Calculate semantic density using Block Coverage + Binding Density
+ * δ = (blockScore × 0.4) + (bindingScore × 0.6)
+ * @param {string} text - AISP source
+ * @returns {object} { delta, blockScore, bindingScore, breakdown, pureDensity }
+ */
+function calculateSemanticDensity(text) {
+    // Required blocks present?
+    const blocks = ['⟦Ω', '⟦Σ', '⟦Γ', '⟦Λ', '⟦Ε'];
+    const blocksFound = blocks.filter(b => text.includes(b));
+    const blockScore = blocksFound.length / blocks.length;
+
+    // Binding density (semantic operators)
+    const definitions = (text.match(/≜/g) || []).length;
+    const assignments = (text.match(/≔/g) || []).length;
+    const quantifiers = (text.match(/[∀∃]/g) || []).length;
+    const lambdas = (text.match(/λ/g) || []).length;
+    const implications = (text.match(/[⇒⇔→↔]/g) || []).length;
+    const setOps = (text.match(/[∈⊆∩∪∅]/g) || []).length;
+
+    const totalBindings = definitions + assignments + quantifiers + lambdas + implications + setOps;
+    const bindingScore = Math.min(1, totalBindings / 20);
+
+    // Combined score (semantic delta)
+    const delta = (blockScore * 0.4) + (bindingScore * 0.6);
+
+    // Pure density (symbol/token ratio)
+    const pureResult = calculatePureDensity(text);
+
+    return {
+        delta,
+        blockScore,
+        bindingScore,
+        pureDensity: pureResult.pureDensity,
+        breakdown: {
+            blocksFound: blocksFound.length,
+            blocksRequired: blocks.length,
+            definitions,
+            assignments,
+            quantifiers,
+            lambdas,
+            implications,
+            setOps,
+            totalBindings,
+            symbolCount: pureResult.symbolCount,
+            tokenCount: pureResult.tokenCount
+        }
+    };
+}
+
+/**
+ * Get tier from delta value
+ * @param {number} delta
+ * @returns {object} { tier, tierValue, tierName }
+ */
+function getTierFromDelta(delta) {
+    if (delta >= 0.75) return { tier: '◊⁺⁺', tierValue: 4, tierName: 'Platinum' };
+    if (delta >= 0.60) return { tier: '◊⁺', tierValue: 3, tierName: 'Gold' };
+    if (delta >= 0.40) return { tier: '◊', tierValue: 2, tierName: 'Silver' };
+    if (delta >= 0.20) return { tier: '◊⁻', tierValue: 1, tierName: 'Bronze' };
+    return { tier: '⊘', tierValue: 0, tierName: 'Reject' };
+}
+
 const AISP = {
     _instance: null,
     _memory: null,
@@ -74,15 +195,40 @@ const AISP = {
             };
         }
 
-        const result = this._instance.aisp_validate(docId);
+        const parseResult = this._instance.aisp_validate(docId);
+
+        // Use semantic density calculation instead of WASM density
+        const densityResult = calculateSemanticDensity(source);
+        const tierResult = getTierFromDelta(densityResult.delta);
 
         return {
-            valid: result === 0,
-            tier: this._getTierSymbol(this._instance.aisp_tier(docId)),
-            tierValue: this._instance.aisp_tier(docId),
-            delta: this._instance.aisp_density(docId),
+            valid: parseResult === 0,
+            tier: tierResult.tier,
+            tierValue: tierResult.tierValue,
+            tierName: tierResult.tierName,
+            delta: densityResult.delta,
+            pureDensity: densityResult.pureDensity,
             ambiguity: this._instance.aisp_ambig(docId),
-            errorCode: result
+            errorCode: parseResult
+        };
+    },
+
+    /**
+     * Get detailed density breakdown for debugging
+     * @param {string} source - AISP source
+     * @returns {object} Detailed breakdown
+     */
+    debug(source) {
+        const densityResult = calculateSemanticDensity(source);
+        const tierResult = getTierFromDelta(densityResult.delta);
+
+        return {
+            ...tierResult,
+            delta: densityResult.delta,
+            pureDensity: densityResult.pureDensity,
+            blockScore: densityResult.blockScore,
+            bindingScore: densityResult.bindingScore,
+            breakdown: densityResult.breakdown
         };
     },
 
@@ -130,8 +276,19 @@ const AISP = {
     async validateFile(filePath) {
         const content = await readFile(filePath, 'utf-8');
         return this.validate(content);
+    },
+
+    /**
+     * Debug file - show density breakdown
+     * @param {string} filePath - Path to AISP file
+     * @returns {Promise<object>} Debug breakdown
+     */
+    async debugFile(filePath) {
+        const content = await readFile(filePath, 'utf-8');
+        return this.debug(content);
     }
 };
 
 export default AISP;
-export const { init, validate, isValid, getDensity, getTier, validateFile } = AISP;
+export const { init, validate, isValid, getDensity, getTier, validateFile, debug, debugFile } = AISP;
+export { calculateSemanticDensity, calculatePureDensity, getTierFromDelta, AISP_SYMBOLS };