@spaceflow/core 0.1.3 → 0.2.0

package/src/shared/llm-proxy/llm-proxy.service.spec.ts

@@ -1,13 +1,30 @@
 import { vi, type Mocked } from "vitest";
-import { Test, TestingModule } from "@nestjs/testing";
 import { LlmProxyService, ChatOptions } from "./llm-proxy.service";
-import { ClaudeCodeAdapter } from "./adapters/claude-code.adapter";
-import { OpenAIAdapter } from "./adapters/openai.adapter";
-import { OpenCodeAdapter } from "./adapters/open-code.adapter";
+import type { ClaudeCodeAdapter } from "./adapters/claude-code.adapter";
+import type { OpenAIAdapter } from "./adapters/openai.adapter";
+import type { OpenCodeAdapter } from "./adapters/open-code.adapter";
 
 vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
   query: vi.fn(),
 }));
+vi.mock("../../claude-setup", () => ({
+  ClaudeSetupService: class MockClaudeSetupService {
+    configure = vi.fn().mockResolvedValue(undefined);
+  },
+}));
+
+vi.mock("./adapters/claude-code.adapter", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./adapters/claude-code.adapter")>();
+  return { ...actual };
+});
+vi.mock("./adapters/openai.adapter", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./adapters/openai.adapter")>();
+  return { ...actual };
+});
+vi.mock("./adapters/open-code.adapter", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./adapters/open-code.adapter")>();
+  return { ...actual };
+});
 
 describe("LlmProxyService", () => {
   let service: LlmProxyService;
@@ -17,45 +34,18 @@ describe("LlmProxyService", () => {
 
   const mockConfig = {
     defaultAdapter: "claude-code" as const,
+    claudeCode: { model: "claude-3-5-sonnet" },
+    openai: { apiKey: "test-key", model: "gpt-4o" },
+    openCode: { apiKey: "test-key" },
   };
 
-  beforeEach(async () => {
-    const mockClaude = {
-      name: "claude-code",
-      chat: vi.fn(),
-      chatStream: vi.fn(),
-      isConfigured: vi.fn().mockReturnValue(true),
-      isSupportJsonSchema: vi.fn().mockReturnValue(true),
-    };
-    const mockOpenAI = {
-      name: "openai",
-      chat: vi.fn(),
-      chatStream: vi.fn(),
-      isConfigured: vi.fn().mockReturnValue(true),
-      isSupportJsonSchema: vi.fn().mockReturnValue(true),
-    };
-    const mockOpenCode = {
-      name: "open-code",
-      chat: vi.fn(),
-      chatStream: vi.fn(),
-      isConfigured: vi.fn().mockReturnValue(true),
-      isSupportJsonSchema: vi.fn().mockReturnValue(true),
-    };
-
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        LlmProxyService,
-        { provide: "LLM_PROXY_CONFIG", useValue: mockConfig },
-        { provide: ClaudeCodeAdapter, useValue: mockClaude },
-        { provide: OpenAIAdapter, useValue: mockOpenAI },
-        { provide: OpenCodeAdapter, useValue: mockOpenCode },
-      ],
-    }).compile();
-
-    service = module.get<LlmProxyService>(LlmProxyService);
-    claudeAdapter = module.get(ClaudeCodeAdapter);
-    openaiAdapter = module.get(OpenAIAdapter);
-    opencodeAdapter = module.get(OpenCodeAdapter);
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new LlmProxyService(mockConfig as any);
+    // 获取内部适配器的引用（通过 getAdapter）
+    claudeAdapter = (service as any).adapters.get("claude-code");
+    openaiAdapter = (service as any).adapters.get("openai");
+    opencodeAdapter = (service as any).adapters.get("open-code");
   });
 
   it("should be defined", () => {
@@ -76,8 +66,9 @@ describe("LlmProxyService", () => {
     });
 
     it("should throw error if adapter is not configured", () => {
-      claudeAdapter.isConfigured.mockReturnValue(false);
+      const spy = vi.spyOn(claudeAdapter, "isConfigured").mockReturnValue(false);
       expect(() => service.createSession("claude-code")).toThrow('适配器 "claude-code" 未配置');
+      spy.mockRestore();
     });
   });
 
@@ -85,23 +76,29 @@ describe("LlmProxyService", () => {
     it("should call adapter.chat and return response", async () => {
       const messages = [{ role: "user", content: "hello" }] as any;
       const mockResponse = { content: "hi", role: "assistant" };
-      claudeAdapter.chat.mockResolvedValue(mockResponse as any);
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue(mockResponse as any);
 
       const result = await service.chat(messages);
 
-      expect(claudeAdapter.chat).toHaveBeenCalledWith(messages, undefined);
+      expect(chatSpy).toHaveBeenCalledWith(messages, undefined);
       expect(result).toEqual(mockResponse);
+      chatSpy.mockRestore();
     });
 
     it("should use specified adapter", async () => {
       const messages = [{ role: "user", content: "hello" }] as any;
       const options: ChatOptions = { adapter: "openai" };
-      openaiAdapter.chat.mockResolvedValue({ content: "hi" } as any);
+      const openaiChatSpy = vi
+        .spyOn(openaiAdapter, "chat")
+        .mockResolvedValue({ content: "hi" } as any);
+      const claudeChatSpy = vi.spyOn(claudeAdapter, "chat");
 
       await service.chat(messages, options);
 
-      expect(openaiAdapter.chat).toHaveBeenCalled();
-      expect(claudeAdapter.chat).not.toHaveBeenCalled();
+      expect(openaiChatSpy).toHaveBeenCalled();
+      expect(claudeChatSpy).not.toHaveBeenCalled();
+      openaiChatSpy.mockRestore();
+      claudeChatSpy.mockRestore();
     });
 
     it("should handle jsonSchema and parse output", async () => {
@@ -113,12 +110,13 @@ describe("LlmProxyService", () => {
       };
       const options = { jsonSchema: mockJsonSchema };
       const mockResponse = { content: '{"foo":"bar"}', role: "assistant" };
-      claudeAdapter.chat.mockResolvedValue(mockResponse as any);
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue(mockResponse as any);
 
       const result = await service.chat(messages, options as any);
 
       expect(result.structuredOutput).toEqual(mockParsed);
       expect(mockJsonSchema.parse).toHaveBeenCalledWith(mockResponse.content);
+      chatSpy.mockRestore();
     });
   });
 
@@ -128,7 +126,9 @@ describe("LlmProxyService", () => {
       const mockStream = (async function* () {
         yield { type: "text", content: "hi" };
       })();
-      claudeAdapter.chatStream.mockReturnValue(mockStream as any);
+      const chatStreamSpy = vi
+        .spyOn(claudeAdapter, "chatStream")
+        .mockReturnValue(mockStream as any);
 
       const stream = service.chatStream(messages);
       const chunks: any[] = [];
@@ -137,13 +137,17 @@ describe("LlmProxyService", () => {
       }
 
       expect(chunks).toEqual([{ type: "text", content: "hi" }]);
-      expect(claudeAdapter.chatStream).toHaveBeenCalledWith(messages, undefined);
+      expect(chatStreamSpy).toHaveBeenCalledWith(messages, undefined);
+      chatStreamSpy.mockRestore();
     });
   });
 
   describe("chat with jsonSchema fallback", () => {
     it("should append jsonSchema prompt when adapter does not support jsonSchema", async () => {
-      claudeAdapter.isSupportJsonSchema.mockReturnValue(false);
+      const jsonSchemaSpy = vi.spyOn(claudeAdapter, "isSupportJsonSchema").mockReturnValue(false);
+      const chatSpy = vi
+        .spyOn(claudeAdapter, "chat")
+        .mockResolvedValue({ content: '{"foo":"bar"}' } as any);
       const mockJsonSchema = {
         parse: vi.fn().mockResolvedValue({ foo: "bar" }),
         getSchema: vi.fn(),
@@ -154,14 +158,16 @@ describe("LlmProxyService", () => {
         { role: "system", content: "你是助手" },
         { role: "user", content: "hello" },
       ] as any;
-      claudeAdapter.chat.mockResolvedValue({ content: '{"foo":"bar"}' } as any);
       const result = await service.chat(messages, { jsonSchema: mockJsonSchema } as any);
       expect(messages[0].content).toContain("请返回 JSON");
       expect(result.structuredOutput).toEqual({ foo: "bar" });
+      jsonSchemaSpy.mockRestore();
+      chatSpy.mockRestore();
     });
 
     it("should not append jsonSchema prompt if already matched", async () => {
-      claudeAdapter.isSupportJsonSchema.mockReturnValue(false);
+      const jsonSchemaSpy = vi.spyOn(claudeAdapter, "isSupportJsonSchema").mockReturnValue(false);
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue({ content: "{}" } as any);
       const mockJsonSchema = {
         parse: vi.fn().mockResolvedValue({}),
         getSchema: vi.fn(),
@@ -169,13 +175,15 @@ describe("LlmProxyService", () => {
         isMatched: vi.fn().mockReturnValue(true),
       };
       const messages = [{ role: "system", content: "已包含 JSON 指令" }] as any;
-      claudeAdapter.chat.mockResolvedValue({ content: "{}" } as any);
       await service.chat(messages, { jsonSchema: mockJsonSchema } as any);
       expect(messages[0].content).toBe("已包含 JSON 指令");
+      jsonSchemaSpy.mockRestore();
+      chatSpy.mockRestore();
     });
 
     it("should add system message if none exists", async () => {
-      claudeAdapter.isSupportJsonSchema.mockReturnValue(false);
+      const jsonSchemaSpy = vi.spyOn(claudeAdapter, "isSupportJsonSchema").mockReturnValue(false);
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue({ content: "{}" } as any);
       const mockJsonSchema = {
         parse: vi.fn().mockResolvedValue({}),
         getSchema: vi.fn(),
@@ -183,41 +191,44 @@ describe("LlmProxyService", () => {
         isMatched: vi.fn().mockReturnValue(false),
       };
       const messages = [{ role: "user", content: "hello" }] as any;
-      claudeAdapter.chat.mockResolvedValue({ content: "{}" } as any);
       await service.chat(messages, { jsonSchema: mockJsonSchema } as any);
       expect(messages[0].role).toBe("system");
       expect(messages[0].content).toBe("请返回 JSON");
+      jsonSchemaSpy.mockRestore();
+      chatSpy.mockRestore();
     });
 
     it("should not parse if response has no content", async () => {
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue({ content: "" } as any);
       const mockJsonSchema = {
         parse: vi.fn(),
         getSchema: vi.fn(),
       };
-      claudeAdapter.chat.mockResolvedValue({ content: "" } as any);
       const result = await service.chat(
         [{ role: "user", content: "hello" }] as any,
         { jsonSchema: mockJsonSchema } as any,
       );
       expect(mockJsonSchema.parse).not.toHaveBeenCalled();
       expect(result.structuredOutput).toBeUndefined();
+      chatSpy.mockRestore();
     });
 
     it("should not parse if structuredOutput already exists", async () => {
+      const chatSpy = vi.spyOn(claudeAdapter, "chat").mockResolvedValue({
+        content: "{}",
+        structuredOutput: { existing: true },
+      } as any);
       const mockJsonSchema = {
         parse: vi.fn(),
         getSchema: vi.fn(),
       };
-      claudeAdapter.chat.mockResolvedValue({
-        content: "{}",
-        structuredOutput: { existing: true },
-      } as any);
       const result = await service.chat(
         [{ role: "user", content: "hello" }] as any,
         { jsonSchema: mockJsonSchema } as any,
       );
       expect(mockJsonSchema.parse).not.toHaveBeenCalled();
       expect(result.structuredOutput).toEqual({ existing: true });
+      chatSpy.mockRestore();
     });
   });
 
@@ -230,7 +241,9 @@ describe("LlmProxyService", () => {
       const mockStream = (async function* () {
         yield { type: "result", response: { content: '{"parsed":true}' } };
       })();
-      claudeAdapter.chatStream.mockReturnValue(mockStream as any);
+      const chatStreamSpy = vi
+        .spyOn(claudeAdapter, "chatStream")
+        .mockReturnValue(mockStream as any);
       const chunks: any[] = [];
       for await (const chunk of service.chatStream(
         [{ role: "user", content: "hello" }] as any,
@@ -239,6 +252,7 @@ describe("LlmProxyService", () => {
         chunks.push(chunk);
       }
       expect(chunks[0].response.structuredOutput).toEqual({ parsed: true });
+      chatStreamSpy.mockRestore();
     });
 
     it("should handle jsonSchema parse error gracefully", async () => {
@@ -249,7 +263,9 @@ describe("LlmProxyService", () => {
       const mockStream = (async function* () {
         yield { type: "result", response: { content: "invalid json" } };
       })();
-      claudeAdapter.chatStream.mockReturnValue(mockStream as any);
+      const chatStreamSpy = vi
+        .spyOn(claudeAdapter, "chatStream")
+        .mockReturnValue(mockStream as any);
       const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
       const chunks: any[] = [];
       for await (const chunk of service.chatStream(
@@ -261,32 +277,39 @@ describe("LlmProxyService", () => {
       expect(consoleSpy).toHaveBeenCalled();
       expect(chunks[0].response.structuredOutput).toBeUndefined();
       consoleSpy.mockRestore();
+      chatStreamSpy.mockRestore();
     });
 
     it("should use specified adapter for chatStream", async () => {
       const mockStream = (async function* () {
         yield { type: "text", content: "hi" };
       })();
-      openaiAdapter.chatStream.mockReturnValue(mockStream as any);
+      const chatStreamSpy = vi
+        .spyOn(openaiAdapter, "chatStream")
+        .mockReturnValue(mockStream as any);
       const chunks: any[] = [];
       for await (const chunk of service.chatStream([{ role: "user", content: "hello" }] as any, {
         adapter: "openai",
       })) {
         chunks.push(chunk);
       }
-      expect(openaiAdapter.chatStream).toHaveBeenCalled();
+      expect(chatStreamSpy).toHaveBeenCalled();
+      chatStreamSpy.mockRestore();
     });
   });
 
   describe("getAvailableAdapters", () => {
     it("should return list of configured adapters", () => {
-      claudeAdapter.isConfigured.mockReturnValue(true);
-      openaiAdapter.isConfigured.mockReturnValue(false);
-      opencodeAdapter.isConfigured.mockReturnValue(false);
+      const claudeSpy = vi.spyOn(claudeAdapter, "isConfigured").mockReturnValue(true);
+      const openaiSpy = vi.spyOn(openaiAdapter, "isConfigured").mockReturnValue(false);
+      const opencodeSpy = vi.spyOn(opencodeAdapter, "isConfigured").mockReturnValue(false);
 
       const available = service.getAvailableAdapters();
 
       expect(available).toEqual(["claude-code"]);
+      claudeSpy.mockRestore();
+      openaiSpy.mockRestore();
+      opencodeSpy.mockRestore();
     });
 
     it("should return all adapters when all configured", () => {

package/src/shared/llm-proxy/llm-proxy.service.ts

@@ -1,4 +1,3 @@
-import { Injectable, Inject } from "@nestjs/common";
 import type { LlmAdapter } from "./adapters";
 import { ClaudeCodeAdapter } from "./adapters/claude-code.adapter";
 import { OpenAIAdapter } from "./adapters/openai.adapter";
@@ -19,16 +18,14 @@ export interface ChatOptions extends LlmRequestOptions {
   adapter?: LLMMode;
 }
 
-@Injectable()
 export class LlmProxyService {
   private adapters: Map<LLMMode, LlmAdapter> = new Map();
 
-  constructor(
-    @Inject("LLM_PROXY_CONFIG") private readonly config: LlmProxyConfig,
-    private readonly claudeCodeAdapter: ClaudeCodeAdapter,
-    private readonly openaiAdapter: OpenAIAdapter,
-    private readonly openCodeAdapter: OpenCodeAdapter,
-  ) {
+  constructor(private readonly config: LlmProxyConfig) {
+    // 适配器接收完整配置，内部自行读取所需部分
+    const claudeCodeAdapter = new ClaudeCodeAdapter(config);
+    const openaiAdapter = new OpenAIAdapter(config);
+    const openCodeAdapter = new OpenCodeAdapter(config);
     this.adapters.set("claude-code", claudeCodeAdapter);
     this.adapters.set("openai", openaiAdapter);
     this.adapters.set("open-code", openCodeAdapter);

package/src/shared/mcp/index.ts

@@ -27,7 +27,6 @@
  */
 
 import "reflect-metadata";
-import { Injectable } from "@nestjs/common";
 
 /** MCP 服务元数据 key（使用 Symbol 确保唯一性） */
 export const MCP_SERVER_METADATA = Symbol.for("spaceflow:mcp:server");
@@ -90,36 +89,7 @@ export function dtoToJsonSchema(dtoClass: new (...args: any[]) => any): JsonSche
     if (typeof schemaType === "function") {
       schemaType = typeMap[schemaType.name] || "string";
     }
-    // 如果 swagger 没有显式 type，从 class-validator 元数据推断
-    if (!schemaType) {
-      try {
-        const { getMetadataStorage } = require("class-validator");
-        const validationMetas = getMetadataStorage().getTargetValidationMetadatas(
-          dtoClass,
-          "",
-          false,
-          false,
-        );
-        const validatorTypeMap: Record<string, string> = {
-          isString: "string",
-          isNumber: "number",
-          isBoolean: "boolean",
-          isArray: "array",
-          isObject: "object",
-          isInt: "number",
-          isEnum: "string",
-        };
-        const propMeta = validationMetas.find(
-          (m: any) => m.propertyName === key && validatorTypeMap[m.name],
-        );
-        if (propMeta) {
-          schemaType = validatorTypeMap[propMeta.name];
-        }
-      } catch {
-        // class-validator 不可用时忽略
-      }
-    }
-    // 最后从 reflect-metadata 的 design:type 推断
+    // 从 reflect-metadata 的 design:type 推断
     if (!schemaType) {
       const reflectedType = Reflect.getMetadata("design:type", prototype, key);
       if (reflectedType) {
@@ -180,8 +150,6 @@ export interface McpToolMetadata extends McpToolDefinition {
  */
 export function McpServer(definition: McpServerDefinition): ClassDecorator {
   return (target: Function) => {
-    // 应用 @Injectable() 装饰器
-    Injectable()(target);
     // 使用静态属性存储元数据（跨模块可访问）
     (target as any).__mcp_server__ = definition;
   };

package/src/shared/output/index.ts

@@ -1,2 +1 @@
 export * from "./output.service";
-export * from "./output.module";

package/src/shared/output/output.service.ts

@@ -1,5 +1,5 @@
-import { Injectable, Scope } from "@nestjs/common";
 import { randomUUID } from "crypto";
+import type { IOutputService } from "../../extension-system/types";
 
 const OUTPUT_MARKER_START = "::spaceflow-output::";
 const OUTPUT_MARKER_END = "::end::";
@@ -16,20 +16,13 @@ const OUTPUT_MARKER_END = "::end::";
  *
  * 使用示例:
  * ```typescript
- * @Injectable()
- * export class MyService {
- *   constructor(protected readonly output: OutputService) {}
- *
- *   async execute() {
- *     // ... 执行逻辑
- *     this.output.set("version", "1.0.0");
- *     this.output.set("tag", "v1.0.0");
- *   }
- * }
+ * const output = new OutputService();
+ * output.set("version", "1.0.0");
+ * output.set("tag", "v1.0.0");
+ * output.flush();
  * ```
  */
-@Injectable({ scope: Scope.DEFAULT })
-export class OutputService {
+export class OutputService implements IOutputService {
   protected outputs: Record<string, string> = {};
   protected cacheId: string = randomUUID();
 
@@ -92,6 +85,43 @@ export class OutputService {
   getCacheId(): string {
     return this.cacheId;
   }
+
+  /**
+   * 输出信息
+   */
+  info(message: string): void {
+    console.log(message);
+  }
+
+  /**
+   * 输出成功信息
+   */
+  success(message: string): void {
+    console.log(`✅ ${message}`);
+  }
+
+  /**
+   * 输出警告
+   */
+  warn(message: string): void {
+    console.warn(`⚠️ ${message}`);
+  }
+
+  /**
+   * 输出错误
+   */
+  error(message: string): void {
+    console.error(`❌ ${message}`);
+  }
+
+  /**
+   * 输出调试信息
+   */
+  debug(message: string): void {
+    if (process.env.DEBUG) {
+      console.debug(`🔍 ${message}`);
+    }
+  }
 }
 
 export { OUTPUT_MARKER_START, OUTPUT_MARKER_END };

package/src/shared/rspack-config/rspack-config.ts

@@ -37,12 +37,6 @@ export interface CorePathOptions {
 export const DEFAULT_EXTERNALS: Configuration["externals"] = [
   // Spaceflow 核心 - 运行时从 core 加载
   { "@spaceflow/core": "module @spaceflow/core" },
-  // NestJS 相关 - 这些由 core 提供
-  { "@nestjs/common": "module @nestjs/common" },
-  { "@nestjs/config": "module @nestjs/config" },
-  { "@nestjs/core": "module @nestjs/core" },
-  { "nest-commander": "module nest-commander" },
-  { "reflect-metadata": "module reflect-metadata" },
   // 排除所有 node_modules（除了相对路径和 src/ 别名）
   /^(?!\.\/|\.\.\/|src\/)[^./]/,
 ];

package/src/shared/storage/index.ts

@@ -1,4 +1,3 @@
-export * from "./storage.module";
 export * from "./storage.service";
 export * from "./types";
 export * from "./adapters";

package/src/shared/storage/storage.service.ts

@@ -1,6 +1,15 @@
-import { Inject, Injectable, OnModuleDestroy } from "@nestjs/common";
 import { type StorageAdapter } from "./adapters/storage-adapter.interface";
-import { STORAGE_ADAPTER, STORAGE_MODULE_OPTIONS, type StorageModuleOptions } from "./types";
+import type { IStorageService } from "../../extension-system/types";
+
+/**
+ * Storage 服务配置选项
+ */
+export interface StorageServiceOptions {
+  /** 默认过期时间（毫秒），0 表示永不过期 */
+  defaultTtl?: number;
+  /** 最大 key 数量，超过时会淘汰最早过期的 key，0 或 undefined 表示不限制 */
+  maxKeys?: number;
+}
 
 /**
  * Storage 服务
@@ -10,21 +19,18 @@ import { STORAGE_ADAPTER, STORAGE_MODULE_OPTIONS, type StorageModuleOptions } fr
  * - user:123:profile
  * - cache:api:users
  */
-@Injectable()
-export class StorageService implements OnModuleDestroy {
+export class StorageService implements IStorageService {
   protected cleanupTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(
-    @Inject(STORAGE_ADAPTER)
     protected readonly adapter: StorageAdapter,
-    @Inject(STORAGE_MODULE_OPTIONS)
-    protected readonly options: StorageModuleOptions,
+    protected readonly options: StorageServiceOptions = {},
   ) {
     // 启动定期清理过期项的定时器
     this.startCleanupTimer();
   }
 
-  onModuleDestroy() {
+  destroy(): void {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -39,6 +45,8 @@ export class StorageService implements OnModuleDestroy {
     this.cleanupTimer = setInterval(() => {
       this.cleanup().catch(console.error);
     }, 60 * 1000);
+    // 使用 unref() 让定时器不阻止进程退出
+    this.cleanupTimer.unref();
   }
 
   /**

package/src/shared/storage/types.ts

@@ -1,37 +1,3 @@
-/**
- * Storage 模块配置选项
- */
-export interface StorageModuleOptions {
-  /**
-   * 适配器类型
-   */
-  adapter: "memory" | "file";
-
-  /**
-   * 文件适配器的存储路径（仅 file 适配器需要）
-   */
-  filePath?: string;
-
-  /**
-   * 默认过期时间（毫秒），0 表示永不过期
-   */
-  defaultTtl?: number;
-
-  /**
-   * 最大 key 数量，超过时会淘汰最早过期的 key
-   * 0 或 undefined 表示不限制
-   */
-  maxKeys?: number;
-}
-
-/**
- * 异步模块配置选项
- */
-export interface StorageModuleAsyncOptions {
-  useFactory: (...args: any[]) => Promise<StorageModuleOptions> | StorageModuleOptions;
-  inject?: any[];
-}
-
 /**
  * 存储项元数据
  */
@@ -39,13 +5,3 @@ export interface StorageItem<T = any> {
   value: T;
   expireAt?: number; // 过期时间戳，undefined 表示永不过期
 }
-
-/**
- * 模块配置注入 Token
- */
-export const STORAGE_MODULE_OPTIONS = Symbol("STORAGE_MODULE_OPTIONS");
-
-/**
- * 适配器注入 Token
- */
-export const STORAGE_ADAPTER = Symbol("STORAGE_ADAPTER");

package/src/shared/verbose/index.ts

@@ -71,3 +71,18 @@ export function shouldLog(
 ): boolean {
   return normalizeVerbose(verbose) >= requiredLevel;
 }
+
+/**
+ * 解析命令行 verbose 参数
+ * 支持: -v, -v 2, -v 3, --verbose, --verbose 2, -vvv (计数模式)
+ * @param val 命令行参数值（字符串、布尔值、数字或 undefined）
+ * @returns 规范化后的 VerboseLevel
+ */
+export function parseVerbose(val: string | boolean | number | undefined): 0 | 1 | 2 | 3 {
+  if (val === undefined || val === 0) return 1;
+  if (val === true || val === "") return 1;
+  if (typeof val === "number") return normalizeVerbose(val as VerboseLevel);
+  const level = parseInt(val as string, 10);
+  if (isNaN(level)) return 1;
+  return normalizeVerbose(level as VerboseLevel);
+}

package/src/app.module.ts

@@ -1,18 +0,0 @@
-import { Module } from "@nestjs/common";
-import { StorageModule } from "./shared/storage/storage.module";
-import { OutputModule } from "./shared/output";
-import { ConfigModule } from "@nestjs/config";
-import { configLoaders, getEnvFilePaths } from "./config";
-
-@Module({
-  imports: [
-    ConfigModule.forRoot({
-      isGlobal: true,
-      load: configLoaders,
-      envFilePath: getEnvFilePaths(),
-    }),
-    StorageModule.forFeature(),
-    OutputModule,
-  ],
-})
-export class AppModule {}