shokupan 0.13.0 → 0.14.0

package/dist/ast-analyzer-worker-C3jrQ8VR.js

@@ -0,0 +1,184 @@
+import { EventEmitter } from "events";
+import path from "path";
+import { Worker } from "worker_threads";
+class ASTAnalyzerWorker extends EventEmitter {
+  state = "idle";
+  result = null;
+  error = null;
+  worker = null;
+  analysisPromise = null;
+  rootDir;
+  entrypoint;
+  timeout;
+  startTime = 0;
+  constructor(rootDir, entrypoint, timeout = 3e4) {
+    super();
+    this.rootDir = rootDir;
+    this.entrypoint = entrypoint;
+    this.timeout = timeout;
+  }
+  /**
+   * Get the current state of the analyzer.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the cached result if analysis completed successfully.
+   */
+  getResult() {
+    return this.result;
+  }
+  /**
+   * Get the error if analysis failed.
+   */
+  getError() {
+    return this.error;
+  }
+  /**
+   * Check if analysis is currently running.
+   */
+  isAnalyzing() {
+    return this.state === "analyzing";
+  }
+  /**
+   * Check if analysis has completed successfully.
+   */
+  isCompleted() {
+    return this.state === "completed";
+  }
+  /**
+   * Check if analysis has failed.
+   */
+  isFailed() {
+    return this.state === "failed";
+  }
+  /**
+   * Get analysis duration in milliseconds (if completed or failed).
+   */
+  getDuration() {
+    if (this.state === "idle" || this.state === "analyzing") {
+      return null;
+    }
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Start AST analysis in a worker thread.
+   * Returns immediately and emits events as analysis progresses.
+   */
+  async analyze() {
+    if (this.analysisPromise) {
+      return this.analysisPromise;
+    }
+    if (this.state === "completed" && this.result) {
+      return Promise.resolve(this.result);
+    }
+    if (this.state === "failed") {
+      this.state = "idle";
+      this.error = null;
+    }
+    this.analysisPromise = new Promise((resolve, reject) => {
+      this.state = "analyzing";
+      this.startTime = Date.now();
+      this.emit("started");
+      const workerPath = path.join(__dirname, "ast-worker-thread.js");
+      this.worker = new Worker(workerPath, {
+        workerData: {
+          rootDir: this.rootDir,
+          entrypoint: this.entrypoint
+        }
+      });
+      const timeoutId = setTimeout(() => {
+        if (this.worker) {
+          this.worker.terminate();
+          this.worker = null;
+        }
+        const timeoutError = new Error(`AST analysis timed out after ${this.timeout}ms`);
+        this.state = "failed";
+        this.error = timeoutError;
+        this.emit("failed", timeoutError);
+        reject(timeoutError);
+      }, this.timeout);
+      this.worker.on("message", (message) => {
+        if (message.type === "progress") {
+          this.emit("progress", message.message);
+        } else if (message.type === "result") {
+          clearTimeout(timeoutId);
+          this.state = "completed";
+          this.result = message.data;
+          this.emit("completed", this.result);
+          resolve(this.result);
+          if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+          }
+        }
+      });
+      this.worker.on("error", (err) => {
+        clearTimeout(timeoutId);
+        this.state = "failed";
+        this.error = err;
+        this.emit("failed", err);
+        reject(err);
+        if (this.worker) {
+          this.worker.terminate();
+          this.worker = null;
+        }
+      });
+      this.worker.on("exit", (code) => {
+        if (code !== 0 && this.state === "analyzing") {
+          clearTimeout(timeoutId);
+          const exitError = new Error(`Worker exited with code ${code}`);
+          this.state = "failed";
+          this.error = exitError;
+          this.emit("failed", exitError);
+          reject(exitError);
+        }
+      });
+    });
+    return this.analysisPromise;
+  }
+  /**
+   * Wait for analysis to complete (if it's running) or return immediately if already done.
+   */
+  async waitForCompletion() {
+    if (this.state === "completed" && this.result) {
+      return this.result;
+    }
+    if (this.state === "failed" && this.error) {
+      throw this.error;
+    }
+    if (this.state === "analyzing" && this.analysisPromise) {
+      return this.analysisPromise;
+    }
+    return this.analyze();
+  }
+  /**
+   * Terminate the worker thread if running.
+   */
+  terminate() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    if (this.state === "analyzing") {
+      this.state = "idle";
+    }
+  }
+}
+let globalAnalyzer = null;
+function getGlobalAnalyzer(rootDir, entrypoint, timeout) {
+  if (!globalAnalyzer) {
+    globalAnalyzer = new ASTAnalyzerWorker(
+      rootDir || process.cwd(),
+      entrypoint,
+      timeout
+    );
+  }
+  return globalAnalyzer;
+}
+export {
+  ASTAnalyzerWorker,
+  getGlobalAnalyzer
+};
+//# sourceMappingURL=ast-analyzer-worker-C3jrQ8VR.js.map

package/dist/ast-analyzer-worker-C3jrQ8VR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-analyzer-worker-C3jrQ8VR.js","sources":["../src/util/ast-analyzer-worker.ts"],"sourcesContent":["import { EventEmitter } from 'events';\nimport path from 'path';\nimport { Worker } from 'worker_threads';\n\nexport type ASTAnalyzerState = 'idle' | 'analyzing' | 'completed' | 'failed';\n\nexport interface ASTAnalyzerResult {\n    applications: any[];\n}\n\nexport interface ASTAnalyzerEvents {\n    'started': () => void;\n    'completed': (result: ASTAnalyzerResult) => void;\n    'failed': (error: Error) => void;\n    'progress': (message: string) => void;\n}\n\n/**\n * Worker-based AST analyzer that runs TypeScript analysis in a separate thread.\n * This prevents blocking the main event loop during intensive AST parsing.\n */\nexport class ASTAnalyzerWorker extends EventEmitter {\n    private state: ASTAnalyzerState = 'idle';\n    private result: ASTAnalyzerResult | null = null;\n    private error: Error | null = null;\n    private worker: Worker | null = null;\n    private analysisPromise: Promise<ASTAnalyzerResult> | null = null;\n    private rootDir: string;\n    private entrypoint?: string;\n    private timeout: number;\n    private startTime: number = 0;\n\n    constructor(rootDir: string, entrypoint?: string, timeout: number = 30000) {\n        super();\n        this.rootDir = rootDir;\n        this.entrypoint = entrypoint;\n        this.timeout = timeout;\n    }\n\n    /**\n     * Get the current state of the analyzer.\n     */\n    public getState(): ASTAnalyzerState {\n        return this.state;\n    }\n\n    /**\n     * Get the cached result if analysis completed successfully.\n     */\n    public getResult(): ASTAnalyzerResult | null {\n        return this.result;\n    }\n\n    /**\n     * Get the error if analysis failed.\n     */\n    public getError(): Error | null {\n        return this.error;\n    }\n\n    /**\n     * Check if analysis is currently running.\n     */\n    public isAnalyzing(): boolean {\n        return this.state === 'analyzing';\n    }\n\n    /**\n     * Check if analysis has completed successfully.\n     */\n    public isCompleted(): boolean {\n        return this.state === 'completed';\n    }\n\n    /**\n     * Check if analysis has failed.\n     */\n    public isFailed(): boolean {\n        return this.state === 'failed';\n    }\n\n    /**\n     * Get analysis duration in milliseconds (if completed or failed).\n     */\n    public getDuration(): number | null {\n        if (this.state === 'idle' || this.state === 'analyzing') {\n            return null;\n        }\n        return Date.now() - this.startTime;\n    }\n\n    /**\n     * Start AST analysis in a worker thread.\n     * Returns immediately and emits events as analysis progresses.\n     */\n    public async analyze(): Promise<ASTAnalyzerResult> {\n        // If already analyzing, return the existing promise\n        if (this.analysisPromise) {\n            return this.analysisPromise;\n        }\n\n        // If already completed, return cached result\n        if (this.state === 'completed' && this.result) {\n            return Promise.resolve(this.result);\n        }\n\n        // If previously failed, reset state for retry\n        if (this.state === 'failed') {\n            this.state = 'idle';\n            this.error = null;\n        }\n\n        this.analysisPromise = new Promise<ASTAnalyzerResult>((resolve, reject) => {\n            this.state = 'analyzing';\n            this.startTime = Date.now();\n            this.emit('started');\n\n            // Create worker thread\n            const workerPath = path.join(__dirname, 'ast-worker-thread.js');\n            this.worker = new Worker(workerPath, {\n                workerData: {\n                    rootDir: this.rootDir,\n                    entrypoint: this.entrypoint\n                }\n            });\n\n            // Set timeout\n            const timeoutId = setTimeout(() => {\n                if (this.worker) {\n                    this.worker.terminate();\n                    this.worker = null;\n                }\n                const timeoutError = new Error(`AST analysis timed out after ${this.timeout}ms`);\n                this.state = 'failed';\n                this.error = timeoutError;\n                this.emit('failed', timeoutError);\n                reject(timeoutError);\n            }, this.timeout);\n\n            // Handle worker messages\n            this.worker.on('message', (message: any) => {\n                if (message.type === 'progress') {\n                    this.emit('progress', message.message);\n                } else if (message.type === 'result') {\n                    clearTimeout(timeoutId);\n                    this.state = 'completed';\n                    this.result = message.data;\n                    this.emit('completed', this.result!);\n                    resolve(this.result!);\n\n                    // Clean up worker\n                    if (this.worker) {\n                        this.worker.terminate();\n                        this.worker = null;\n                    }\n                }\n            });\n\n            // Handle worker errors\n            this.worker.on('error', (err: Error) => {\n                clearTimeout(timeoutId);\n                this.state = 'failed';\n                this.error = err;\n                this.emit('failed', err);\n                reject(err);\n\n                // Clean up worker\n                if (this.worker) {\n                    this.worker.terminate();\n                    this.worker = null;\n                }\n            });\n\n            // Handle worker exit\n            this.worker.on('exit', (code) => {\n                if (code !== 0 && this.state === 'analyzing') {\n                    clearTimeout(timeoutId);\n                    const exitError = new Error(`Worker exited with code ${code}`);\n                    this.state = 'failed';\n                    this.error = exitError;\n                    this.emit('failed', exitError);\n                    reject(exitError);\n                }\n            });\n        });\n\n        return this.analysisPromise;\n    }\n\n    /**\n     * Wait for analysis to complete (if it's running) or return immediately if already done.\n     */\n    public async waitForCompletion(): Promise<ASTAnalyzerResult> {\n        if (this.state === 'completed' && this.result) {\n            return this.result;\n        }\n\n        if (this.state === 'failed' && this.error) {\n            throw this.error;\n        }\n\n        if (this.state === 'analyzing' && this.analysisPromise) {\n            return this.analysisPromise;\n        }\n\n        // Not started yet, start it\n        return this.analyze();\n    }\n\n    /**\n     * Terminate the worker thread if running.\n     */\n    public terminate(): void {\n        if (this.worker) {\n            this.worker.terminate();\n            this.worker = null;\n        }\n        if (this.state === 'analyzing') {\n            this.state = 'idle';\n        }\n    }\n}\n\n// Singleton instance for shared use across plugins\nlet globalAnalyzer: ASTAnalyzerWorker | null = null;\n\n/**\n * Get or create the global AST analyzer instance.\n * This ensures all plugins share the same analysis results.\n */\nexport function getGlobalAnalyzer(rootDir?: string, entrypoint?: string, timeout?: number): ASTAnalyzerWorker {\n    if (!globalAnalyzer) {\n        globalAnalyzer = new ASTAnalyzerWorker(\n            rootDir || process.cwd(),\n            entrypoint,\n            timeout\n        );\n    }\n    return globalAnalyzer;\n}\n\n/**\n * Reset the global analyzer instance (useful for testing).\n */\nexport function resetGlobalAnalyzer(): void {\n    if (globalAnalyzer) {\n        globalAnalyzer.terminate();\n        globalAnalyzer = null;\n    }\n}\n"],"names":[],"mappings":"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"}

package/dist/ast-analyzer-worker-D_uYkqmY.cjs

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const events = require("events");
+const path = require("path");
+const worker_threads = require("worker_threads");
+class ASTAnalyzerWorker extends events.EventEmitter {
+  state = "idle";
+  result = null;
+  error = null;
+  worker = null;
+  analysisPromise = null;
+  rootDir;
+  entrypoint;
+  timeout;
+  startTime = 0;
+  constructor(rootDir, entrypoint, timeout = 3e4) {
+    super();
+    this.rootDir = rootDir;
+    this.entrypoint = entrypoint;
+    this.timeout = timeout;
+  }
+  /**
+   * Get the current state of the analyzer.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the cached result if analysis completed successfully.
+   */
+  getResult() {
+    return this.result;
+  }
+  /**
+   * Get the error if analysis failed.
+   */
+  getError() {
+    return this.error;
+  }
+  /**
+   * Check if analysis is currently running.
+   */
+  isAnalyzing() {
+    return this.state === "analyzing";
+  }
+  /**
+   * Check if analysis has completed successfully.
+   */
+  isCompleted() {
+    return this.state === "completed";
+  }
+  /**
+   * Check if analysis has failed.
+   */
+  isFailed() {
+    return this.state === "failed";
+  }
+  /**
+   * Get analysis duration in milliseconds (if completed or failed).
+   */
+  getDuration() {
+    if (this.state === "idle" || this.state === "analyzing") {
+      return null;
+    }
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Start AST analysis in a worker thread.
+   * Returns immediately and emits events as analysis progresses.
+   */
+  async analyze() {
+    if (this.analysisPromise) {
+      return this.analysisPromise;
+    }
+    if (this.state === "completed" && this.result) {
+      return Promise.resolve(this.result);
+    }
+    if (this.state === "failed") {
+      this.state = "idle";
+      this.error = null;
+    }
+    this.analysisPromise = new Promise((resolve, reject) => {
+      this.state = "analyzing";
+      this.startTime = Date.now();
+      this.emit("started");
+      const workerPath = path.join(__dirname, "ast-worker-thread.js");
+      this.worker = new worker_threads.Worker(workerPath, {
+        workerData: {
+          rootDir: this.rootDir,
+          entrypoint: this.entrypoint
+        }
+      });
+      const timeoutId = setTimeout(() => {
+        if (this.worker) {
+          this.worker.terminate();
+          this.worker = null;
+        }
+        const timeoutError = new Error(`AST analysis timed out after ${this.timeout}ms`);
+        this.state = "failed";
+        this.error = timeoutError;
+        this.emit("failed", timeoutError);
+        reject(timeoutError);
+      }, this.timeout);
+      this.worker.on("message", (message) => {
+        if (message.type === "progress") {
+          this.emit("progress", message.message);
+        } else if (message.type === "result") {
+          clearTimeout(timeoutId);
+          this.state = "completed";
+          this.result = message.data;
+          this.emit("completed", this.result);
+          resolve(this.result);
+          if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+          }
+        }
+      });
+      this.worker.on("error", (err) => {
+        clearTimeout(timeoutId);
+        this.state = "failed";
+        this.error = err;
+        this.emit("failed", err);
+        reject(err);
+        if (this.worker) {
+          this.worker.terminate();
+          this.worker = null;
+        }
+      });
+      this.worker.on("exit", (code) => {
+        if (code !== 0 && this.state === "analyzing") {
+          clearTimeout(timeoutId);
+          const exitError = new Error(`Worker exited with code ${code}`);
+          this.state = "failed";
+          this.error = exitError;
+          this.emit("failed", exitError);
+          reject(exitError);
+        }
+      });
+    });
+    return this.analysisPromise;
+  }
+  /**
+   * Wait for analysis to complete (if it's running) or return immediately if already done.
+   */
+  async waitForCompletion() {
+    if (this.state === "completed" && this.result) {
+      return this.result;
+    }
+    if (this.state === "failed" && this.error) {
+      throw this.error;
+    }
+    if (this.state === "analyzing" && this.analysisPromise) {
+      return this.analysisPromise;
+    }
+    return this.analyze();
+  }
+  /**
+   * Terminate the worker thread if running.
+   */
+  terminate() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    if (this.state === "analyzing") {
+      this.state = "idle";
+    }
+  }
+}
+let globalAnalyzer = null;
+function getGlobalAnalyzer(rootDir, entrypoint, timeout) {
+  if (!globalAnalyzer) {
+    globalAnalyzer = new ASTAnalyzerWorker(
+      rootDir || process.cwd(),
+      entrypoint,
+      timeout
+    );
+  }
+  return globalAnalyzer;
+}
+exports.ASTAnalyzerWorker = ASTAnalyzerWorker;
+exports.getGlobalAnalyzer = getGlobalAnalyzer;
+//# sourceMappingURL=ast-analyzer-worker-D_uYkqmY.cjs.map

package/dist/ast-analyzer-worker-D_uYkqmY.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-analyzer-worker-D_uYkqmY.cjs","sources":["../src/util/ast-analyzer-worker.ts"],"sourcesContent":["import { EventEmitter } from 'events';\nimport path from 'path';\nimport { Worker } from 'worker_threads';\n\nexport type ASTAnalyzerState = 'idle' | 'analyzing' | 'completed' | 'failed';\n\nexport interface ASTAnalyzerResult {\n    applications: any[];\n}\n\nexport interface ASTAnalyzerEvents {\n    'started': () => void;\n    'completed': (result: ASTAnalyzerResult) => void;\n    'failed': (error: Error) => void;\n    'progress': (message: string) => void;\n}\n\n/**\n * Worker-based AST analyzer that runs TypeScript analysis in a separate thread.\n * This prevents blocking the main event loop during intensive AST parsing.\n */\nexport class ASTAnalyzerWorker extends EventEmitter {\n    private state: ASTAnalyzerState = 'idle';\n    private result: ASTAnalyzerResult | null = null;\n    private error: Error | null = null;\n    private worker: Worker | null = null;\n    private analysisPromise: Promise<ASTAnalyzerResult> | null = null;\n    private rootDir: string;\n    private entrypoint?: string;\n    private timeout: number;\n    private startTime: number = 0;\n\n    constructor(rootDir: string, entrypoint?: string, timeout: number = 30000) {\n        super();\n        this.rootDir = rootDir;\n        this.entrypoint = entrypoint;\n        this.timeout = timeout;\n    }\n\n    /**\n     * Get the current state of the analyzer.\n     */\n    public getState(): ASTAnalyzerState {\n        return this.state;\n    }\n\n    /**\n     * Get the cached result if analysis completed successfully.\n     */\n    public getResult(): ASTAnalyzerResult | null {\n        return this.result;\n    }\n\n    /**\n     * Get the error if analysis failed.\n     */\n    public getError(): Error | null {\n        return this.error;\n    }\n\n    /**\n     * Check if analysis is currently running.\n     */\n    public isAnalyzing(): boolean {\n        return this.state === 'analyzing';\n    }\n\n    /**\n     * Check if analysis has completed successfully.\n     */\n    public isCompleted(): boolean {\n        return this.state === 'completed';\n    }\n\n    /**\n     * Check if analysis has failed.\n     */\n    public isFailed(): boolean {\n        return this.state === 'failed';\n    }\n\n    /**\n     * Get analysis duration in milliseconds (if completed or failed).\n     */\n    public getDuration(): number | null {\n        if (this.state === 'idle' || this.state === 'analyzing') {\n            return null;\n        }\n        return Date.now() - this.startTime;\n    }\n\n    /**\n     * Start AST analysis in a worker thread.\n     * Returns immediately and emits events as analysis progresses.\n     */\n    public async analyze(): Promise<ASTAnalyzerResult> {\n        // If already analyzing, return the existing promise\n        if (this.analysisPromise) {\n            return this.analysisPromise;\n        }\n\n        // If already completed, return cached result\n        if (this.state === 'completed' && this.result) {\n            return Promise.resolve(this.result);\n        }\n\n        // If previously failed, reset state for retry\n        if (this.state === 'failed') {\n            this.state = 'idle';\n            this.error = null;\n        }\n\n        this.analysisPromise = new Promise<ASTAnalyzerResult>((resolve, reject) => {\n            this.state = 'analyzing';\n            this.startTime = Date.now();\n            this.emit('started');\n\n            // Create worker thread\n            const workerPath = path.join(__dirname, 'ast-worker-thread.js');\n            this.worker = new Worker(workerPath, {\n                workerData: {\n                    rootDir: this.rootDir,\n                    entrypoint: this.entrypoint\n                }\n            });\n\n            // Set timeout\n            const timeoutId = setTimeout(() => {\n                if (this.worker) {\n                    this.worker.terminate();\n                    this.worker = null;\n                }\n                const timeoutError = new Error(`AST analysis timed out after ${this.timeout}ms`);\n                this.state = 'failed';\n                this.error = timeoutError;\n                this.emit('failed', timeoutError);\n                reject(timeoutError);\n            }, this.timeout);\n\n            // Handle worker messages\n            this.worker.on('message', (message: any) => {\n                if (message.type === 'progress') {\n                    this.emit('progress', message.message);\n                } else if (message.type === 'result') {\n                    clearTimeout(timeoutId);\n                    this.state = 'completed';\n                    this.result = message.data;\n                    this.emit('completed', this.result!);\n                    resolve(this.result!);\n\n                    // Clean up worker\n                    if (this.worker) {\n                        this.worker.terminate();\n                        this.worker = null;\n                    }\n                }\n            });\n\n            // Handle worker errors\n            this.worker.on('error', (err: Error) => {\n                clearTimeout(timeoutId);\n                this.state = 'failed';\n                this.error = err;\n                this.emit('failed', err);\n                reject(err);\n\n                // Clean up worker\n                if (this.worker) {\n                    this.worker.terminate();\n                    this.worker = null;\n                }\n            });\n\n            // Handle worker exit\n            this.worker.on('exit', (code) => {\n                if (code !== 0 && this.state === 'analyzing') {\n                    clearTimeout(timeoutId);\n                    const exitError = new Error(`Worker exited with code ${code}`);\n                    this.state = 'failed';\n                    this.error = exitError;\n                    this.emit('failed', exitError);\n                    reject(exitError);\n                }\n            });\n        });\n\n        return this.analysisPromise;\n    }\n\n    /**\n     * Wait for analysis to complete (if it's running) or return immediately if already done.\n     */\n    public async waitForCompletion(): Promise<ASTAnalyzerResult> {\n        if (this.state === 'completed' && this.result) {\n            return this.result;\n        }\n\n        if (this.state === 'failed' && this.error) {\n            throw this.error;\n        }\n\n        if (this.state === 'analyzing' && this.analysisPromise) {\n            return this.analysisPromise;\n        }\n\n        // Not started yet, start it\n        return this.analyze();\n    }\n\n    /**\n     * Terminate the worker thread if running.\n     */\n    public terminate(): void {\n        if (this.worker) {\n            this.worker.terminate();\n            this.worker = null;\n        }\n        if (this.state === 'analyzing') {\n            this.state = 'idle';\n        }\n    }\n}\n\n// Singleton instance for shared use across plugins\nlet globalAnalyzer: ASTAnalyzerWorker | null = null;\n\n/**\n * Get or create the global AST analyzer instance.\n * This ensures all plugins share the same analysis results.\n */\nexport function getGlobalAnalyzer(rootDir?: string, entrypoint?: string, timeout?: number): ASTAnalyzerWorker {\n    if (!globalAnalyzer) {\n        globalAnalyzer = new ASTAnalyzerWorker(\n            rootDir || process.cwd(),\n            entrypoint,\n            timeout\n        );\n    }\n    return globalAnalyzer;\n}\n\n/**\n * Reset the global analyzer instance (useful for testing).\n */\nexport function resetGlobalAnalyzer(): void {\n    if (globalAnalyzer) {\n        globalAnalyzer.terminate();\n        globalAnalyzer = null;\n    }\n}\n"],"names":["EventEmitter","Worker"],"mappings":"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"}

package/dist/cli.cjs

@@ -4,7 +4,7 @@ const p = require("@clack/prompts");
 const fs = require("node:fs");
 const path = require("node:path");
 const promises = require("node:timers/promises");
-const analyzer = require("./analyzer-BOtveWL-.cjs");
+const analyzer = require("./analyzer-BZSVGTmP.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/dist/cli.js

@@ -3,7 +3,7 @@ import * as p from "@clack/prompts";
 import fs from "node:fs";
 import path from "node:path";
 import { setTimeout } from "node:timers/promises";
-import { OpenAPIAnalyzer } from "./analyzer-B0fMzeIo.js";
+import { OpenAPIAnalyzer } from "./analyzer-Faojwm7c.js";
 const templates = {
   controller: (name) => `import { Controller, Get, Ctx } from 'shokupan';
 import { ShokupanContext } from 'shokupan';

package/dist/context.d.ts

@@ -5,6 +5,15 @@ import { ShokupanRequest } from './util/request';
 import { ShokupanResponse } from './util/response';
 import { $bodyParsed, $bodyParseError, $bodyType, $cachedBody, $cachedCookies, $cachedHost, $cachedHostname, $cachedOrigin, $cachedProtocol, $cachedQuery, $debug, $finalResponse, $io, $rawBody, $requestId, $routeMatched, $socket, $url, $ws } from './util/symbol';
 import { CookieOptions, HeadersInit, JSXRenderer, SSEStreamErrorHandler, SSEStreamHelper, StreamErrorHandler, StreamHelper, TextStreamErrorHandler, TextStreamHelper } from './util/types';
+/**
+ * Inline WebSocket handlers for ctx.upgrade()
+ */
+export interface InlineWebSocketHandlers<T = any> {
+    open?: (ctx: ShokupanContext<T>, ws: ServerWebSocket<any>) => void | Promise<void>;
+    message?: (ctx: ShokupanContext<T>, ws: ServerWebSocket<any>, message: string | Buffer) => void | Promise<void>;
+    close?: (ctx: ShokupanContext<T>, ws: ServerWebSocket<any>, code?: number, reason?: string) => void | Promise<void>;
+    error?: (ctx: ShokupanContext<T>, ws: ServerWebSocket<any>, error: Error) => void | Promise<void>;
+}
 export interface HandlerStackItem {
     name: string;
     file: string;
@@ -93,6 +102,10 @@ export declare class ShokupanContext<State extends Record<string, any> = Record<
     [$debug]?: DebugCollector;
     [$finalResponse]?: Response;
     [$rawBody]?: string | ArrayBuffer | Uint8Array;
+    /**
+     * Application logger instance
+     */
+    get logger(): import('./util/logger').Logger;
     private [$url]?;
     private [$cachedBody]?;
     private [$bodyType]?;
@@ -211,12 +224,26 @@ export declare class ShokupanContext<State extends Record<string, any> = Record<
     isUpgraded: boolean;
     /**
      * Upgrades the request to a WebSocket connection.
-     * @param options Upgrade options
+     *
+     * @param options Upgrade options or inline WebSocket handlers
      * @returns true if upgraded, false otherwise
-     */
-    upgrade(options?: {
+     *
+     * This method will link the WebSocket connection to the context object,
+     * allowing you to access the connection in your handlers.
+     *
+     * @example Inline handlers
+     * ```ts
+     * app.get('/ws', (ctx) => {
+     *   ctx.upgrade({
+     *     open: (ctx, ws) => ws.send("Connected"),
+     *     message: (ctx, ws, msg) => ws.send(msg),
+     *     close: (ctx, ws) => console.log("Disconnected")
+     *   });
+     * });
+     * ```
+     */
+    upgrade(options?: Parameters<Server<State>["upgrade"]>[1] | InlineWebSocketHandlers<State> & {
         data?: any;
-        headers?: HeadersInit;
     }): boolean;
     /**
      * Set a cookie
@@ -241,6 +268,14 @@ export declare class ShokupanContext<State extends Record<string, any> = Record<
      * Errors are deferred until the body is actually accessed in the handler.
      */
     parseBody(): Promise<void>;
+    /**
+     * Respond with automatic content negotiation
+     * Uses Accept header to determine the best response format
+     * @param data Data to respond with
+     * @param status HTTP status code
+     * @param headers Additional headers
+     */
+    respond(data: any, status?: number, headers?: HeadersInit): Promise<Response>;
     /**
      * Send a response
      * @param body Response body

package/dist/decorators/di.d.ts

@@ -0,0 +1,31 @@
+import { RateLimitOptions } from '../plugins/middleware/rate-limit';
+import { AsyncAPISpec, GuardAPISpec, MethodAPISpec, Middleware } from '../util/types';
+/**
+ * Registers this class as a **Singleton** service.
+ * A single instance will be created and shared across the process.
+ */
+export declare function Injectable(scope: 'singleton'): ClassDecorator;
+/**
+ * Registers this class as an **Instanced** (Transient) service.
+ * A new instance will be created every time dependency is resolved.
+ */
+export declare function Injectable(scope: 'instanced'): ClassDecorator;
+/**
+ * Property/Parameter Decorator: Injects a service.
+ * Used on class properties or constructor parameters.
+ */
+export declare function Inject(token: any): PropertyDecorator & ParameterDecorator;
+/**
+ * Decorator: Applies middleware OR injects dependencies.
+ * - Class/Method: Middleware
+ * - Property/Parameter: Dependency Injection
+ */
+export declare function Use(tokenOrMiddleware?: any | Middleware, ...moreMiddleware: Middleware[]): any;
+/**
+ * Decorator: Overrides the OpenAPI specification for a route.
+ */
+export declare function Spec(spec: MethodAPISpec | GuardAPISpec | AsyncAPISpec): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Applies a rate limit to a class or method.
+ */
+export declare function RateLimit(options: RateLimitOptions): any;

package/dist/decorators/hooks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Decorator: Hook that runs before a request is processed by the controller handler.
+ */
+export declare const OnRequestStart: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs after a request is successfully processed.
+ */
+export declare const OnRequestEnd: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs when an error occurs during request processing.
+ */
+export declare const OnRequestError: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs when the response starts sending (headers).
+ */
+export declare const OnResponseStart: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs after the response has finished sending.
+ */
+export declare const OnResponseEnd: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs before validation.
+ */
+export declare const BeforeValidate: () => (target: any, propertyKey: string) => void;
+/**
+ * Decorator: Hook that runs after validation.
+ */
+export declare const AfterValidate: () => (target: any, propertyKey: string) => void;

package/dist/decorators/http.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Class Decorator: Defines the base path for a controller.
+ */
+export declare function Controller(path?: string): (target: any) => void;
+/**
+ * Decorator: Binds a method to the GET HTTP verb.
+ */
+export declare const Get: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the POST HTTP verb.
+ */
+export declare const Post: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the PUT HTTP verb.
+ */
+export declare const Put: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the DELETE HTTP verb.
+ */
+export declare const Delete: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the PATCH HTTP verb.
+ */
+export declare const Patch: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the OPTIONS HTTP verb.
+ */
+export declare const Options: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the HEAD HTTP verb.
+ */
+export declare const Head: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to ANY HTTP verb.
+ */
+export declare const All: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a parameter to the request body.
+ */
+export declare const Body: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request parameters.
+ */
+export declare const Param: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request query string.
+ */
+export declare const Query: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request headers.
+ */
+export declare const Headers: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request object.
+ */
+export declare const Req: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request context.
+ */
+export declare const Ctx: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;

package/dist/decorators/index.d.ts

@@ -0,0 +1,8 @@
+export * from './di';
+export * from './hooks';
+export * from './http';
+export * from './mcp';
+export * from './util/container';
+export * from './util/metadata';
+export * from './util/stack';
+export * from './websocket';