signal-codec 1.0.0

package/dist/protocol-reporter.d.ts

@@ -0,0 +1,34 @@
+import { CheckResult, CompatibilityIssue } from './codec-verifier';
+/**
+ * Reporter for formatted output
+ */
+export declare class Reporter {
+    /**
+     * Print a colored header
+     */
+    private printHeader;
+    /**
+     * Print colored error message
+     */
+    private printError;
+    /**
+     * Print colored warning message
+     */
+    private printWarning;
+    /**
+     * Format codec analysis summary
+     */
+    formatSummary(result: CheckResult): string;
+    /**
+     * Format issues as a table
+     */
+    formatTable(issues: CompatibilityIssue[]): string;
+    /**
+     * Format detailed report with mythology terminology
+     */
+    formatDetailed(result: CheckResult): string;
+    /**
+     * Format JSON output
+     */
+    formatJson(result: CheckResult): string;
+}

package/dist/protocol-reporter.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reporter = void 0;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+/**
+ * Reporter for formatted output
+ */
+class Reporter {
+    /**
+     * Print a colored header
+     */
+    printHeader(text) {
+        return `\x1b[1m\x1b[36m${text}\x1b[0m`;
+    }
+    /**
+     * Print colored error message
+     */
+    printError(text) {
+        return `\x1b[31m✗\x1b[0m ${text}`;
+    }
+    /**
+     * Print colored warning message
+     */
+    printWarning(text) {
+        return `\x1b[33m⚠\x1b[0m ${text}`;
+    }
+    /**
+     * Format codec analysis summary
+     */
+    formatSummary(result) {
+        let output = '';
+        output += `\n◆ \x1b[1m\x1b[38;5;208mSIGNAL-CODEC\x1b[0m — Transmission Protocol Analysis\n`;
+        output += `────────────────────────────────────────────\n\n`;
+        output += `Archive Codec: ${result.projectLicense}\n`;
+        output += `Fragments Analyzed: ${result.totalDependencies}\n`;
+        output += `Codec Conflicts: ${result.issues.length}\n\n`;
+        if (result.issues.length === 0) {
+            output += `\x1b[32m✓\x1b[0m All fragments use interoperable codecs\n`;
+            return output;
+        }
+        output += `${this.printWarning(`${result.issues.length} transmission protocol conflict${result.issues.length > 1 ? 's' : ''} detected`)}\n`;
+        return output;
+    }
+    /**
+     * Format issues as a table
+     */
+    formatTable(issues) {
+        if (issues.length === 0) {
+            return '';
+        }
+        const table = new cli_table3_1.default({
+            head: ['Fragment', 'Codec', 'Conflict'].map((h) => `\x1b[1m${h}\x1b[0m`),
+            style: {
+                head: [],
+                border: ['cyan'],
+            },
+            colWidths: [25, 20, 50],
+            wordWrap: true,
+        });
+        for (const issue of issues) {
+            const severity = issue.severity === 'error'
+                ? `\x1b[31m${issue.severity}\x1b[0m`
+                : issue.severity === 'warning'
+                    ? `\x1b[33m${issue.severity}\x1b[0m`
+                    : `\x1b[36m${issue.severity}\x1b[0m`;
+            table.push([issue.package, issue.license, `[${severity}] ${issue.message}`]);
+        }
+        return table.toString();
+    }
+    /**
+     * Format detailed report with mythology terminology
+     */
+    formatDetailed(result) {
+        let output = this.formatSummary(result);
+        if (result.issues.length > 0) {
+            output += '\n' + this.printHeader('Codec Conflicts') + '\n\n';
+            output += this.formatTable(result.issues);
+            output += '\n';
+        }
+        const errorCount = result.summary.errors;
+        const warningCount = result.summary.warnings + result.summary.info;
+        if (errorCount > 0) {
+            output += `\n${this.printError(`${errorCount} incompatible codec${errorCount > 1 ? 's' : ''}`)}\n`;
+        }
+        if (warningCount > 0) {
+            output += `${this.printWarning(`${warningCount} unverified codec${warningCount > 1 ? 's' : ''}`)}\n`;
+        }
+        if (result.summary.errors === 0 && result.issues.length > 0) {
+            output += `\n${this.printWarning('Signal integrity compromised • Review required')}\n`;
+        }
+        else if (result.summary.errors === 0 && result.issues.length === 0) {
+            output += `Signal integrity maintained • Amulet Digital Archive Protocol\n`;
+        }
+        output += '\n';
+        return output;
+    }
+    /**
+     * Format JSON output
+     */
+    formatJson(result) {
+        return JSON.stringify(result, null, 2);
+    }
+}
+exports.Reporter = Reporter;

package/dist/protocol-reporter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/protocol-reporter.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const protocol_reporter_1 = require("./protocol-reporter");
+describe('Reporter', () => {
+    let reporter;
+    beforeEach(() => {
+        reporter = new protocol_reporter_1.Reporter();
+    });
+    describe('formatSummary', () => {
+        it('should include project license and count', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 10,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('MIT');
+            expect(output).toContain('10');
+        });
+        it('should show success for no issues', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('interoperable');
+        });
+        it('should warn when issues found', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [
+                    {
+                        package: 'test',
+                        license: 'GPL-3.0',
+                        severity: 'error',
+                        message: 'test',
+                    },
+                ],
+                summary: { errors: 1, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('transmission protocol conflict');
+        });
+    });
+    describe('formatTable', () => {
+        it('should return empty string for no issues', () => {
+            const output = reporter.formatTable([]);
+            expect(output).toBe('');
+        });
+        it('should create table with issues', () => {
+            const issues = [
+                {
+                    package: 'test-lib',
+                    license: 'GPL-3.0',
+                    severity: 'error',
+                    message: 'GPL not compatible with MIT',
+                },
+            ];
+            const output = reporter.formatTable(issues);
+            expect(output).toContain('test-lib');
+            expect(output).toContain('GPL-3.0');
+        });
+    });
+    describe('formatJson', () => {
+        it('should output valid JSON', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatJson(result);
+            const parsed = JSON.parse(output);
+            expect(parsed.projectLicense).toBe('MIT');
+            expect(parsed.totalDependencies).toBe(5);
+        });
+    });
+});

package/dist/reporter.d.ts

@@ -0,0 +1,34 @@
+import { CheckResult, CompatibilityIssue } from './checker';
+/**
+ * Reporter for formatted output
+ */
+export declare class Reporter {
+    /**
+     * Print a colored header
+     */
+    private printHeader;
+    /**
+     * Print colored error message
+     */
+    private printError;
+    /**
+     * Print colored warning message
+     */
+    private printWarning;
+    /**
+     * Format license summary
+     */
+    formatSummary(result: CheckResult): string;
+    /**
+     * Format issues as a table
+     */
+    formatTable(issues: CompatibilityIssue[]): string;
+    /**
+     * Format detailed report
+     */
+    formatDetailed(result: CheckResult): string;
+    /**
+     * Format JSON output
+     */
+    formatJson(result: CheckResult): string;
+}

package/dist/reporter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reporter = void 0;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+/**
+ * Reporter for formatted output
+ */
+class Reporter {
+    /**
+     * Print a colored header
+     */
+    printHeader(text) {
+        return `\x1b[1m\x1b[36m${text}\x1b[0m`;
+    }
+    /**
+     * Print colored error message
+     */
+    printError(text) {
+        return `\x1b[31m✗\x1b[0m ${text}`;
+    }
+    /**
+     * Print colored warning message
+     */
+    printWarning(text) {
+        return `\x1b[33m⚠\x1b[0m ${text}`;
+    }
+    /**
+     * Format license summary
+     */
+    formatSummary(result) {
+        let output = '';
+        output += `\n${this.printHeader('License Guard Report')}\n\n`;
+        output += `Project License: ${result.projectLicense}\n`;
+        output += `Dependencies Checked: ${result.totalDependencies}\n`;
+        output += `Issues Found: ${result.issues.length}\n\n`;
+        if (result.issues.length === 0) {
+            output += `\x1b[32m✓\x1b[0m All licenses are compatible!\n`;
+            return output;
+        }
+        output += `${this.printWarning(`${result.issues.length} potential compatibility issues found`)}\n`;
+        return output;
+    }
+    /**
+     * Format issues as a table
+     */
+    formatTable(issues) {
+        if (issues.length === 0) {
+            return '';
+        }
+        const table = new cli_table3_1.default({
+            head: ['Package', 'License', 'Issue'].map((h) => `\x1b[1m${h}\x1b[0m`),
+            style: {
+                head: [],
+                border: ['cyan'],
+            },
+            colWidths: [25, 20, 50],
+            wordWrap: true,
+        });
+        for (const issue of issues) {
+            const severity = issue.severity === 'error'
+                ? `\x1b[31m${issue.severity}\x1b[0m`
+                : issue.severity === 'warning'
+                    ? `\x1b[33m${issue.severity}\x1b[0m`
+                    : `\x1b[36m${issue.severity}\x1b[0m`;
+            table.push([issue.package, issue.license, `[${severity}] ${issue.message}`]);
+        }
+        return table.toString();
+    }
+    /**
+     * Format detailed report
+     */
+    formatDetailed(result) {
+        let output = this.formatSummary(result);
+        if (result.issues.length > 0) {
+            output += '\n' + this.printHeader('Compatibility Issues') + '\n\n';
+            output += this.formatTable(result.issues);
+            output += '\n';
+        }
+        if (result.summary.errors > 0) {
+            output += `\n${this.printError(`Found ${result.summary.errors} error(s)`)}\n`;
+        }
+        if (result.summary.warnings > 0) {
+            output += `${this.printWarning(`Found ${result.summary.warnings} warning(s)`)}\n`;
+        }
+        if (result.summary.info > 0) {
+            output += `${this.printWarning(`Found ${result.summary.info} info message(s)`)}\n`;
+        }
+        if (result.summary.errors === 0 && result.issues.length > 0) {
+            output += `\n${this.printWarning('Review warnings above for compliance')}\n`;
+        }
+        output += '\n';
+        return output;
+    }
+    /**
+     * Format JSON output
+     */
+    formatJson(result) {
+        return JSON.stringify(result, null, 2);
+    }
+}
+exports.Reporter = Reporter;

package/dist/reporter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reporter.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reporter_1 = require("./reporter");
+describe('Reporter', () => {
+    let reporter;
+    beforeEach(() => {
+        reporter = new reporter_1.Reporter();
+    });
+    describe('formatSummary', () => {
+        it('should include project license and count', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 10,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('MIT');
+            expect(output).toContain('10');
+        });
+        it('should show success for no issues', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('compatible');
+        });
+        it('should warn when issues found', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [
+                    {
+                        package: 'test',
+                        license: 'GPL-3.0',
+                        severity: 'error',
+                        message: 'test',
+                    },
+                ],
+                summary: { errors: 1, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatSummary(result);
+            expect(output).toContain('compatibility issues');
+        });
+    });
+    describe('formatTable', () => {
+        it('should return empty string for no issues', () => {
+            const output = reporter.formatTable([]);
+            expect(output).toBe('');
+        });
+        it('should create table with issues', () => {
+            const issues = [
+                {
+                    package: 'test-lib',
+                    license: 'GPL-3.0',
+                    severity: 'error',
+                    message: 'GPL not compatible with MIT',
+                },
+            ];
+            const output = reporter.formatTable(issues);
+            expect(output).toContain('test-lib');
+            expect(output).toContain('GPL-3.0');
+        });
+    });
+    describe('formatJson', () => {
+        it('should output valid JSON', () => {
+            const result = {
+                projectLicense: 'MIT',
+                totalDependencies: 5,
+                issues: [],
+                summary: { errors: 0, warnings: 0, info: 0 },
+            };
+            const output = reporter.formatJson(result);
+            const parsed = JSON.parse(output);
+            expect(parsed.projectLicense).toBe('MIT');
+            expect(parsed.totalDependencies).toBe(5);
+        });
+    });
+});

package/dist/scanner.d.ts

@@ -0,0 +1,39 @@
+export interface DependencyInfo {
+    name: string;
+    version: string;
+    license: string;
+    location: string;
+}
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    license?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Scanner for collecting dependency licenses
+ */
+export declare class Scanner {
+    /**
+     * Load package.json from a directory
+     */
+    loadPackageJson(projectRoot: string): PackageJson;
+    /**
+     * Extract all dependencies from package.json
+     */
+    extractDependencies(pkg: PackageJson): Record<string, string>;
+    /**
+     * Get license for a specific dependency
+     */
+    private getLicenseFromPackageJson;
+    /**
+     * Scan node_modules for all installed dependencies and their licenses
+     */
+    scanDependencies(projectRoot: string): DependencyInfo[];
+    /**
+     * Recursively scan for transitive dependencies
+     */
+    private scanTransitiveDeps;
+}

package/dist/scanner.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Scanner for collecting dependency licenses
+ */
+class Scanner {
+    /**
+     * Load package.json from a directory
+     */
+    loadPackageJson(projectRoot) {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error('package.json not found');
+        }
+        const content = fs.readFileSync(pkgPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    /**
+     * Extract all dependencies from package.json
+     */
+    extractDependencies(pkg) {
+        const deps = {};
+        if (pkg.dependencies) {
+            Object.assign(deps, pkg.dependencies);
+        }
+        if (pkg.devDependencies) {
+            Object.assign(deps, pkg.devDependencies);
+        }
+        return deps;
+    }
+    /**
+     * Get license for a specific dependency
+     */
+    getLicenseFromPackageJson(depPath) {
+        try {
+            const pkgPath = path.join(depPath, 'package.json');
+            if (!fs.existsSync(pkgPath)) {
+                return 'UNKNOWN';
+            }
+            const content = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            return pkg.license || 'UNKNOWN';
+        }
+        catch (_a) {
+            return 'UNKNOWN';
+        }
+    }
+    /**
+     * Scan node_modules for all installed dependencies and their licenses
+     */
+    scanDependencies(projectRoot) {
+        const nodeModulesPath = path.join(projectRoot, 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+            throw new Error('node_modules not found. Run npm install first.');
+        }
+        const dependencies = [];
+        const pkg = this.loadPackageJson(projectRoot);
+        const allDeps = this.extractDependencies(pkg);
+        for (const [name, version] of Object.entries(allDeps)) {
+            const depPath = path.join(nodeModulesPath, name);
+            const license = this.getLicenseFromPackageJson(depPath);
+            dependencies.push({
+                name,
+                version,
+                license,
+                location: depPath,
+            });
+        }
+        // Also scan transitive dependencies (nested in node_modules)
+        this.scanTransitiveDeps(nodeModulesPath, dependencies);
+        return dependencies;
+    }
+    /**
+     * Recursively scan for transitive dependencies
+     */
+    scanTransitiveDeps(nodeModulesPath, dependencies, visited = new Set()) {
+        if (!fs.existsSync(nodeModulesPath)) {
+            return;
+        }
+        const entries = fs.readdirSync(nodeModulesPath);
+        for (const entry of entries) {
+            if (entry.startsWith('.'))
+                continue;
+            const entryPath = path.join(nodeModulesPath, entry);
+            const stat = fs.statSync(entryPath);
+            if (!stat.isDirectory())
+                continue;
+            const pkgPath = path.join(entryPath, 'package.json');
+            if (!fs.existsSync(pkgPath))
+                continue;
+            const normalized = path.normalize(entryPath);
+            if (visited.has(normalized))
+                continue;
+            visited.add(normalized);
+            try {
+                const content = fs.readFileSync(pkgPath, 'utf-8');
+                const pkg = JSON.parse(content);
+                // Only add if not already scanned
+                if (!dependencies.some((d) => d.name === entry)) {
+                    dependencies.push({
+                        name: entry,
+                        version: pkg.version || 'unknown',
+                        license: pkg.license || 'UNKNOWN',
+                        location: entryPath,
+                    });
+                }
+            }
+            catch (_a) {
+                // Skip packages that can't be parsed
+            }
+        }
+    }
+}
+exports.Scanner = Scanner;

package/dist/scanner.test.d.ts

@@ -0,0 +1 @@
+export {};