com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/scripts/validate-skills.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 51cc96af036a2ef2e635b1d39f1c667a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/validate-workflows.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * validate-workflows.js
+ *
+ * Validates GitHub Actions workflow files for problematic patterns, specifically:
+ * - Single-line multi-pattern `git add --renormalize` commands (FORBIDDEN)
+ * - `git add --renormalize` commands without existence checks
+ *
+ * @usage
+ *   node scripts/validate-workflows.js
+ *
+ * @exitcodes
+ *   0 - Success (no violations found)
+ *   1 - Validation failed (one or more violations found)
+ *
+ * @example
+ *   # Run from repository root
+ *   node scripts/validate-workflows.js
+ *
+ *   # Run in CI pipeline
+ *   node scripts/validate-workflows.js || exit 1
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const WORKFLOWS_DIR = path.join(__dirname, "..", ".github", "workflows");
+
+/**
+ * Represents a validation violation.
+ */
+class Violation {
+    constructor(file, line, pattern, message, severity = "error") {
+        this.file = file;
+        this.line = line;
+        this.pattern = pattern;
+        this.message = message;
+        this.severity = severity;
+    }
+
+    toString() {
+        const prefix = this.severity === "error" ? "ERROR" : "WARN";
+        return `[${prefix}] ${this.file}:${this.line}: ${this.message}\n  Pattern: ${this.pattern}`;
+    }
+}
+
+/**
+ * Checks if a line contains a problematic single-line multi-pattern renormalize command.
+ * These commands fail with exit code 128 if any pattern matches no files.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line contains a forbidden pattern
+ */
+function isForbiddenRenormalizePattern(line) {
+    // Match lines that have git add --renormalize with multiple file patterns
+    // Forbidden: git add --renormalize -- '*.md' '*.json' '*.yml'
+    // Allowed: git add --renormalize -- "*.$ext" "**/*.$ext" (single extension via variable)
+
+    const trimmed = line.trim();
+
+    // Must contain git add --renormalize
+    if (!trimmed.includes("git add") || !trimmed.includes("--renormalize")) {
+        return false;
+    }
+
+    // Skip lines that use shell variable expansion (part of a loop)
+    if (trimmed.includes("$ext") || trimmed.includes("${ext}")) {
+        return false;
+    }
+
+    // Skip lines that target a single specific file (e.g., '.config/dotnet-tools.json')
+    // These are safe because the file definitely exists or the step would have failed earlier
+    const singleFilePattern = /git add --renormalize\s+--\s+'[^'*?]+'/;
+    if (singleFilePattern.test(trimmed)) {
+        return false;
+    }
+
+    // Count distinct file extension patterns (*.ext or **/*.ext)
+    // Use a Set to count unique extensions
+    const extensionPatterns = trimmed.match(/\*\.(\w+)/g) || [];
+    const uniqueExtensions = new Set(
+        extensionPatterns.map((p) => p.replace("*.", ""))
+    );
+
+    // If there are multiple unique extensions on one line, it's forbidden
+    return uniqueExtensions.size > 1;
+}
+
+/**
+ * Checks if a renormalize command is properly guarded by an existence check.
+ * The existence check should be in a preceding line within the same block.
+ *
+ * @param {string[]} lines - All lines of the file
+ * @param {number} lineIndex - Index of the renormalize line
+ * @returns {boolean} True if properly guarded
+ */
+function hasExistenceCheck(lines, lineIndex) {
+    // Look backwards for an existence check pattern
+    // Pattern: if git ls-files "*.ext" | grep -q .; then
+    // or: if git ls-files "*.$ext" | grep -q .; then
+    const lookbackLines = 5;
+    const startIndex = Math.max(0, lineIndex - lookbackLines);
+
+    for (let i = lineIndex - 1; i >= startIndex; i--) {
+        const line = lines[i];
+        if (
+            line.includes("git ls-files") &&
+            line.includes("grep -q") &&
+            (line.includes("then") || lines[i + 1]?.includes("then"))
+        ) {
+            return true;
+        }
+        // Also check for a for-loop with if-check pattern
+        if (line.includes("for ext in") || line.includes("for EXT in")) {
+            // Check if there's a git ls-files check between the for and the renormalize
+            for (let j = i + 1; j < lineIndex; j++) {
+                if (lines[j].includes("git ls-files") && lines[j].includes("grep -q")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Validates a single workflow file.
+ *
+ * @param {string} filePath - Absolute path to the workflow file
+ * @returns {Violation[]} Array of violations found
+ */
+function validateWorkflow(filePath) {
+    const violations = [];
+    const relativePath = path.relative(
+        path.join(__dirname, ".."),
+        filePath
+    );
+
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf8");
+    } catch (error) {
+        violations.push(
+            new Violation(relativePath, 0, "", `Failed to read file: ${error.message}`)
+        );
+        return violations;
+    }
+
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+
+        // Check for forbidden single-line multi-pattern renormalize
+        if (isForbiddenRenormalizePattern(line)) {
+            violations.push(
+                new Violation(
+                    relativePath,
+                    lineNumber,
+                    line.trim(),
+                    "FORBIDDEN: Single-line multi-pattern git add --renormalize. Use per-extension loop pattern instead.",
+                    "error"
+                )
+            );
+        }
+
+        // Check for unguarded renormalize commands (warning only for non-variable patterns)
+        if (
+            line.includes("git add") &&
+            line.includes("--renormalize") &&
+            !line.includes("$ext") &&
+            !line.includes("${ext}") &&
+            line.includes("*.")
+        ) {
+            if (!hasExistenceCheck(lines, index)) {
+                violations.push(
+                    new Violation(
+                        relativePath,
+                        lineNumber,
+                        line.trim(),
+                        "WARNING: git add --renormalize without existence check may fail if pattern matches no files.",
+                        "warning"
+                    )
+                );
+            }
+        }
+    });
+
+    return violations;
+}
+
+/**
+ * Main entry point.
+ */
+function main() {
+    console.log("Validating workflow files for git add --renormalize patterns...\n");
+
+    if (!fs.existsSync(WORKFLOWS_DIR)) {
+        console.log(`Workflows directory not found: ${WORKFLOWS_DIR}`);
+        console.log("Nothing to validate.");
+        process.exit(0);
+    }
+
+    const workflowFiles = fs.readdirSync(WORKFLOWS_DIR).filter((file) =>
+        file.endsWith(".yml") || file.endsWith(".yaml")
+    );
+
+    if (workflowFiles.length === 0) {
+        console.log("No workflow files found.");
+        process.exit(0);
+    }
+
+    console.log(`Found ${workflowFiles.length} workflow file(s)\n`);
+
+    const allViolations = [];
+
+    workflowFiles.forEach((file) => {
+        const filePath = path.join(WORKFLOWS_DIR, file);
+        const violations = validateWorkflow(filePath);
+        allViolations.push(...violations);
+    });
+
+    const errors = allViolations.filter((v) => v.severity === "error");
+    const warnings = allViolations.filter((v) => v.severity === "warning");
+
+    if (allViolations.length === 0) {
+        console.log("✅ All workflow files passed validation.\n");
+        console.log("No forbidden git add --renormalize patterns detected.");
+        process.exit(0);
+    }
+
+    if (errors.length > 0) {
+        console.log(`\n❌ Found ${errors.length} error(s):\n`);
+        errors.forEach((v) => console.log(v.toString() + "\n"));
+    }
+
+    if (warnings.length > 0) {
+        console.log(`\n⚠️  Found ${warnings.length} warning(s):\n`);
+        warnings.forEach((v) => console.log(v.toString() + "\n"));
+    }
+
+    console.log("\n--- Summary ---");
+    console.log(`Errors:   ${errors.length}`);
+    console.log(`Warnings: ${warnings.length}`);
+
+    if (errors.length > 0) {
+        console.log("\nValidation FAILED. Please fix the errors above.");
+        console.log(
+            "\nSee .llm/skills/github-actions/git-renormalize-patterns.md for the required pattern."
+        );
+        process.exit(1);
+    }
+
+    console.log("\nValidation passed with warnings.");
+    process.exit(0);
+}
+
+// Export for testing when required as a module
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        isForbiddenRenormalizePattern,
+        hasExistenceCheck,
+        Violation,
+    };
+}
+
+// Only run main when executed directly (not when required as a module)
+if (require.main === module) {
+    main();
+}

package/scripts/validate-workflows.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 82de48c78453c4664e68b53c1ba60704
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/wiki/__tests__/transform.test.js

@@ -0,0 +1,380 @@
+/**
+ * Test suite for wiki transformation functions
+ */
+
+const {
+    isExternalLink,
+    docsPathToWikiPage,
+    findMarkdownLinks,
+    CodeBlockTracker,
+    transformLine,
+    transformFile
+} = require('../transform-docs-to-wiki.js');
+
+describe('isExternalLink', () => {
+    test('identifies http links', () => {
+        expect(isExternalLink('http://example.com')).toBe(true);
+    });
+
+    test('identifies https links', () => {
+        expect(isExternalLink('https://example.com/path')).toBe(true);
+    });
+
+    test('identifies mailto links', () => {
+        expect(isExternalLink('mailto:test@example.com')).toBe(true);
+    });
+
+    test('identifies tel links', () => {
+        expect(isExternalLink('tel:+1234567890')).toBe(true);
+    });
+
+    test('identifies ftp links', () => {
+        expect(isExternalLink('ftp://files.example.com')).toBe(true);
+    });
+
+    test('identifies relative paths as internal', () => {
+        expect(isExternalLink('./file.md')).toBe(false);
+        expect(isExternalLink('../file.md')).toBe(false);
+        expect(isExternalLink('file.md')).toBe(false);
+    });
+
+    test('identifies absolute paths as internal', () => {
+        expect(isExternalLink('/docs/file.md')).toBe(false);
+    });
+});
+
+describe('docsPathToWikiPage', () => {
+    test('converts simple path', () => {
+        expect(docsPathToWikiPage('concepts/message-types.md')).toBe('Concepts-Message-Types');
+    });
+
+    test('converts nested path', () => {
+        expect(docsPathToWikiPage('getting-started/overview.md')).toBe('Getting-Started-Overview');
+    });
+
+    test('converts index.md to parent directory name', () => {
+        expect(docsPathToWikiPage('concepts/index.md')).toBe('Concepts');
+    });
+
+    test('converts nested index.md to parent path', () => {
+        expect(docsPathToWikiPage('advanced/topics/index.md')).toBe('Advanced-Topics');
+    });
+
+    test('converts root index.md to Home', () => {
+        expect(docsPathToWikiPage('index.md')).toBe('Home');
+    });
+
+    test('converts README.md to Home', () => {
+        expect(docsPathToWikiPage('README.md')).toBe('Home');
+    });
+
+    test('handles parent directory README reference', () => {
+        expect(docsPathToWikiPage('../README.md')).toBe('Home');
+    });
+
+    test('capitalizes each path segment', () => {
+        expect(docsPathToWikiPage('guides/testing.md')).toBe('Guides-Testing');
+    });
+
+    test('handles paths without .md extension', () => {
+        expect(docsPathToWikiPage('concepts/types')).toBe('Concepts-Types');
+    });
+});
+
+describe('CodeBlockTracker', () => {
+    let tracker;
+
+    beforeEach(() => {
+        tracker = new CodeBlockTracker();
+    });
+
+    test('tracks triple backtick code blocks', () => {
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('code here')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks code blocks with language', () => {
+        expect(tracker.processLine('```javascript')).toBe(true);
+        expect(tracker.processLine('const x = 1;')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks code blocks with csharp language', () => {
+        expect(tracker.processLine('```csharp')).toBe(true);
+        expect(tracker.processLine('public class Test {}')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks quadruple backtick code blocks', () => {
+        expect(tracker.processLine('````')).toBe(true);
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('nested')).toBe(true);
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('````')).toBe(false);
+    });
+
+    test('tracks tilde code blocks', () => {
+        expect(tracker.processLine('~~~')).toBe(true);
+        expect(tracker.processLine('code')).toBe(true);
+        expect(tracker.processLine('~~~')).toBe(false);
+    });
+
+    test('does not close backtick block with tildes', () => {
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('~~~')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('reset clears state', () => {
+        tracker.processLine('```');
+        expect(tracker.inCodeBlock).toBe(true);
+        tracker.reset();
+        expect(tracker.inCodeBlock).toBe(false);
+    });
+
+    test('handles indented code fences', () => {
+        expect(tracker.processLine('    ```python')).toBe(true);
+        expect(tracker.processLine('    print("hello")')).toBe(true);
+        expect(tracker.processLine('    ```')).toBe(false);
+    });
+});
+
+describe('findMarkdownLinks', () => {
+    test('finds simple link', () => {
+        const links = findMarkdownLinks('See [guide](guide.md) for more.');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('guide');
+        expect(links[0].href).toBe('guide.md');
+        expect(links[0].isImage).toBe(false);
+    });
+
+    test('finds multiple links', () => {
+        const links = findMarkdownLinks('[one](a.md) and [two](b.md)');
+        expect(links).toHaveLength(2);
+        expect(links[0].text).toBe('one');
+        expect(links[0].href).toBe('a.md');
+        expect(links[1].text).toBe('two');
+        expect(links[1].href).toBe('b.md');
+    });
+
+    test('finds image links', () => {
+        const links = findMarkdownLinks('![alt text](image.png)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('alt text');
+        expect(links[0].href).toBe('image.png');
+        expect(links[0].isImage).toBe(true);
+    });
+
+    test('finds links with anchors', () => {
+        const links = findMarkdownLinks('[section](page.md#heading)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('page.md#heading');
+    });
+
+    test('ignores links inside inline code', () => {
+        const links = findMarkdownLinks('Use `[link](file.md)` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('ignores links inside double-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ``[link](file.md)`` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('ignores links inside double-backtick with text before', () => {
+        const links = findMarkdownLinks('Some text ``[link](file.md)`` more text');
+        expect(links).toHaveLength(0);
+    });
+
+    test('finds real link after double-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ``code`` then [real](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('real');
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('ignores links inside triple-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ```[link](file.md)``` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles mixed single and double backtick code spans', () => {
+        const links = findMarkdownLinks('`single` and ``double [link](file.md)`` and [real](page.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('real');
+        expect(links[0].href).toBe('page.md');
+    });
+
+    test('handles unclosed multi-backtick delimiter', () => {
+        const links = findMarkdownLinks('Text ``unclosed [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('handles asymmetric backticks correctly', () => {
+        // Double open, single close - should not match, link should be found
+        const links = findMarkdownLinks('Text ``code` [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('finds links with nested brackets in text', () => {
+        const links = findMarkdownLinks('[[nested]](page.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('[nested]');
+    });
+
+    test('finds links with parentheses in href', () => {
+        const links = findMarkdownLinks('[link](page_(version).md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('page_(version).md');
+    });
+
+    test('returns empty array for no links', () => {
+        const links = findMarkdownLinks('No links here');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles escaped brackets', () => {
+        const links = findMarkdownLinks('\\[not a link\\](file.md)');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles empty code span before link', () => {
+        const links = findMarkdownLinks('`` `` then [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('link');
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('handles very long backtick sequences', () => {
+        const links = findMarkdownLinks('``````````[link](file.md)``````````');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles backticks at end of line with no close', () => {
+        const links = findMarkdownLinks('text with unclosed ``');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles backtick immediately before link', () => {
+        const links = findMarkdownLinks('`[link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('link');
+        expect(links[0].href).toBe('file.md');
+    });
+});
+
+describe('transformLine', () => {
+    test('transforms internal markdown link to wiki link', () => {
+        const result = transformLine('[Guide](guide.md)', 'index.md');
+        // When link text matches wiki page name, simple [[Page]] format is used
+        expect(result).toBe('[[Guide]]');
+    });
+
+    test('preserves external links', () => {
+        const result = transformLine('[GitHub](https://github.com)', 'index.md');
+        expect(result).toBe('[GitHub](https://github.com)');
+    });
+
+    test('preserves anchor-only links', () => {
+        const result = transformLine('[Section](#section)', 'index.md');
+        expect(result).toBe('[Section](#section)');
+    });
+
+    test('transforms links with anchors', () => {
+        const result = transformLine('[Topic](concepts/types.md#section)', 'index.md');
+        expect(result).toBe('[[Concepts-Types#section|Topic]]');
+    });
+
+    test('transforms relative paths correctly', () => {
+        // Note: Path resolution happens at a different level, '../index.md' becomes '..' page
+        const result = transformLine('[Back](../index.md)', 'concepts/types.md');
+        expect(result).toBe('[[..|Back]]');
+    });
+
+    test('handles multiple links in one line', () => {
+        const result = transformLine('[One](a.md) and [Two](b.md)', 'index.md');
+        expect(result).toContain('[[A|One]]');
+        expect(result).toContain('[[B|Two]]');
+    });
+
+    test('transforms image paths', () => {
+        const result = transformLine('![Image](images/diagram.png)', 'index.md');
+        expect(result).toBe('![Image](wiki-images/diagram.png)');
+    });
+
+    test('preserves external image links', () => {
+        const result = transformLine('![Badge](https://img.shields.io/badge.svg)', 'index.md');
+        expect(result).toBe('![Badge](https://img.shields.io/badge.svg)');
+    });
+
+    test('returns unchanged line with no links', () => {
+        const result = transformLine('Just some text', 'index.md');
+        expect(result).toBe('Just some text');
+    });
+});
+
+describe('transformFile', () => {
+    test('preserves code blocks', () => {
+        const content = `# Example
+
+\`\`\`markdown
+[This should not be transformed](link.md)
+\`\`\`
+
+[This should be transformed](link.md)`;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toContain('[This should not be transformed](link.md)');
+        expect(result).toContain('[[Link|This should be transformed]]');
+    });
+
+    test('handles multiple code blocks', () => {
+        const content = `[before](a.md)
+
+\`\`\`
+[inside1](b.md)
+\`\`\`
+
+[between](c.md)
+
+\`\`\`csharp
+[inside2](d.md)
+\`\`\`
+
+[after](e.md)`;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toContain('[[A|before]]');
+        expect(result).toContain('[inside1](b.md)');
+        expect(result).toContain('[[C|between]]');
+        expect(result).toContain('[inside2](d.md)');
+        expect(result).toContain('[[E|after]]');
+    });
+
+    test('preserves line structure', () => {
+        const content = `Line 1
+Line 2
+Line 3`;
+
+        const result = transformFile(content, 'index.md');
+        const lines = result.split('\n');
+        expect(lines).toHaveLength(3);
+    });
+
+    test('handles empty content', () => {
+        const result = transformFile('', 'index.md');
+        expect(result).toBe('');
+    });
+
+    test('handles content with only code blocks', () => {
+        const content = `\`\`\`
+code only
+\`\`\``;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toBe(content);
+    });
+});

package/scripts/wiki/__tests__/transform.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2b3c4d5e6f7890abcd1234567890abcd
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/wiki/__tests__.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1a2b3c4d5e6f7890abcd1234567890ab
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: