@justscale/typescript 0.1.1

package/lib/lib.webworker.importscripts.d.ts

@@ -0,0 +1,21 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/////////////////////////////
+/// WorkerGlobalScope APIs
+/////////////////////////////
+// These are only available in a Web Worker
+declare function importScripts(...urls: string[]): void;

package/lib/lib.webworker.iterable.d.ts

@@ -0,0 +1,18 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+// This file's contents are now included in the main types file.
+// The file has been left for backward compatibility.

package/lib/logger.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Logger for JustScale TypeScript
+ *
+ * Provides structured logging with timestamps for debugging
+ * TypeScript/proto integration issues.
+ *
+ * Integrates with TypeScript's TSS_LOG environment variable:
+ *   TSS_LOG="-logToFile true -file /path/to/log.txt -level verbose"
+ *
+ * Or use our own:
+ *   JUSTSCALE_LOG=1 JUSTSCALE_LOG_LEVEL=debug
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.createLogger = createLogger;
+exports.logCall = logCall;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+// Parse TSS_LOG environment variable (TypeScript's native logging)
+function parseTssLog() {
+    const tssLog = process.env.TSS_LOG || '';
+    let file;
+    let level = 'info';
+    // Parse -file flag
+    const fileMatch = tssLog.match(/-file\s+(\S+)/);
+    if (fileMatch) {
+        file = fileMatch[1];
+    }
+    // Parse -level flag (verbose = debug, normal = info)
+    if (tssLog.includes('-level verbose')) {
+        level = 'debug';
+    }
+    return { file, level };
+}
+const tssConfig = parseTssLog();
+// Log file location - prefer TSS_LOG, fallback to our default
+const LOG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), '.justscale', 'logs');
+const LOG_FILE = tssConfig.file || (0, node_path_1.join)(LOG_DIR, 'typescript.log');
+// Minimum log level from environment (our var takes precedence)
+const MIN_LEVEL = process.env.JUSTSCALE_LOG_LEVEL || tssConfig.level;
+// Off by default — opt in with JUSTSCALE_LOG=1 or any TSS_LOG flag.
+// Header docstring describes the env-var contract; this gate enforces it.
+// Without this, every TS compile in any user's IDE writes to ~/.justscale/logs.
+const LOGGING_ENABLED = process.env.JUSTSCALE_LOG === '1' || Boolean(process.env.TSS_LOG);
+let initialized = false;
+function ensureLogDir() {
+    if (initialized)
+        return;
+    // Only create dir if using our default location (not TSS_LOG file)
+    if (!tssConfig.file) {
+        try {
+            (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+        }
+        catch {
+            // Ignore - logging is best-effort
+        }
+    }
+    initialized = true;
+}
+function formatTimestamp() {
+    const now = new Date();
+    return now.toISOString();
+}
+function formatData(data) {
+    if (data === undefined)
+        return '';
+    // Handle objects with stack traces specially
+    if (typeof data === 'object' && data !== null) {
+        const obj = data;
+        const parts = [];
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === 'stack' && typeof value === 'string') {
+                // Format stack traces with actual newlines and indentation
+                parts.push(`${key}:\n\t${value}`);
+            }
+            else if (typeof value === 'string') {
+                parts.push(`${key}=${value}`);
+            }
+            else {
+                parts.push(`${key}=${JSON.stringify(value)}`);
+            }
+        }
+        return ' ' + parts.join(' ');
+    }
+    return ` ${JSON.stringify(data)}`;
+}
+function formatMessage(level, component, message, data) {
+    const timestamp = formatTimestamp();
+    const dataStr = formatData(data);
+    return `[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${component}] ${message}${dataStr}\n`;
+}
+function createLogger(component) {
+    const log = (level, message, data) => {
+        if (!LOGGING_ENABLED)
+            return;
+        if (LOG_LEVELS[level] < LOG_LEVELS[MIN_LEVEL])
+            return;
+        ensureLogDir();
+        const formatted = formatMessage(level, component, message, data);
+        // Write to file
+        try {
+            (0, node_fs_1.appendFileSync)(LOG_FILE, formatted);
+        }
+        catch {
+            // Ignore write errors - logging is best-effort
+        }
+        // Also write to stderr for errors
+        if (level === 'error') {
+            process.stderr.write(`[justscale] ${formatted}`);
+        }
+    };
+    return {
+        debug: (message, data) => log('debug', message, data),
+        info: (message, data) => log('info', message, data),
+        warn: (message, data) => log('warn', message, data),
+        error: (message, data) => log('error', message, data),
+    };
+}
+// Main logger for the typescript.js module
+exports.logger = createLogger('typescript');
+// Helper to log function calls with timing
+function logCall(log, fnName, fn, args) {
+    const start = performance.now();
+    log.debug(`${fnName} called`, args);
+    try {
+        const result = fn();
+        const duration = (performance.now() - start).toFixed(2);
+        log.debug(`${fnName} completed in ${duration}ms`);
+        return result;
+    }
+    catch (err) {
+        const duration = (performance.now() - start).toFixed(2);
+        log.error(`${fnName} failed after ${duration}ms`, { error: String(err) });
+        throw err;
+    }
+}

package/lib/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@justscale/typescript-lib",
+  "version": "0.1.0",
+  "description": "JustScale TypeScript lib directory for IDE integration",
+  "main": "typescript.js",
+  "typescriptVersion": "6.0.3"
+}

package/lib/tsserver.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * JustScale TypeScript Server
+ *
+ * Drop-in replacement for tsserver that uses our patched TypeScript.
+ * This ensures proto support works in any IDE that loads this server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+const node_path_1 = require("node:path");
+const log = (0, logger_1.createLogger)('tsserver');
+log.info('JustScale TSServer starting...');
+log.info('Process args', { argv: process.argv });
+// Import our patched TypeScript to ensure patches are applied
+// before the real tsserver loads
+log.info('Loading patched TypeScript...');
+require('./typescript');
+log.info('Patched TypeScript loaded');
+function findTsServer() {
+    const __dirname = (0, node_path_1.dirname)(__filename);
+    const possiblePaths = [
+        // From lib/ directory, go up to find node_modules
+        (0, node_path_1.resolve)(__dirname, '../node_modules/typescript/lib/tsserver.js'),
+        (0, node_path_1.resolve)(__dirname, '../../node_modules/typescript/lib/tsserver.js'),
+        (0, node_path_1.resolve)(__dirname, '../../../node_modules/typescript/lib/tsserver.js'),
+        (0, node_path_1.resolve)(__dirname, '../../../../node_modules/typescript/lib/tsserver.js'),
+        (0, node_path_1.resolve)(__dirname, '../../../../../node_modules/typescript/lib/tsserver.js'),
+    ];
+    for (const p of possiblePaths) {
+        try {
+            require.resolve(p);
+            log.info('Found tsserver', { path: p });
+            return p;
+        }
+        catch {
+            log.debug('TSServer not at', { path: p });
+        }
+    }
+    // Last resort: try to resolve from node_modules
+    try {
+        const resolved = require.resolve('typescript/lib/tsserver.js');
+        log.info('Found tsserver via require.resolve', { path: resolved });
+        return resolved;
+    }
+    catch (err) {
+        log.error('Could not find tsserver', { error: String(err) });
+        const error = new Error('Could not find TypeScript tsserver. Make sure typescript is installed.');
+        error.cause = err;
+        throw error;
+    }
+}
+// Run tsserver
+const tsserverPath = findTsServer();
+log.info('Starting real tsserver', { path: tsserverPath });
+// The real tsserver.js will start the server when required
+require(tsserverPath);

package/lib/tsserverlibrary.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * JustScale TypeScript Server Library
+ *
+ * This module re-exports our patched TypeScript for IDE integration.
+ * JetBrains loads this when using our lib/ as the TypeScript SDK.
+ */
+const logger_1 = require("./logger");
+let filterUsingExportsDiagnostics = null;
+try {
+    const errors = require('../dist/compiler/errors.js');
+    filterUsingExportsDiagnostics = errors.filterUsingExportsDiagnostics;
+}
+catch { /* errors.js not available in all environments */ }
+const log = (0, logger_1.createLogger)('tsserverlibrary');
+log.info('JustScale TSServerLibrary loading...');
+// Re-export our patched TypeScript
+// This ensures JetBrains gets the proto-aware version
+const ts = require('./typescript');
+// Load the real tsserverlibrary to get ts.server
+const realTsServerLib = require('typescript/lib/tsserverlibrary');
+log.info('JustScale TSServerLibrary ready', { version: ts.version });
+// Import process analyzer dynamically
+let analyzeHandler = null;
+let formatErrorCode = null;
+try {
+    const analyzer = require('@justscale/typescript/api');
+    analyzeHandler = analyzer.analyzeHandler;
+    formatErrorCode = analyzer.formatErrorCode;
+    log.info('Process analyzer loaded');
+}
+catch (err) {
+    log.info('Process analyzer not available', { error: String(err) });
+}
+/**
+ * Check if a source file is a process file
+ */
+function isProcessFile(sourceFile) {
+    if (sourceFile.fileName.includes('.process.')) {
+        return true;
+    }
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            const moduleSpecifier = statement.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                if (moduleSpecifier.text === '@justscale/core/process') {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Get process-specific diagnostics for a source file.
+ */
+function getProcessDiagnostics(sourceFile, program) {
+    if (!analyzeHandler) {
+        return [];
+    }
+    const diagnostics = [];
+    const typeChecker = program.getTypeChecker();
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            const expr = node.expression;
+            if (ts.isIdentifier(expr) && expr.text === 'createProcess') {
+                const configArg = node.arguments[0];
+                if (configArg && ts.isObjectLiteralExpression(configArg)) {
+                    // Find handler
+                    for (const prop of configArg.properties) {
+                        if (ts.isMethodDeclaration(prop)) {
+                            if (ts.isIdentifier(prop.name) && prop.name.text === 'handler') {
+                                const analysis = analyzeHandler(prop, typeChecker);
+                                diagnostics.push(...analysis.diagnostics.map(d => ({
+                                    ...d,
+                                    messageText: formatDiagnosticMessage(d),
+                                })));
+                            }
+                        }
+                        else if (ts.isPropertyAssignment(prop)) {
+                            if (ts.isIdentifier(prop.name) && prop.name.text === 'handler') {
+                                if (ts.isFunctionExpression(prop.initializer) || ts.isArrowFunction(prop.initializer)) {
+                                    const analysis = analyzeHandler(prop.initializer, typeChecker);
+                                    diagnostics.push(...analysis.diagnostics.map(d => ({
+                                        ...d,
+                                        messageText: formatDiagnosticMessage(d),
+                                    })));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return diagnostics;
+}
+function formatDiagnosticMessage(diagnostic) {
+    const code = diagnostic.code - 100000;
+    const tspCode = formatErrorCode ? formatErrorCode(code) : `TSP${code}`;
+    const message = typeof diagnostic.messageText === 'string'
+        ? diagnostic.messageText
+        : diagnostic.messageText.messageText;
+    return `${tspCode}: ${message}`;
+}
+// Patch the Project prototype from the real tsserverlibrary
+if (realTsServerLib.server?.Project) {
+    const ProjectProto = realTsServerLib.server.Project.prototype;
+    if (ProjectProto.getLanguageService && !ProjectProto.__justscale_patched) {
+        const originalGetLanguageService = ProjectProto.getLanguageService;
+        ProjectProto.getLanguageService = function () {
+            const ls = originalGetLanguageService.call(this);
+            // Check if we already wrapped this language service
+            const lsAny = ls;
+            if (lsAny.__justscale_wrapped) {
+                return ls;
+            }
+            log.info('Project.getLanguageService: wrapping language service');
+            // Create wrapped version
+            const originalGetSemanticDiagnostics = ls.getSemanticDiagnostics.bind(ls);
+            ls.getSemanticDiagnostics = (fileName) => {
+                log.info('getSemanticDiagnostics: called', { fileName });
+                const original = originalGetSemanticDiagnostics(fileName);
+                const program = ls.getProgram();
+                if (!program) {
+                    return original;
+                }
+                const sourceFile = program.getSourceFile(fileName);
+                if (!sourceFile) {
+                    return original;
+                }
+                const isProcess = isProcessFile(sourceFile);
+                log.info('getSemanticDiagnostics: isProcessFile', { fileName, isProcess });
+                if (!isProcess) {
+                    return original;
+                }
+                const filtered = filterUsingExportsDiagnostics ? filterUsingExportsDiagnostics(original) : original;
+                log.info('getSemanticDiagnostics: analyzing process file', { fileName });
+                try {
+                    const processDiagnostics = getProcessDiagnostics(sourceFile, program);
+                    log.info('getSemanticDiagnostics: complete', {
+                        fileName,
+                        originalCount: original.length,
+                        filteredCount: filtered.length,
+                        processCount: processDiagnostics.length,
+                    });
+                    return [...filtered, ...processDiagnostics];
+                }
+                catch (err) {
+                    log.error('getSemanticDiagnostics: error', { fileName, error: String(err) });
+                    return original;
+                }
+            };
+            lsAny.__justscale_wrapped = true;
+            return ls;
+        };
+        ProjectProto.__justscale_patched = true;
+        log.info('Patched ts.server.Project.prototype.getLanguageService');
+    }
+}
+else {
+    log.warn('ts.server.Project not found in tsserverlibrary');
+}
+// Re-export the patched ts with server from real tsserverlibrary
+const merged = {
+    ...ts,
+    server: realTsServerLib.server,
+};
+module.exports = merged;