stringray-ai 1.0.0

package/dist/plugin/state/state-manager.d.ts

@@ -0,0 +1,29 @@
+export interface StateManager {
+    get: <T>(key: string) => T | undefined;
+    set: <T>(key: string, value: T) => void;
+    clear: (key: string) => void;
+}
+export declare class StringRayStateManager implements StateManager {
+    private store;
+    private persistencePath;
+    private persistenceEnabled;
+    private writeQueue;
+    private initialized;
+    private earlyOperationsQueue;
+    constructor(persistencePath?: string, persistenceEnabled?: boolean);
+    private initializePersistence;
+    private persistToDisk;
+    private isSerializable;
+    private schedulePersistence;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    clear(key: string): void;
+    isPersistenceEnabled(): boolean;
+    getPersistenceStats(): {
+        enabled: boolean;
+        initialized: boolean;
+        keysInMemory: number;
+        pendingWrites: number;
+    };
+}
+//# sourceMappingURL=state-manager.d.ts.map

package/dist/plugin/state/state-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.d.ts","sourceRoot":"","sources":["../../../src/state/state-manager.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC;IACvC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACxC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAID,qBAAa,qBAAsB,YAAW,YAAY;IACxD,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,kBAAkB,CAAU;IACpC,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,oBAAoB,CAAgB;gBAEhC,eAAe,SAAoB,EAAE,kBAAkB,UAAO;YAM5D,qBAAqB;YA4DrB,aAAa;IAuB3B,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,mBAAmB;IAe3B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IASlC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAuBnC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IA6BxB,oBAAoB,IAAI,OAAO;IAK/B,mBAAmB,IAAI;QACrB,OAAO,EAAE,OAAO,CAAC;QACjB,WAAW,EAAE,OAAO,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB;CAQF"}

package/dist/plugin/state/state-manager.js

@@ -0,0 +1,153 @@
+import { frameworkLogger } from "../framework-logger.js";
+export class StringRayStateManager {
+    store = new Map();
+    persistencePath;
+    persistenceEnabled;
+    writeQueue = new Map();
+    initialized = false;
+    earlyOperationsQueue = []; // Queue keys that need persistence after init
+    constructor(persistencePath = ".opencode/state", persistenceEnabled = true) {
+        this.persistencePath = persistencePath;
+        this.persistenceEnabled = persistenceEnabled;
+        this.initializePersistence();
+    }
+    async initializePersistence() {
+        if (!this.persistenceEnabled) {
+            this.initialized = true;
+            return;
+        }
+        try {
+            const fs = await import("fs");
+            const path = await import("path");
+            // Ensure persistence directory exists
+            const dir = path.dirname(this.persistencePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Load existing state from disk
+            if (fs.existsSync(this.persistencePath)) {
+                const data = fs.readFileSync(this.persistencePath, "utf8");
+                const parsed = JSON.parse(data);
+                for (const [key, value] of Object.entries(parsed)) {
+                    this.store.set(key, value);
+                }
+                frameworkLogger.log("state-manager", "persistence loaded", "success", {
+                    keysLoaded: Object.keys(parsed).length,
+                });
+            }
+            this.initialized = true;
+            // Process any early operations that were queued
+            if (this.persistenceEnabled && this.earlyOperationsQueue.length > 0) {
+                for (const key of this.earlyOperationsQueue) {
+                    this.schedulePersistence(key);
+                }
+                this.earlyOperationsQueue = [];
+                frameworkLogger.log("state-manager", "processed queued early operations", "info", {
+                    operationsProcessed: this.earlyOperationsQueue.length,
+                });
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("state-manager", "persistence initialization failed", "error", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Continue without persistence rather than failing
+            this.persistenceEnabled = false;
+            this.initialized = true;
+        }
+    }
+    async persistToDisk() {
+        if (!this.persistenceEnabled || !this.initialized)
+            return;
+        try {
+            const fs = await import("fs");
+            // Convert Map to object for JSON serialization
+            const data = {};
+            for (const [key, value] of this.store.entries()) {
+                // Only persist serializable data
+                if (this.isSerializable(value)) {
+                    data[key] = value;
+                }
+            }
+            fs.writeFileSync(this.persistencePath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            frameworkLogger.log("state-manager", "disk persistence failed", "error", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    isSerializable(value) {
+        try {
+            JSON.stringify(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    schedulePersistence(key) {
+        // Debounce writes to disk (100ms delay)
+        const existingTimeout = this.writeQueue.get(key);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        const timeout = setTimeout(() => {
+            this.persistToDisk();
+            this.writeQueue.delete(key);
+        }, 100);
+        this.writeQueue.set(key, timeout);
+    }
+    get(key) {
+        const value = this.store.get(key);
+        frameworkLogger.log("state-manager", "get operation", "info", {
+            key,
+            hasValue: value !== undefined,
+        });
+        return value;
+    }
+    set(key, value) {
+        // Store in memory immediately, even if persistence isn't ready yet
+        this.store.set(key, value);
+        // If initialized, schedule persistence
+        if (this.initialized && this.persistenceEnabled) {
+            this.schedulePersistence(key);
+        }
+        else if (!this.initialized) {
+            // Queue for persistence once initialized
+            if (!this.earlyOperationsQueue.includes(key)) {
+                this.earlyOperationsQueue.push(key);
+            }
+            frameworkLogger.log("state-manager", "set called before initialization, queued for persistence", "debug", { key });
+        }
+        frameworkLogger.log("state-manager", "set operation", "success", { key });
+    }
+    clear(key) {
+        // Ensure persistence is initialized
+        if (!this.initialized) {
+            frameworkLogger.log("state-manager", "clear called before initialization", "error", { key });
+            return;
+        }
+        const existed = this.store.has(key);
+        this.store.delete(key);
+        // Immediately persist the deletion
+        if (this.persistenceEnabled && existed) {
+            this.persistToDisk();
+        }
+        frameworkLogger.log("state-manager", "clear operation", existed ? "success" : "info", { key, existed });
+    }
+    // New method to check if persistence is enabled
+    isPersistenceEnabled() {
+        return this.persistenceEnabled;
+    }
+    // New method to get persistence stats
+    getPersistenceStats() {
+        return {
+            enabled: this.persistenceEnabled,
+            initialized: this.initialized,
+            keysInMemory: this.store.size,
+            pendingWrites: this.writeQueue.size,
+        };
+    }
+}
+//# sourceMappingURL=state-manager.js.map

package/dist/plugin/state/state-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.js","sourceRoot":"","sources":["../../../src/state/state-manager.ts"],"names":[],"mappings":"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"}

package/dist/plugin/state/state-types.d.ts

@@ -0,0 +1,6 @@
+export type StateValue = string | number | boolean | object | null;
+export interface StateTypes {
+    value: StateValue;
+    timestamp: number;
+}
+//# sourceMappingURL=state-types.d.ts.map

package/dist/plugin/state/state-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-types.d.ts","sourceRoot":"","sources":["../../../src/state/state-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;AAEnE,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/plugin/state/state-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-types.js.map

package/dist/plugin/state/state-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-types.js","sourceRoot":"","sources":["../../../src/state/state-types.ts"],"names":[],"mappings":""}

package/dist/plugin/utils/codex-parser.d.ts

@@ -0,0 +1,62 @@
+/**
+ * StringRay Codex Parser Utility
+ *
+ * Unified parsing utility for codex content in both JSON and Markdown formats.
+ * Provides consistent parsing across all components with format detection and validation.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { CodexContext } from "../context-loader";
+/**
+ * Content format detection result
+ */
+export interface FormatDetectionResult {
+    format: "json" | "markdown" | "unknown";
+    confidence: number;
+}
+/**
+ * Parsing result
+ */
+export interface ParsingResult {
+    success: boolean;
+    context?: CodexContext;
+    error?: string;
+    warnings: string[];
+}
+/**
+ * Detect content format
+ */
+export declare function detectContentFormat(content: string): FormatDetectionResult;
+/**
+ * Unified codex content parser
+ */
+export declare function parseCodexContent(content: string, sourcePath?: string): ParsingResult;
+/**
+ * Extract codex metadata from content (for compatibility with existing code)
+ */
+export declare function extractCodexMetadata(content: string): {
+    version: string;
+    termCount: number;
+};
+/**
+ * Pre-modification validation result
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate TypeScript code syntax
+ */
+export declare function validateTypeScriptSyntax(code: string, filePath?: string): Promise<ValidationResult>;
+/**
+ * Validate JSON syntax
+ */
+export declare function validateJsonSyntax(jsonString: string): ValidationResult;
+/**
+ * Comprehensive pre-modification validation
+ */
+export declare function validateBeforeModification(content: string, filePath: string): Promise<ValidationResult>;
+//# sourceMappingURL=codex-parser.d.ts.map

package/dist/plugin/utils/codex-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/codex-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,YAAY,EAAa,MAAM,mBAAmB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAuC1E;AA2MD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,aAAa,CA4Cf;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAoBA;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,CAAC,CAiE3B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAqBvE;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CAmC3B"}

package/dist/plugin/utils/codex-parser.js

@@ -0,0 +1,396 @@
+/**
+ * StringRay Codex Parser Utility
+ *
+ * Unified parsing utility for codex content in both JSON and Markdown formats.
+ * Provides consistent parsing across all components with format detection and validation.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+/**
+ * Detect content format
+ */
+export function detectContentFormat(content) {
+    if (!content || content.trim() === "") {
+        return { format: "unknown", confidence: 0 };
+    }
+    // Check for JSON format
+    const jsonConfidence = (() => {
+        try {
+            JSON.parse(content);
+            return 1.0;
+        }
+        catch {
+            return 0.0; // Not valid JSON
+        }
+    })();
+    // Check for Markdown format
+    const markdownConfidence = (() => {
+        const markdownIndicators = [
+            content.includes("**Version**:"),
+            content.includes("**Last Updated**:"),
+            content.includes("#### "), // Term headers
+            content.includes("## Overview"),
+            content.includes("## Critical Codex Terms"),
+            content.includes("#### 1."), // Common first term
+            content.includes("#### 2."), // Common second term
+        ];
+        return (markdownIndicators.filter(Boolean).length / markdownIndicators.length);
+    })();
+    // Prefer JSON as primary format, Markdown as fallback
+    if (jsonConfidence >= 0.5) {
+        return { format: "json", confidence: jsonConfidence };
+    }
+    else if (markdownConfidence > 0.1) {
+        return { format: "markdown", confidence: markdownConfidence };
+    }
+    return { format: "unknown", confidence: 0 };
+}
+/**
+ * Parse JSON format codex content
+ */
+function parseJsonContent(content) {
+    const warnings = [];
+    try {
+        const jsonData = JSON.parse(content);
+        // Convert terms object to Map
+        const termsMap = new Map();
+        if (jsonData.terms) {
+            Object.entries(jsonData.terms).forEach(([key, term]) => {
+                termsMap.set(parseInt(key, 10), term);
+            });
+        }
+        // Build context from JSON data
+        const context = {
+            version: jsonData.version || "1.2.20",
+            lastUpdated: jsonData.lastUpdated || new Date().toISOString(),
+            terms: termsMap,
+            interweaves: jsonData.interweaves || [],
+            lenses: jsonData.lenses || [],
+            principles: jsonData.principles || [],
+            antiPatterns: jsonData.antiPatterns || [],
+            validationCriteria: jsonData.validationCriteria || {},
+            frameworkAlignment: jsonData.frameworkAlignment || {},
+            errorPreventionTarget: jsonData.errorPreventionTarget || 0.996,
+        };
+        return { success: true, context, warnings };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to parse JSON content: ${error instanceof Error ? error.message : String(error)}`,
+            warnings,
+        };
+    }
+}
+/**
+ * Parse Markdown format codex content
+ */
+function parseMarkdownContent(content) {
+    const warnings = [];
+    try {
+        // Extract version
+        const versionMatch = content.match(/\*\*Version\*\*:\s*([^\n]+)/);
+        const version = versionMatch && versionMatch[1] ? versionMatch[1].trim() : "1.2.20";
+        // Extract last updated
+        const lastUpdatedMatch = content.match(/\*\*Last Updated\*\*:\s*([^\n]+)/);
+        const lastUpdated = lastUpdatedMatch && lastUpdatedMatch[1]
+            ? lastUpdatedMatch[1].trim()
+            : new Date().toISOString();
+        // Extract terms
+        const termsMap = new Map();
+        const termRegex = /^\s*#### (\d+)\.\s*([^\n]+)(?:\s*\n([\s\S]*?))?(?=^\s*#### \d+\.|^\s*## |$)/gm;
+        let match;
+        while ((match = termRegex.exec(content)) !== null) {
+            const termNumber = parseInt(match[1], 10);
+            const termTitle = match[2].trim();
+            const termDescription = (match[3] || "").trim();
+            // Infer category from term number
+            let category;
+            if (termNumber <= 10) {
+                category = "core";
+            }
+            else if (termNumber <= 20) {
+                category = "extended";
+            }
+            else if (termNumber <= 30) {
+                category = "architecture";
+            }
+            else {
+                category = "advanced";
+            }
+            // Check for zero tolerance indicators
+            const zeroTolerance = termDescription.toLowerCase().includes("zero-tolerance") ||
+                termDescription.toLowerCase().includes("blocking");
+            // Infer enforcement level
+            let enforcementLevel = "low";
+            if (zeroTolerance) {
+                enforcementLevel = "blocking";
+            }
+            else if (termDescription.toLowerCase().includes("blocking")) {
+                enforcementLevel = "blocking";
+            }
+            else if (termDescription.toLowerCase().includes("high")) {
+                enforcementLevel = "high";
+            }
+            else if (termDescription.toLowerCase().includes("medium")) {
+                enforcementLevel = "medium";
+            }
+            const term = {
+                number: termNumber,
+                description: termDescription,
+                category,
+                zeroTolerance,
+                enforcementLevel,
+            };
+            termsMap.set(termNumber, term);
+        }
+        // Extract interweaves, lenses, principles, anti-patterns
+        const interweaves = extractSectionList(content, "Interweaves");
+        const lenses = extractSectionList(content, "Lenses");
+        const principles = extractSectionList(content, "Principles");
+        const antiPatterns = extractSectionList(content, "Anti-Patterns");
+        // Extract validation criteria (simple presence check for now)
+        const validationCriteria = {};
+        const validationSections = [
+            "Code Completeness",
+            "Code Quality",
+            "Code Safety",
+        ];
+        validationSections.forEach((section) => {
+            validationCriteria[section] = content.includes(`### ${section}`);
+        });
+        // Extract framework alignment
+        const frameworkAlignment = {};
+        const frameworkMatch = content.match(/### Framework Alignment([\s\S]*?)(?=### |$)/);
+        if (frameworkMatch && frameworkMatch[1]) {
+            const alignmentText = frameworkMatch[1];
+            const alignmentRegex = /- \*\*([^:]+)\*\*:\s*([^\n]+)/g;
+            let alignmentMatch;
+            while ((alignmentMatch = alignmentRegex.exec(alignmentText)) !== null) {
+                if (alignmentMatch[1] && alignmentMatch[2]) {
+                    frameworkAlignment[alignmentMatch[1].trim()] =
+                        alignmentMatch[2].trim();
+                }
+            }
+        }
+        // Extract error prevention target
+        const targetMatch = content.match(/Error Prevention Target[^:]*:\s*([\d.]+)%?/);
+        const errorPreventionTarget = targetMatch && targetMatch[1] ? parseFloat(targetMatch[1]) / 100 : 0.996;
+        const context = {
+            version,
+            lastUpdated,
+            terms: termsMap,
+            interweaves,
+            lenses,
+            principles,
+            antiPatterns,
+            validationCriteria,
+            frameworkAlignment,
+            errorPreventionTarget,
+        };
+        return { success: true, context, warnings };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to parse Markdown content: ${error instanceof Error ? error.message : String(error)}`,
+            warnings,
+        };
+    }
+}
+/**
+ * Extract section list from markdown content
+ */
+function extractSectionList(content, sectionName) {
+    const sectionRegex = new RegExp(`### ${sectionName}([\\s\\S]*?)(?=### |$)`, "i");
+    const match = content.match(sectionRegex);
+    if (!match || !match[1])
+        return [];
+    const sectionContent = match[1];
+    const listRegex = /- (.+)$/gm;
+    const items = [];
+    let listMatch;
+    while ((listMatch = listRegex.exec(sectionContent)) !== null) {
+        if (listMatch[1]) {
+            items.push(listMatch[1].trim());
+        }
+    }
+    return items;
+}
+/**
+ * Unified codex content parser
+ */
+export function parseCodexContent(content, sourcePath) {
+    // Validate inputs
+    if (!content || content.trim() === "") {
+        return {
+            success: false,
+            error: "Invalid content provided: content cannot be empty",
+            warnings: [],
+        };
+    }
+    if (!sourcePath || sourcePath.trim() === "") {
+        return {
+            success: false,
+            error: "Invalid source path provided",
+            warnings: [],
+        };
+    }
+    // Detect format
+    const formatResult = detectContentFormat(content);
+    // For .json files, try JSON parsing regardless of detection result
+    const isJsonFile = sourcePath && sourcePath.endsWith(".json");
+    if (formatResult.format === "unknown" && !isJsonFile) {
+        return {
+            success: false,
+            error: `Unable to detect content format. Content appears to be neither valid JSON nor Markdown.`,
+            warnings: [`Format detection confidence: ${formatResult.confidence}`],
+        };
+    }
+    // Parse based on detected format or file extension
+    const result = formatResult.format === "json" || isJsonFile
+        ? parseJsonContent(content)
+        : parseMarkdownContent(content);
+    // Add source path to error if available
+    if (!result.success && sourcePath && result.error) {
+        result.error = `${result.error} (source: ${sourcePath})`;
+    }
+    return result;
+}
+/**
+ * Extract codex metadata from content (for compatibility with existing code)
+ */
+export function extractCodexMetadata(content) {
+    const result = parseCodexContent(content, "extract-metadata");
+    if (result.success && result.context) {
+        return {
+            version: result.context.version,
+            termCount: result.context.terms.size,
+        };
+    }
+    // Fallback to old logic for backward compatibility
+    try {
+        const jsonData = JSON.parse(content);
+        const version = jsonData.version || "1.2.20";
+        const termCount = jsonData.terms ? Object.keys(jsonData.terms).length : 0;
+        return { version, termCount };
+    }
+    catch (error) {
+        // Fallback for invalid content
+        return { version: "1.2.20", termCount: 0 };
+    }
+}
+/**
+ * Validate TypeScript code syntax
+ */
+export async function validateTypeScriptSyntax(code, filePath) {
+    const errors = [];
+    const warnings = [];
+    try {
+        // Use a simpler syntax check for now - basic bracket matching and common syntax issues
+        const bracketStack = [];
+        const brackets = { "{": "}", "[": "]", "(": ")" };
+        for (let i = 0; i < code.length; i++) {
+            const char = code.charAt(i);
+            if (char in brackets) {
+                bracketStack.push(char);
+            }
+            else if (Object.values(brackets).includes(char)) {
+                const lastOpen = bracketStack.pop();
+                if (!lastOpen || brackets[lastOpen] !== char) {
+                    errors.push(`Bracket mismatch at position ${i}: expected closing bracket for '${lastOpen || "none"}', found '${char}'`);
+                }
+            }
+            // Check for common syntax issues
+            if (char === ";" && i > 0 && code.charAt(i - 1) === ";") {
+                warnings.push(`Double semicolon at position ${i}`);
+            }
+        }
+        if (bracketStack.length > 0) {
+            errors.push(`Unclosed brackets: ${bracketStack.join(", ")}`);
+        }
+        // Check for basic import/export syntax
+        const importRegex = /^import\s+.*from\s+['"]/gm;
+        const exportRegex = /^export\s+/gm;
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            if (!match[0].includes("from")) {
+                errors.push(`Invalid import statement at line ${code.substring(0, match.index).split("\n").length}`);
+            }
+        }
+        while ((match = exportRegex.exec(code)) !== null) {
+            // Basic export validation - could be expanded
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    catch (error) {
+        errors.push(`Failed to validate TypeScript syntax: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            valid: false,
+            errors,
+            warnings,
+        };
+    }
+}
+/**
+ * Validate JSON syntax
+ */
+export function validateJsonSyntax(jsonString) {
+    const errors = [];
+    const warnings = [];
+    try {
+        JSON.parse(jsonString);
+        return {
+            valid: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+    catch (error) {
+        errors.push(`Invalid JSON syntax: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            valid: false,
+            errors,
+            warnings,
+        };
+    }
+}
+/**
+ * Comprehensive pre-modification validation
+ */
+export async function validateBeforeModification(content, filePath) {
+    const errors = [];
+    const warnings = [];
+    // Check file extension to determine validation type
+    const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+    const isJson = filePath.endsWith(".json");
+    if (isTypeScript) {
+        const tsResult = await validateTypeScriptSyntax(content, filePath);
+        errors.push(...tsResult.errors);
+        warnings.push(...tsResult.warnings);
+    }
+    else if (isJson) {
+        const jsonResult = validateJsonSyntax(content);
+        errors.push(...jsonResult.errors);
+        warnings.push(...jsonResult.warnings);
+    }
+    // Additional content validation
+    if (!content || content.trim() === "") {
+        errors.push("File content is empty or contains only whitespace");
+    }
+    // Check for potential security issues
+    if (content.includes("eval(") || content.includes("Function(")) {
+        warnings.push("Content contains potentially unsafe code execution patterns");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+//# sourceMappingURL=codex-parser.js.map