@spaceflow/core 0.1.3 → 0.3.0

package/src/config/config-reader.module.ts

@@ -1,16 +0,0 @@
-import { Global, Module } from "@nestjs/common";
-import { ConfigReaderService } from "./config-reader.service";
-import { SchemaGeneratorService } from "./schema-generator.service";
-
-/**
- * 配置读取模块
- * 提供插件配置读取服务和 Schema 生成服务
- *
- * 插件的 defaultConfig 通过 getMetadata() 返回，在插件加载时自动注册
- */
-@Global()
-@Module({
-  providers: [ConfigReaderService, SchemaGeneratorService],
-  exports: [ConfigReaderService, SchemaGeneratorService],
-})
-export class ConfigReaderModule {}

package/src/shared/claude-setup/claude-setup.module.ts

@@ -1,8 +0,0 @@
-import { Module } from "@nestjs/common";
-import { ClaudeSetupService } from "./claude-setup.service";
-
-@Module({
-  providers: [ClaudeSetupService],
-  exports: [ClaudeSetupService],
-})
-export class ClaudeSetupModule {}

package/src/shared/feishu-sdk/feishu-sdk.module.ts

@@ -1,77 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ConfigModule, ConfigService } from "@nestjs/config";
-import { EventEmitterModule } from "@nestjs/event-emitter";
-import { FeishuSdkService } from "./feishu-sdk.service";
-import { FeishuCardService } from "./fieshu-card.service";
-import { FeishuModuleOptions, FeishuModuleAsyncOptions, FEISHU_MODULE_OPTIONS } from "./types";
-import { feishuConfig, FeishuConfig } from "../../config";
-
-@Module({})
-export class FeishuSdkModule {
-  /**
-   * 同步注册模块
-   */
-  static forRoot(options: FeishuModuleOptions): DynamicModule {
-    return {
-      module: FeishuSdkModule,
-      imports: [EventEmitterModule.forRoot()],
-      providers: [
-        {
-          provide: FEISHU_MODULE_OPTIONS,
-          useValue: options,
-        },
-        FeishuSdkService,
-        FeishuCardService,
-      ],
-      exports: [FeishuSdkService, FeishuCardService],
-    };
-  }
-
-  /**
-   * 异步注册模块 - 支持从环境变量等动态获取配置
-   */
-  static forRootAsync(options: FeishuModuleAsyncOptions): DynamicModule {
-    return {
-      module: FeishuSdkModule,
-      imports: [EventEmitterModule.forRoot()],
-      providers: [
-        {
-          provide: FEISHU_MODULE_OPTIONS,
-          useFactory: options.useFactory,
-          inject: options.inject || [],
-        },
-        FeishuSdkService,
-        FeishuCardService,
-      ],
-      exports: [FeishuSdkService, FeishuCardService],
-    };
-  }
-
-  /**
-   * 使用 ConfigService 注册模块
-   */
-  static forFeature(): DynamicModule {
-    return {
-      module: FeishuSdkModule,
-      imports: [ConfigModule.forFeature(feishuConfig), EventEmitterModule.forRoot()],
-      providers: [
-        {
-          provide: FEISHU_MODULE_OPTIONS,
-          useFactory: (configService: ConfigService): FeishuModuleOptions => {
-            const config = configService.get<FeishuConfig>("feishu");
-            return {
-              appId: config?.appId || "",
-              appSecret: config?.appSecret || "",
-              appType: config?.appType,
-              domain: config?.domain,
-            };
-          },
-          inject: [ConfigService],
-        },
-        FeishuSdkService,
-        FeishuCardService,
-      ],
-      exports: [FeishuSdkService, FeishuCardService],
-    };
-  }
-}

package/src/shared/git-provider/git-provider.module.ts

@@ -1,73 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ConfigModule, ConfigService } from "@nestjs/config";
-import { GitProviderService } from "./git-provider.service";
-import {
-  type GitProviderModuleOptions,
-  type GitProviderModuleAsyncOptions,
-  GIT_PROVIDER_MODULE_OPTIONS,
-} from "./types";
-import { gitProviderConfig, type GitProviderConfig } from "../../config/git-provider.config";
-
-@Module({})
-export class GitProviderModule {
-  /**
-   * 同步注册模块
-   */
-  static forRoot(options: GitProviderModuleOptions): DynamicModule {
-    return {
-      module: GitProviderModule,
-      providers: [
-        {
-          provide: GIT_PROVIDER_MODULE_OPTIONS,
-          useValue: options,
-        },
-        GitProviderService,
-      ],
-      exports: [GitProviderService],
-    };
-  }
-
-  /**
-   * 异步注册模块 - 支持从环境变量等动态获取配置
-   */
-  static forRootAsync(options: GitProviderModuleAsyncOptions): DynamicModule {
-    return {
-      module: GitProviderModule,
-      providers: [
-        {
-          provide: GIT_PROVIDER_MODULE_OPTIONS,
-          useFactory: options.useFactory,
-          inject: options.inject || [],
-        },
-        GitProviderService,
-      ],
-      exports: [GitProviderService],
-    };
-  }
-
-  /**
-   * 使用 ConfigService 注册模块
-   */
-  static forFeature(): DynamicModule {
-    return {
-      module: GitProviderModule,
-      imports: [ConfigModule.forFeature(gitProviderConfig)],
-      providers: [
-        {
-          provide: GIT_PROVIDER_MODULE_OPTIONS,
-          useFactory: (configService: ConfigService): GitProviderModuleOptions => {
-            const config = configService.get<GitProviderConfig>("gitProvider");
-            return {
-              provider: config?.provider || "gitea",
-              baseUrl: config?.serverUrl || "",
-              token: config?.token || "",
-            };
-          },
-          inject: [ConfigService],
-        },
-        GitProviderService,
-      ],
-      exports: [GitProviderService],
-    };
-  }
-}

package/src/shared/git-sdk/git-sdk.module.ts

@@ -1,8 +0,0 @@
-import { Module } from "@nestjs/common";
-import { GitSdkService } from "./git-sdk.service";
-
-@Module({
-  providers: [GitSdkService],
-  exports: [GitSdkService],
-})
-export class GitSdkModule {}

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

@@ -1,140 +0,0 @@
-import { Module, DynamicModule, Provider, Type } from "@nestjs/common";
-import { LlmProxyService } from "./llm-proxy.service";
-import { ClaudeCodeAdapter } from "./adapters/claude-code.adapter";
-import { OpenAIAdapter } from "./adapters/openai.adapter";
-import { ClaudeSetupModule } from "../claude-setup";
-import type { LlmProxyConfig } from "./interfaces";
-import { OpenCodeAdapter } from "./adapters";
-
-export interface LlmProxyModuleOptions extends LlmProxyConfig {}
-
-export interface LlmProxyModuleAsyncOptions {
-  imports?: any[];
-  useFactory?: (...args: any[]) => Promise<LlmProxyConfig> | LlmProxyConfig;
-  inject?: any[];
-  useClass?: Type<LlmProxyOptionsFactory>;
-  useExisting?: Type<LlmProxyOptionsFactory>;
-}
-
-export interface LlmProxyOptionsFactory {
-  createLlmProxyOptions(): Promise<LlmProxyConfig> | LlmProxyConfig;
-}
-
-@Module({})
-export class LlmProxyModule {
-  static forRoot(options: LlmProxyModuleOptions): DynamicModule {
-    const resolvedOptions = this.resolveOpenCodeConfig(options);
-    return {
-      module: LlmProxyModule,
-      imports: [ClaudeSetupModule],
-      providers: [
-        {
-          provide: "LLM_PROXY_CONFIG",
-          useValue: resolvedOptions,
-        },
-        ClaudeCodeAdapter,
-        OpenAIAdapter,
-        OpenCodeAdapter,
-        LlmProxyService,
-      ],
-      exports: [LlmProxyService, ClaudeCodeAdapter, OpenCodeAdapter, OpenAIAdapter],
-    };
-  }
-
-  static forRootAsync(options: LlmProxyModuleAsyncOptions): DynamicModule {
-    const asyncProviders = this.createAsyncProviders(options);
-
-    return {
-      module: LlmProxyModule,
-      imports: [...(options.imports || []), ClaudeSetupModule],
-      providers: [
-        ...asyncProviders,
-        ClaudeCodeAdapter,
-        OpenAIAdapter,
-        OpenCodeAdapter,
-        LlmProxyService,
-      ],
-      exports: [LlmProxyService, ClaudeCodeAdapter, OpenCodeAdapter, OpenAIAdapter],
-    };
-  }
-
-  private static createAsyncProviders(options: LlmProxyModuleAsyncOptions): Provider[] {
-    if (options.useFactory) {
-      const originalFactory = options.useFactory;
-      return [
-        {
-          provide: "LLM_PROXY_CONFIG",
-          useFactory: async (...args: any[]) => {
-            const config = await originalFactory(...args);
-            return this.resolveOpenCodeConfig(config);
-          },
-          inject: options.inject || [],
-        },
-      ];
-    }
-
-    if (options.useClass) {
-      return [
-        {
-          provide: "LLM_PROXY_CONFIG",
-          useFactory: async (optionsFactory: LlmProxyOptionsFactory) =>
-            optionsFactory.createLlmProxyOptions(),
-          inject: [options.useClass],
-        },
-        {
-          provide: options.useClass,
-          useClass: options.useClass,
-        },
-      ];
-    }
-
-    if (options.useExisting) {
-      return [
-        {
-          provide: "LLM_PROXY_CONFIG",
-          useFactory: async (optionsFactory: LlmProxyOptionsFactory) =>
-            optionsFactory.createLlmProxyOptions(),
-          inject: [options.useExisting],
-        },
-      ];
-    }
-
-    return [];
-  }
-
-  private static resolveOpenCodeConfig(config: LlmProxyConfig): LlmProxyConfig {
-    if (!config.openCode) {
-      return config;
-    }
-
-    const providerID = config.openCode.providerID || "openai";
-    let apiKey = config.openCode.apiKey;
-    let baseUrl = config.openCode.baseUrl;
-    let model = config.openCode.model;
-
-    // 根据 providerID 从对应的 adapter 配置中读取缺失的值
-    if (providerID === "openai" && config.openai) {
-      if (!apiKey) apiKey = config.openai.apiKey;
-      if (!baseUrl) baseUrl = config.openai.baseUrl;
-      if (!model) model = config.openai.model;
-    } else if (providerID === "anthropic" && config.claudeCode) {
-      if (!apiKey) apiKey = config.claudeCode.authToken;
-      if (!baseUrl) baseUrl = config.claudeCode.baseUrl;
-      if (!model) model = config.claudeCode.model;
-    }
-
-    // 如果有任何值需要更新
-    if (
-      apiKey !== config.openCode.apiKey ||
-      baseUrl !== config.openCode.baseUrl ||
-      model !== config.openCode.model
-    ) {
-      return {
-        ...config,
-        openCode: { ...config.openCode, apiKey, baseUrl, model },
-      };
-    }
-
-    return config;
-  }
-}

package/src/shared/output/output.module.ts

@@ -1,9 +0,0 @@
-import { Global, Module } from "@nestjs/common";
-import { OutputService } from "./output.service";
-
-@Global()
-@Module({
-  providers: [OutputService],
-  exports: [OutputService],
-})
-export class OutputModule {}

package/src/shared/storage/storage.module.ts

@@ -1,150 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ConfigModule, ConfigService } from "@nestjs/config";
-import { StorageService } from "./storage.service";
-import { MemoryAdapter } from "./adapters/memory.adapter";
-import { FileAdapter } from "./adapters/file.adapter";
-import { StorageAdapter } from "./adapters/storage-adapter.interface";
-import {
-  type StorageModuleOptions,
-  type StorageModuleAsyncOptions,
-  STORAGE_MODULE_OPTIONS,
-  STORAGE_ADAPTER,
-} from "./types";
-import { storageConfig, StorageConfig } from "../../config";
-
-/**
- * 创建适配器实例
- */
-function createAdapter(options: StorageModuleOptions): StorageAdapter {
-  switch (options.adapter) {
-    case "file":
-      if (!options.filePath) {
-        throw new Error("filePath is required for file adapter");
-      }
-      return new FileAdapter(options.filePath);
-    case "memory":
-    default:
-      return new MemoryAdapter();
-  }
-}
-
-@Module({})
-export class StorageModule {
-  /**
-   * 同步注册模块
-   *
-   * @example
-   * ```ts
-   * StorageModule.forRoot({
-   *   adapter: 'memory',
-   *   defaultTtl: 3600000, // 1 hour
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * StorageModule.forRoot({
-   *   adapter: 'file',
-   *   filePath: './data/storage.json',
-   * })
-   * ```
-   */
-  static forRoot(options: StorageModuleOptions): DynamicModule {
-    return {
-      module: StorageModule,
-      providers: [
-        {
-          provide: STORAGE_MODULE_OPTIONS,
-          useValue: options,
-        },
-        {
-          provide: STORAGE_ADAPTER,
-          useValue: createAdapter(options),
-        },
-        StorageService,
-      ],
-      exports: [StorageService],
-    };
-  }
-
-  /**
-   * 异步注册模块
-   *
-   * @example
-   * ```ts
-   * StorageModule.forRootAsync({
-   *   useFactory: (configService: ConfigService) => ({
-   *     adapter: configService.get('STORAGE_ADAPTER') || 'memory',
-   *     filePath: configService.get('STORAGE_FILE_PATH'),
-   *   }),
-   *   inject: [ConfigService],
-   * })
-   * ```
-   */
-  static forRootAsync(options: StorageModuleAsyncOptions): DynamicModule {
-    return {
-      module: StorageModule,
-      providers: [
-        {
-          provide: STORAGE_MODULE_OPTIONS,
-          useFactory: options.useFactory,
-          inject: options.inject || [],
-        },
-        {
-          provide: STORAGE_ADAPTER,
-          useFactory: (opts: StorageModuleOptions) => createAdapter(opts),
-          inject: [STORAGE_MODULE_OPTIONS],
-        },
-        StorageService,
-      ],
-      exports: [StorageService],
-    };
-  }
-
-  /**
-   * 使用 ConfigService 注册模块
-   *
-   * 环境变量：
-   * - STORAGE_ADAPTER: 'memory' | 'file'
-   * - STORAGE_FILE_PATH: 文件存储路径
-   * - STORAGE_DEFAULT_TTL: 默认过期时间（毫秒）
-   * - STORAGE_MAX_KEYS: 最大 key 数量
-   *
-   * @example
-   * ```ts
-   * @Module({
-   *   imports: [StorageModule.forFeature()],
-   * })
-   * export class AppModule {}
-   * ```
-   */
-  static forFeature(): DynamicModule {
-    return {
-      global: true,
-      module: StorageModule,
-      imports: [ConfigModule.forFeature(storageConfig)],
-      providers: [
-        {
-          provide: STORAGE_MODULE_OPTIONS,
-          useFactory: (configService: ConfigService): StorageModuleOptions => {
-            const config = configService.get<StorageConfig>("storage");
-            return {
-              adapter: config?.adapter || "memory",
-              filePath: config?.filePath,
-              defaultTtl: config?.defaultTtl,
-              maxKeys: config?.maxKeys,
-            };
-          },
-          inject: [ConfigService],
-        },
-        {
-          provide: STORAGE_ADAPTER,
-          useFactory: (opts: StorageModuleOptions) => createAdapter(opts),
-          inject: [STORAGE_MODULE_OPTIONS],
-        },
-        StorageService,
-      ],
-      exports: [StorageService],
-    };
-  }
-}