code-sentinel-mcp 0.1.0

package/build/analyzers/placeholders.d.ts

@@ -0,0 +1,2 @@
+import { Issue } from '../types.js';
+export declare function analyzePlaceholders(code: string, filename: string): Issue[];

package/build/analyzers/placeholders.js

@@ -0,0 +1,216 @@
+const placeholderPatterns = [
+    // TODO/FIXME comments
+    {
+        id: 'CS-PH001',
+        pattern: /\/\/\s*TODO(?::|\.|\s).*$/gim,
+        title: 'TODO Comment Found',
+        description: 'Incomplete work marker found in code.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Complete or remove the TODO before shipping.'
+    },
+    {
+        id: 'CS-PH002',
+        pattern: /\/\/\s*FIXME(?::|\.|\s).*$/gim,
+        title: 'FIXME Comment Found',
+        description: 'Known issue marker found - this should be fixed.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Fix the issue or create a ticket to track it.'
+    },
+    {
+        id: 'CS-PH003',
+        pattern: /\/\/\s*HACK(?::|\.|\s).*$/gim,
+        title: 'HACK Comment Found',
+        description: 'Workaround marker found - technical debt.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Document why the hack exists and plan to remove it.'
+    },
+    {
+        id: 'CS-PH004',
+        pattern: /\/\/\s*XXX(?::|\.|\s).*$/gim,
+        title: 'XXX Comment Found',
+        description: 'Attention marker found - requires review.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Address the flagged issue or remove the marker.'
+    },
+    // Lorem ipsum and dummy text
+    {
+        id: 'CS-PH010',
+        pattern: /lorem\s+ipsum/gi,
+        title: 'Lorem Ipsum Placeholder Text',
+        description: 'Placeholder text found - replace with real content.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Replace with actual content before release.'
+    },
+    {
+        id: 'CS-PH011',
+        pattern: /['"`](?:foo|bar|baz|qux|test|dummy|sample|example|placeholder)['"`]/gi,
+        title: 'Common Placeholder Value',
+        description: 'Generic placeholder value detected.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Replace with meaningful values.'
+    },
+    // Test/dummy data
+    {
+        id: 'CS-PH020',
+        pattern: /['"`]test@(?:test|example|dummy|sample)\.[a-z]+['"`]/gi,
+        title: 'Test Email Address',
+        description: 'Placeholder email found - may not be intended for production.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Remove or replace with proper configuration.'
+    },
+    {
+        id: 'CS-PH021',
+        pattern: /['"`](?:123|1234|12345|123456|password|admin|root|test)['"`]/gi,
+        title: 'Common Test Password/Value',
+        description: 'Potentially insecure placeholder password or test value.',
+        severity: 'high',
+        category: 'placeholder',
+        suggestion: 'Remove test credentials before deployment.'
+    },
+    {
+        id: 'CS-PH022',
+        pattern: /(?:localhost|127\.0\.0\.1):\d{4,5}/g,
+        title: 'Localhost URL in Code',
+        description: 'Hardcoded localhost URL may not work in production.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Use environment variables for URLs.'
+    },
+    {
+        id: 'CS-PH023',
+        pattern: /['"`](?:xxx|yyy|zzz|aaa|bbb|ccc)['"`]/gi,
+        title: 'Placeholder String Pattern',
+        description: 'Obvious placeholder pattern detected.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Replace with actual values.'
+    },
+    // Fake/test phone numbers
+    {
+        id: 'CS-PH030',
+        pattern: /['"`](?:\+1)?[\s-]?555[\s-]?\d{3}[\s-]?\d{4}['"`]/g,
+        title: 'Test Phone Number (555)',
+        description: 'The 555 prefix is reserved for fictional use.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Use proper phone number handling or config.'
+    },
+    {
+        id: 'CS-PH031',
+        pattern: /['"`](?:000[-\s]?00[-\s]?0000|111[-\s]?11[-\s]?1111|123[-\s]?45[-\s]?6789)['"`]/g,
+        title: 'Obviously Fake ID Number',
+        description: 'Placeholder ID number pattern detected.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Remove test data before production.'
+    },
+    // Incomplete implementations
+    {
+        id: 'CS-PH040',
+        pattern: /throw\s+new\s+Error\s*\(\s*['"`](?:not\s+implemented|todo|implement\s+me|coming\s+soon)['"`]\s*\)/gi,
+        title: 'Not Implemented Error',
+        description: 'Function explicitly marked as not implemented.',
+        severity: 'high',
+        category: 'placeholder',
+        suggestion: 'Implement the function or remove the dead code.'
+    },
+    {
+        id: 'CS-PH041',
+        pattern: /(?:return|=)\s*['"`](?:TBD|TBA|N\/A|pending|placeholder)['"`]/gi,
+        title: 'TBD/Placeholder Return Value',
+        description: 'Code returns a placeholder instead of real value.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Implement actual logic or handle the case properly.'
+    },
+    // Debug/test code
+    {
+        id: 'CS-PH050',
+        pattern: /console\.log\s*\(\s*['"`](?:debug|test|here|working|checkpoint|\d+)['"`]\s*\)/gi,
+        title: 'Debug Console.log',
+        description: 'Debug logging statement left in code.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Remove debug statements or use a proper logger.'
+    },
+    {
+        id: 'CS-PH051',
+        pattern: /debugger\s*;/g,
+        title: 'Debugger Statement',
+        description: 'Debugger statement will pause execution in browser.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Remove debugger statements before committing.'
+    },
+    {
+        id: 'CS-PH052',
+        pattern: /alert\s*\(\s*['"`](?:test|debug|here|working)['"`]\s*\)/gi,
+        title: 'Debug Alert',
+        description: 'Debug alert left in code.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Remove debug alerts.'
+    },
+    // Commented out code blocks
+    {
+        id: 'CS-PH060',
+        pattern: /\/\/\s*(?:const|let|var|function|class|if|for|while|return)\s+\w+/g,
+        title: 'Commented Out Code',
+        description: 'Code appears to be commented out rather than deleted.',
+        severity: 'low',
+        category: 'placeholder',
+        suggestion: 'Remove dead code - use version control to recover if needed.'
+    },
+    // Hardcoded test IDs
+    {
+        id: 'CS-PH070',
+        pattern: /['"`](?:test-id|test_id|testid|fake-id|temp-id)['"`]/gi,
+        title: 'Test ID in Code',
+        description: 'Hardcoded test ID found.',
+        severity: 'medium',
+        category: 'placeholder',
+        suggestion: 'Use proper ID generation or configuration.'
+    }
+];
+export function analyzePlaceholders(code, filename) {
+    const issues = [];
+    const lines = code.split('\n');
+    for (const patternDef of placeholderPatterns) {
+        patternDef.pattern.lastIndex = 0;
+        let match;
+        while ((match = patternDef.pattern.exec(code)) !== null) {
+            const beforeMatch = code.substring(0, match.index);
+            const lineNumber = beforeMatch.split('\n').length;
+            const lineContent = lines[lineNumber - 1] || '';
+            // Build verification with actual values substituted
+            let verification = patternDef.verification;
+            if (verification) {
+                verification = {
+                    ...verification,
+                    commands: verification.commands?.map(cmd => cmd.replace(/<filename>/g, filename))
+                };
+            }
+            issues.push({
+                id: patternDef.id,
+                category: patternDef.category,
+                severity: patternDef.severity,
+                title: patternDef.title,
+                description: patternDef.description,
+                line: lineNumber,
+                code: lineContent.trim(),
+                suggestion: patternDef.suggestion,
+                verification
+            });
+            if (!patternDef.pattern.global)
+                break;
+        }
+    }
+    return issues;
+}

package/build/analyzers/security.d.ts

@@ -0,0 +1,2 @@
+import { Issue } from '../types.js';
+export declare function analyzeSecurityIssues(code: string, filename: string): Issue[];

package/build/analyzers/security.js

@@ -0,0 +1,238 @@
+const securityPatterns = [
+    // Hardcoded secrets
+    {
+        id: 'CS-SEC001',
+        pattern: /(?:api[_-]?key|apikey|secret|password|passwd|pwd|token|auth[_-]?token|access[_-]?token|private[_-]?key)\s*[:=]\s*['"`][^'"`]{8,}['"`]/gi,
+        title: 'Hardcoded Secret Detected',
+        description: 'Sensitive credentials appear to be hardcoded in the source code.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Move secrets to environment variables or a secure vault.',
+        verification: {
+            status: 'needs_verification',
+            assumption: 'The matched string appears to be a real secret, not a placeholder or test value',
+            commands: [
+                'git log -p -S "<matched_value>" -- <filename>',
+                'grep -r "<matched_value>" .env* config/'
+            ],
+            instruction: 'Verify this is a real secret, not a placeholder like "your-api-key-here" or test data',
+            confirmIf: 'Value looks like a real credential (high entropy, no placeholder words)',
+            falsePositiveIf: 'Value contains words like "example", "test", "placeholder", "your-", "xxx", or is clearly dummy data'
+        }
+    },
+    {
+        id: 'CS-SEC002',
+        pattern: /(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36,}/g,
+        title: 'GitHub Token Detected',
+        description: 'A GitHub personal access token was found in the code.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Remove the token immediately and rotate it in GitHub settings.',
+        verification: {
+            status: 'needs_verification',
+            assumption: 'Token is real and may have been committed to git history',
+            commands: [
+                'git log -p -S "<matched_value>" --all',
+                'git ls-files <filename>'
+            ],
+            instruction: 'Check if token was ever committed. If in history, it must be rotated even if removed now',
+            confirmIf: 'Token pattern matches GitHub format (ghp_, gho_, etc.) and file is tracked',
+            falsePositiveIf: 'Token is in a test file with obviously fake data or documentation example'
+        }
+    },
+    {
+        id: 'CS-SEC003',
+        pattern: /sk-[A-Za-z0-9]{48,}/g,
+        title: 'OpenAI API Key Detected',
+        description: 'An OpenAI API key was found in the code.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Remove the key and rotate it in your OpenAI dashboard.',
+        verification: {
+            status: 'needs_verification',
+            assumption: 'Key is real and may have been committed to git history',
+            commands: [
+                'git log -p -S "sk-" --all -- <filename>',
+                'git ls-files <filename>'
+            ],
+            instruction: 'Check if key was ever committed. If in history, it must be rotated',
+            confirmIf: 'Key matches OpenAI format (sk- prefix, 48+ chars) and file is tracked',
+            falsePositiveIf: 'Key is in documentation as example or clearly marked as fake'
+        }
+    },
+    {
+        id: 'CS-SEC004',
+        pattern: /AKIA[0-9A-Z]{16}/g,
+        title: 'AWS Access Key Detected',
+        description: 'An AWS access key ID was found in the code.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Remove and rotate the AWS credentials immediately.',
+        verification: {
+            status: 'needs_verification',
+            assumption: 'Key is real and may have been committed to git history',
+            commands: [
+                'git log -p -S "AKIA" --all -- <filename>',
+                'git ls-files <filename>'
+            ],
+            instruction: 'Check if key was ever committed. AWS keys in git history are compromised',
+            confirmIf: 'Key matches AWS format (AKIA prefix, 16 chars) and file is tracked',
+            falsePositiveIf: 'Key is in documentation or test fixtures with fake data'
+        }
+    },
+    // SQL Injection
+    {
+        id: 'CS-SEC010',
+        pattern: /(?:execute|query|raw)\s*\(\s*['"`].*?\$\{.*?\}.*?['"`]\s*\)/gi,
+        title: 'Potential SQL Injection',
+        description: 'String interpolation in SQL query may allow injection attacks.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Use parameterized queries or prepared statements instead.'
+    },
+    {
+        id: 'CS-SEC011',
+        pattern: /(?:execute|query)\s*\(\s*['"`].*?\+.*?['"`]\s*\)/gi,
+        title: 'SQL Query String Concatenation',
+        description: 'Concatenating strings in SQL queries is vulnerable to injection.',
+        severity: 'high',
+        category: 'security',
+        suggestion: 'Use parameterized queries with placeholders.'
+    },
+    // XSS
+    {
+        id: 'CS-SEC020',
+        pattern: /innerHTML\s*=\s*(?!['"`]<)/g,
+        title: 'Potential XSS via innerHTML',
+        description: 'Setting innerHTML with dynamic content can lead to XSS.',
+        severity: 'high',
+        category: 'security',
+        suggestion: 'Use textContent or sanitize HTML before insertion.'
+    },
+    {
+        id: 'CS-SEC021',
+        pattern: /dangerouslySetInnerHTML/g,
+        title: 'React dangerouslySetInnerHTML Usage',
+        description: 'Using dangerouslySetInnerHTML can expose the app to XSS.',
+        severity: 'medium',
+        category: 'security',
+        suggestion: 'Ensure content is properly sanitized before rendering.'
+    },
+    // Insecure practices
+    {
+        id: 'CS-SEC030',
+        pattern: /eval\s*\(/g,
+        title: 'eval() Usage Detected',
+        description: 'eval() can execute arbitrary code and is a security risk.',
+        severity: 'high',
+        category: 'security',
+        suggestion: 'Avoid eval(). Use safer alternatives like JSON.parse().'
+    },
+    {
+        id: 'CS-SEC031',
+        pattern: /new\s+Function\s*\(/g,
+        title: 'Dynamic Function Constructor',
+        description: 'Creating functions from strings is similar to eval().',
+        severity: 'high',
+        category: 'security',
+        suggestion: 'Avoid dynamic function creation from user input.'
+    },
+    {
+        id: 'CS-SEC032',
+        pattern: /document\.write\s*\(/g,
+        title: 'document.write() Usage',
+        description: 'document.write() can overwrite the document and enable XSS.',
+        severity: 'medium',
+        category: 'security',
+        suggestion: 'Use DOM manipulation methods instead.'
+    },
+    // Crypto issues
+    {
+        id: 'CS-SEC040',
+        pattern: /(?:md5|sha1)\s*\(/gi,
+        title: 'Weak Hash Algorithm',
+        description: 'MD5 and SHA1 are cryptographically broken.',
+        severity: 'high',
+        category: 'security',
+        suggestion: 'Use SHA-256 or bcrypt for password hashing.'
+    },
+    {
+        id: 'CS-SEC041',
+        pattern: /Math\.random\s*\(\)/g,
+        title: 'Insecure Random for Security',
+        description: 'Math.random() is not cryptographically secure.',
+        severity: 'medium',
+        category: 'security',
+        suggestion: 'Use crypto.randomBytes() or crypto.getRandomValues().'
+    },
+    // Network
+    {
+        id: 'CS-SEC050',
+        pattern: /http:\/\/(?!localhost|127\.0\.0\.1)/g,
+        title: 'Insecure HTTP URL',
+        description: 'Using HTTP instead of HTTPS exposes data in transit.',
+        severity: 'medium',
+        category: 'security',
+        suggestion: 'Use HTTPS for all external URLs.'
+    },
+    {
+        id: 'CS-SEC051',
+        pattern: /rejectUnauthorized\s*:\s*false/g,
+        title: 'SSL Certificate Validation Disabled',
+        description: 'Disabling certificate validation enables MITM attacks.',
+        severity: 'critical',
+        category: 'security',
+        suggestion: 'Never disable SSL certificate validation in production.'
+    },
+    // CORS
+    {
+        id: 'CS-SEC060',
+        pattern: /Access-Control-Allow-Origin['":\s]+\*/g,
+        title: 'Wildcard CORS Origin',
+        description: 'Allowing all origins can expose the API to unauthorized access.',
+        severity: 'medium',
+        category: 'security',
+        suggestion: 'Specify allowed origins explicitly.'
+    }
+];
+export function analyzeSecurityIssues(code, filename) {
+    const issues = [];
+    const lines = code.split('\n');
+    for (const patternDef of securityPatterns) {
+        // Reset regex state
+        patternDef.pattern.lastIndex = 0;
+        let match;
+        while ((match = patternDef.pattern.exec(code)) !== null) {
+            // Find line number
+            const beforeMatch = code.substring(0, match.index);
+            const lineNumber = beforeMatch.split('\n').length;
+            const lineContent = lines[lineNumber - 1] || '';
+            const matchedValue = match[0];
+            // Build verification with actual values substituted
+            let verification = patternDef.verification;
+            if (verification) {
+                verification = {
+                    ...verification,
+                    commands: verification.commands?.map(cmd => cmd
+                        .replace(/<matched_value>/g, matchedValue.substring(0, 20) + '...')
+                        .replace(/<filename>/g, filename))
+                };
+            }
+            issues.push({
+                id: patternDef.id,
+                category: patternDef.category,
+                severity: patternDef.severity,
+                title: patternDef.title,
+                description: patternDef.description,
+                line: lineNumber,
+                code: lineContent.trim(),
+                suggestion: patternDef.suggestion,
+                verification
+            });
+            // Prevent infinite loops for patterns without global flag
+            if (!patternDef.pattern.global)
+                break;
+        }
+    }
+    return issues;
+}

package/build/analyzers/strengths.d.ts

@@ -0,0 +1,2 @@
+import { Strength } from '../types.js';
+export declare function analyzeStrengths(code: string, filename: string): Strength[];

package/build/analyzers/strengths.js

@@ -0,0 +1,169 @@
+const strengthPatterns = [
+    // TypeScript usage
+    {
+        id: 'CS-STR001',
+        pattern: /:\s*(?:string|number|boolean|void|never|unknown|null|undefined|\w+\[\]|Record<|Map<|Set<|Promise<)/g,
+        title: 'Strong Typing',
+        description: 'Explicit type annotations improve code safety and documentation.'
+    },
+    {
+        id: 'CS-STR002',
+        pattern: /interface\s+\w+\s*\{/g,
+        title: 'Interface Definitions',
+        description: 'Well-defined interfaces create clear contracts.'
+    },
+    {
+        id: 'CS-STR003',
+        pattern: /type\s+\w+\s*=\s*/g,
+        title: 'Type Aliases',
+        description: 'Type aliases improve code readability and reusability.'
+    },
+    // Error handling
+    {
+        id: 'CS-STR010',
+        pattern: /try\s*\{[\s\S]+?\}\s*catch\s*\([^)]+\)\s*\{[\s\S]+?\}/g,
+        title: 'Proper Try/Catch',
+        description: 'Structured error handling with meaningful catch blocks.'
+    },
+    {
+        id: 'CS-STR011',
+        pattern: /\.catch\s*\(\s*(?:error|err|e)\s*=>\s*\{[^}]+\}/g,
+        title: 'Promise Error Handling',
+        description: 'Promise chains have explicit error handling.'
+    },
+    {
+        id: 'CS-STR012',
+        pattern: /class\s+\w+Error\s+extends\s+Error/g,
+        title: 'Custom Error Classes',
+        description: 'Custom errors enable better error classification.'
+    },
+    // Documentation
+    {
+        id: 'CS-STR020',
+        pattern: /\/\*\*[\s\S]*?@(?:param|returns?|throws|example)[\s\S]*?\*\//g,
+        title: 'JSDoc Documentation',
+        description: 'Functions have proper JSDoc documentation.'
+    },
+    {
+        id: 'CS-STR021',
+        pattern: /\/\/\s+[A-Z][^.!?]*[.!?]\s*$/gm,
+        title: 'Meaningful Comments',
+        description: 'Code has explanatory comments in complete sentences.'
+    },
+    // Clean code patterns
+    {
+        id: 'CS-STR030',
+        pattern: /const\s+\w+\s*=/g,
+        title: 'Immutable Variables',
+        description: 'Using const by default prevents accidental reassignment.'
+    },
+    {
+        id: 'CS-STR031',
+        pattern: /(?:readonly|Object\.freeze|as\s+const)/g,
+        title: 'Immutability Patterns',
+        description: 'Code uses immutability patterns for data safety.'
+    },
+    {
+        id: 'CS-STR032',
+        pattern: /(?:private|protected|#\w+)/g,
+        title: 'Encapsulation',
+        description: 'Proper use of access modifiers for encapsulation.'
+    },
+    // Async patterns
+    {
+        id: 'CS-STR040',
+        pattern: /async\s+\w+\s*\([^)]*\)\s*(?::\s*Promise<[^>]+>)?/g,
+        title: 'Async/Await Usage',
+        description: 'Modern async/await syntax for readable asynchronous code.'
+    },
+    {
+        id: 'CS-STR041',
+        pattern: /Promise\.all\s*\(/g,
+        title: 'Parallel Promise Execution',
+        description: 'Using Promise.all for efficient parallel async operations.'
+    },
+    {
+        id: 'CS-STR042',
+        pattern: /Promise\.allSettled\s*\(/g,
+        title: 'Resilient Promise Handling',
+        description: 'Using allSettled handles both fulfilled and rejected promises.'
+    },
+    // Testing
+    {
+        id: 'CS-STR050',
+        pattern: /(?:describe|it|test|expect)\s*\(/g,
+        title: 'Test Coverage',
+        description: 'Code includes tests with standard testing patterns.'
+    },
+    {
+        id: 'CS-STR051',
+        pattern: /\.test\.|\.spec\.|__tests__/g,
+        title: 'Test Files Present',
+        description: 'Dedicated test files follow conventions.'
+    },
+    // Validation
+    {
+        id: 'CS-STR060',
+        pattern: /(?:z\.|yup\.|joi\.|validator\.)\w+/g,
+        title: 'Schema Validation',
+        description: 'Using validation libraries for input/data validation.'
+    },
+    {
+        id: 'CS-STR061',
+        pattern: /if\s*\(\s*!?\w+\s*(?:&&|\|\|)?\s*typeof\s+\w+/g,
+        title: 'Type Guards',
+        description: 'Runtime type checking before operations.'
+    },
+    // Modern JavaScript
+    {
+        id: 'CS-STR070',
+        pattern: /(?:\?\.|&&\s*\w+\?\.)/g,
+        title: 'Optional Chaining',
+        description: 'Using ?. for safe property access.'
+    },
+    {
+        id: 'CS-STR071',
+        pattern: /\?\?\s*(?![\[\{])/g,
+        title: 'Nullish Coalescing',
+        description: 'Using ?? for proper null/undefined handling.'
+    },
+    {
+        id: 'CS-STR072',
+        pattern: /\.\.\.\w+/g,
+        title: 'Spread Operator',
+        description: 'Using spread for immutable operations.'
+    },
+    // Environment handling
+    {
+        id: 'CS-STR080',
+        pattern: /process\.env\.\w+|import\.meta\.env\.\w+/g,
+        title: 'Environment Variables',
+        description: 'Configuration via environment variables.'
+    },
+    // Logging
+    {
+        id: 'CS-STR090',
+        pattern: /(?:logger|log)\.\w+\s*\(/g,
+        title: 'Structured Logging',
+        description: 'Using a logging library instead of console.log.'
+    }
+];
+export function analyzeStrengths(code, filename) {
+    const strengths = [];
+    const foundPatterns = new Set();
+    for (const patternDef of strengthPatterns) {
+        patternDef.pattern.lastIndex = 0;
+        const matches = code.match(patternDef.pattern);
+        if (matches && matches.length > 0 && !foundPatterns.has(patternDef.id)) {
+            foundPatterns.add(patternDef.id);
+            // Only report each strength once, with example count
+            strengths.push({
+                id: patternDef.id,
+                title: patternDef.title,
+                description: patternDef.description,
+                examples: matches.slice(0, 3).map(m => m.trim())
+            });
+        }
+    }
+    return strengths;
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};