sonamu 0.7.11 → 0.7.13

package/src/naite/messaging-types.ts

@@ -5,47 +5,46 @@
  * 이 파일은 cartanova-ai/sonamu와 cartanova-ai/vscode-sonamu에서 공통으로 사용됩니다.
  */
 export namespace NaiteMessagingTypes {
-    export type NaiteRunStartMessage = {
-      type: "run/start";
-      startedAt: string;
-    };
-  
-    export type NaiteTestResultMessage = {
-      type: "test/result";
-      receivedAt: string;
-    } & TestResult;
-  
-    export type NaiteRunEndMessage = {
-      type: "run/end";
-      endedAt: string;
-    };
-  
-    export type NaiteMessage = NaiteRunStartMessage | NaiteTestResultMessage | NaiteRunEndMessage;
-  
-    export type NaiteTrace = {
-      key: string;
-      value: any;
-      filePath: string;
-      lineNumber: number;
-      at: string;
-    };
-  
-    export type TestError = {
-      message: string;
-      stack?: string;
-    };
-  
-    export type TestResult = {
-      suiteName: string;
-      suiteFilePath?: string;
-      testName: string;
-      testFilePath: string;
-      testLine: number;
-      status: string;
-      duration: number;
-      error?: TestError;
-      traces: NaiteTrace[];
-      receivedAt: string;
-    };
-  }
-  
+  export type NaiteRunStartMessage = {
+    type: "run/start";
+    startedAt: string;
+  };
+
+  export type NaiteTestResultMessage = {
+    type: "test/result";
+    receivedAt: string;
+  } & TestResult;
+
+  export type NaiteRunEndMessage = {
+    type: "run/end";
+    endedAt: string;
+  };
+
+  export type NaiteMessage = NaiteRunStartMessage | NaiteTestResultMessage | NaiteRunEndMessage;
+
+  export type NaiteTrace = {
+    key: string;
+    value: any;
+    filePath: string;
+    lineNumber: number;
+    at: string;
+  };
+
+  export type TestError = {
+    message: string;
+    stack?: string;
+  };
+
+  export type TestResult = {
+    suiteName: string;
+    suiteFilePath?: string;
+    testName: string;
+    testFilePath: string;
+    testLine: number;
+    status: string;
+    duration: number;
+    error?: TestError;
+    traces: NaiteTrace[];
+    receivedAt: string;
+  };
+}

package/src/naite/naite.ts

@@ -349,7 +349,7 @@ export class NaiteClass {
     // 이로 인해 "직렬화 가능한 값들만 허용"하는 제약이 생깁니다.
     //
     // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.
-    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다. 
+    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다.
     // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,
     for (const trace of traces) {
       const check = isSerializable(trace.data);

package/src/shared/app.shared.ts.txt

@@ -180,6 +180,19 @@ export type ListResult<LP extends { queryMode?: SonamuQueryMode }, T> = LP["quer
 export const SonamuQueryMode = z.enum(["both", "list", "count"]);
 export type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
 
+/* Semantic Query */
+export const SonamuSemanticParams = z
+  .object({
+    semanticQuery: z.object({
+      embedding: z.array(z.number()).min(1024).max(1024),
+      threshold: z.number().optional(),
+      method: z.enum(["cosine", "l2", "inner_product"]).optional(),
+      which: z.string(),
+    }),
+  })
+  .partial();
+export type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;
+
 /*
   SWR
 */

package/src/shared/web.shared.ts.txt

@@ -95,6 +95,19 @@ export type ListResult<LP extends { queryMode?: SonamuQueryMode }, T> = LP["quer
 export const SonamuQueryMode = z.enum(["both", "list", "count"]);
 export type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
 
+/* Semantic Query */
+export const SonamuSemanticParams = z
+  .object({
+    semanticQuery: z.object({
+      embedding: z.array(z.number()).min(1024).max(1024),
+      threshold: z.number().optional(),
+      method: z.enum(["cosine", "l2", "inner_product"]).optional(),
+      which: z.string(),
+    }),
+  })
+  .partial();
+export type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;
+
 /*
   SWR
 */

package/src/stream/sse.ts

@@ -6,11 +6,23 @@ export function createSSEFactory<T extends z.ZodObject>(
   socket: FastifyRequest["socket"],
   reply: FastifyReply,
   _events: T,
-) {
-  return new SSEConnection<T>(socket, reply);
+): SSEConnection<T> {
+  return new SSEConnectionImpl<T>(socket, reply);
 }
 
-class SSEConnection<T extends z.ZodObject> {
+export function createMockSSEFactory<T extends z.ZodObject>(_events: T): SSEConnection<T> {
+  return {
+    publish: (_event, _data) => {},
+    end: () => Promise.resolve(),
+  };
+}
+
+export interface SSEConnection<T extends z.ZodObject> {
+  publish<K extends keyof z.infer<T>>(event: K, data: z.infer<T>[K]): void;
+  end(): Promise<void>;
+}
+
+class SSEConnectionImpl<T extends z.ZodObject> implements SSEConnection<T> {
   private _closed = false;
 
   constructor(

package/src/syncer/api-parser.ts

@@ -98,7 +98,8 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
     // const p = path.join(tmpdir(), "sonamu-syncer-error.json");
     // writeFileSync(p, JSON.stringify(registeredApis, null, 2));
     // execSync(`open ${p}`);
-    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    // throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    return [];
   }
 
   // 등록된 API에 현재 메소드 타입 정보 확장
@@ -229,6 +230,10 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
         };
       }
       break;
+    case ts.SyntaxKind.ParenthesizedType:
+      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))
+      // 내부 타입을 재귀적으로 resolve
+      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);
     case undefined:
       throw new Error(`typeNode undefined`);
   }

package/src/syncer/file-patterns.ts

@@ -3,13 +3,14 @@ import { Sonamu } from "../api/sonamu";
 import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
 
 export type FileType =
-  | "model"
-  | "types"
-  | "functions"
-  | "generated"
+  | "config"
   | "entity"
   | "frame"
-  | "config";
+  | "functions"
+  | "generated"
+  | "model"
+  | "types"
+  | "workflow";
 
 export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
   [key in FileType]: T;
@@ -24,13 +25,14 @@ export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
  * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
  */
 export const checksumPatternGroup: GlobPattern<ApiRelativePath> = {
+  config: "src/sonamu.config.ts",
   entity: "src/application/**/*.entity.json",
-  types: "src/application/**/*.types.ts",
-  generated: "src/application/sonamu.generated.ts",
-  model: "src/application/**/*.model.ts",
   frame: "src/application/**/*.frame.ts",
   functions: "src/application/**/*.functions.ts",
-  config: "src/sonamu.config.ts",
+  generated: "src/application/sonamu.generated.ts",
+  model: "src/application/**/*.model.ts",
+  types: "src/application/**/*.types.ts",
+  workflow: "src/application/**/*.workflow.ts",
 };
 
 /**

package/src/syncer/module-loader.ts

@@ -4,6 +4,7 @@ import type { BaseFrameClass } from "../api/base-frame";
 import type { ApiDecoratorOptions } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
 import type { BaseModelClass } from "../database/base-model";
+import type { WorkflowMetadata } from "../tasks/decorator";
 import type { ApiParam, ApiParamType } from "../types/types";
 import { globAsync } from "../utils/async-utils";
 import { importMembers } from "../utils/esm-utils";
@@ -126,3 +127,37 @@ export async function loadTypes(): Promise<LoadedTypes> {
 
   return types;
 }
+
+/**
+ * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
+ */
+export async function loadWorkflows() {
+  const workflowPathsPattern = path.join(
+    Sonamu.apiRootPath,
+    runtimePath("src/application/**/*.workflow.ts"),
+  );
+  const workflowPaths = await globAsync(workflowPathsPattern);
+  const workflows: Map<string, WorkflowMetadata[]> = new Map();
+  for (const filePath of workflowPaths) {
+    const importedMembers = await importMembers(filePath);
+    workflows.set(
+      filePath,
+      importedMembers
+        .filter(({ value }) => {
+          return (
+            typeof value === "object" &&
+            value !== null &&
+            "type" in value &&
+            value.type === "workflow" &&
+            "fn" in value &&
+            typeof value.fn === "function"
+          );
+        })
+        .map(({ value }) => {
+          return value as WorkflowMetadata;
+        }),
+    );
+  }
+
+  return workflows;
+}

package/src/syncer/syncer.ts

@@ -1,12 +1,14 @@
 import { hot } from "@sonamu-kit/hmr-hook";
 import assert from "assert";
 import chalk from "chalk";
+import { EventEmitter } from "events";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import inflection from "inflection";
 import { minimatch } from "minimatch";
 import path, { dirname } from "path";
 import { group, unique } from "radashi";
 import type { z } from "zod";
+import type { WorkflowMetadata } from "..";
 import { registeredApis } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
 import { EntityManager, type EntityNamesRecord } from "../entity/entity-manager";
@@ -31,6 +33,7 @@ import {
   loadApis,
   loadModels,
   loadTypes,
+  loadWorkflows,
 } from "./module-loader";
 
 type DiffGroups = {
@@ -41,7 +44,9 @@ export class Syncer {
   apis: LoadedApis = [];
   types: LoadedTypes = {};
   models: LoadedModels = {};
+  workflows: Map<string, WorkflowMetadata[]> = new Map();
   isSyncing: boolean = false;
+  eventEmitter: EventEmitter = new EventEmitter();
 
   /**
    * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
@@ -97,17 +102,24 @@ export class Syncer {
         console.log(chalk.bold(`🔄 Invalidated:`));
 
         for (const invalidatedPath of invalidatedPaths) {
-          // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
-          // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
-          // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
-          const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
-          if (removedApis.length > 0) {
-            console.log(
-              chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),
-              chalk.gray(`(with ${removedApis.length} APIs)`),
+          try {
+            // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
+            // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
+            // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
+            const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
+            if (removedApis.length > 0) {
+              console.log(
+                chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),
+                chalk.gray(`(with ${removedApis.length} APIs)`),
+              );
+            } else {
+              console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
+            }
+          } catch (e) {
+            console.error(e);
+            console.error(
+              chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),
             );
-          } else {
-            console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
           }
         }
       }
@@ -127,8 +139,9 @@ export class Syncer {
     await this.autoloadTypes();
     await this.autoloadModels();
     await this.autoloadApis();
+    await this.autoloadWorkflows();
 
-    this.syncUI();
+    this.eventEmitter.emit("onHMRCompleted");
   }
 
   removeInvalidatedRegisteredApis(
@@ -199,6 +212,11 @@ export class Syncer {
     this.apis = await loadApis();
   }
 
+  async autoloadWorkflows() {
+    this.workflows = await loadWorkflows();
+    await Sonamu.workflows.synchronize(this.workflows);
+  }
+
   /**
    * 실제 싱크를 수행하는 본체입니다.
    * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
@@ -235,6 +253,11 @@ export class Syncer {
       await this.actionSyncConfig();
     }
 
+    // 트리거: workflow
+    if (diffTypes.includes("workflow")) {
+      await this.autoloadWorkflows();
+    }
+
     return {
       diffTypes,
     };
@@ -537,16 +560,6 @@ export class Syncer {
     );
   }
 
-  syncUI() {
-    const uiPort = Sonamu.config.ui?.port ?? 57000;
-
-    if (!isTest()) {
-      fetch(`http://127.0.0.1:${uiPort}/api/reload`, {
-        method: "GET",
-      }).catch((e) => console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`)));
-    }
-  }
-
   /**
    * 하위호환용 프록시 메소드입니다.
    */

package/src/tasks/decorator.ts

@@ -0,0 +1,71 @@
+import { randomUUID } from "node:crypto";
+import type {
+  SchemaInput,
+  SchemaOutput,
+  StandardSchemaV1,
+  WorkflowSpec,
+} from "@sonamu-kit/tasks/internal";
+import inflection from "inflection";
+import type { Executable } from "../types/types";
+import type { WorkflowFunction } from "./workflow-manager";
+
+// 워크플로우의 메타데이터 객체
+export interface WorkflowMetadata {
+  type: "workflow";
+  id: string;
+  name: string;
+  version: string | null;
+  schema: StandardSchemaV1<unknown, unknown> | undefined;
+  schedules: {
+    name: string;
+    expression: string;
+    input: Executable<SchemaInput<unknown, unknown> | undefined>;
+  }[];
+  fn: WorkflowFunction<unknown, unknown>;
+}
+
+// 워크플로우 정의 과정에서의 옵션
+export type DefineWorkflowOptions<
+  Input,
+  Output,
+  TSchema extends StandardSchemaV1 | undefined = undefined,
+> = Omit<
+  WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>,
+  "name"
+> & {
+  name?: string;
+  schedules?: {
+    name?: string;
+    expression: string;
+    input?: Executable<SchemaInput<TSchema, Input> | undefined>;
+  }[];
+};
+
+// 워크플로우 정의를 위한 데코레이터,
+// 이것들은 syncer에서 한번에 load한 다음, WorkflowManager에서 synchronize를 통해 등록됨.
+export function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(
+  options: DefineWorkflowOptions<Input, Output, TSchema>,
+) {
+  return (fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => {
+    const id = randomUUID();
+    const workflowName = options.name ?? inflection.underscore(fn.name);
+
+    const decorated: WorkflowMetadata = {
+      type: "workflow" as const,
+      id,
+      name: workflowName,
+      schema: options.schema,
+      version: options.version ?? null,
+      schedules: (options.schedules ?? []).map((schedule) => {
+        return {
+          name: schedule.name ?? `${workflowName}[${schedule.expression}]`,
+          expression: schedule.expression,
+          input: schedule.input,
+        };
+      }),
+      fn: fn as WorkflowFunction<unknown, unknown>,
+    };
+
+    return decorated;
+  };
+}

package/src/tasks/step-wrapper.ts

@@ -0,0 +1,84 @@
+import type { DurationString, StepApi } from "@sonamu-kit/tasks/internal";
+import inflection from "inflection";
+
+export type StepFunction<TArgs extends unknown[], TResult> = (...args: TArgs) => TResult;
+export type RunnableStep<TArgs extends unknown[], TResult> = {
+  run: StepFunction<TArgs, Promise<TResult>>;
+};
+
+export type MethodNames<T, TKey extends keyof T> = T[TKey] extends (
+  ...args: infer _TArgs
+) => infer _TResult
+  ? TKey
+  : never;
+
+export type MethodArguments<T, TKey extends keyof T> = T[TKey] extends (
+  ...args: infer TArgs
+) => unknown
+  ? TArgs
+  : never;
+
+export type MethodReturnType<T, TKey extends keyof T> = T[TKey] extends (
+  this: T,
+  ...args: infer _TArgs
+) => infer TResult
+  ? TResult
+  : never;
+
+export class StepWrapper {
+  readonly #stepApi: StepApi;
+
+  constructor(stepApi: StepApi) {
+    this.#stepApi = stepApi;
+  }
+
+  get<
+    T,
+    TKey extends keyof T,
+    TArgs extends MethodArguments<T, TKey>,
+    TResult extends MethodReturnType<T, TKey>,
+  >(config: { name: string }, object: T, name: MethodNames<T, TKey>): RunnableStep<TArgs, TResult>;
+  get<
+    T,
+    TKey extends keyof T,
+    TArgs extends MethodArguments<T, TKey>,
+    TResult extends MethodReturnType<T, TKey>,
+  >(object: T, name: MethodNames<T, TKey>): RunnableStep<TArgs, TResult>;
+  get<
+    T,
+    TKey extends keyof T,
+    TArgs extends MethodArguments<T, TKey>,
+    TResult extends MethodReturnType<T, TKey>,
+  >(
+    ...args: [{ name: string }, T, MethodNames<T, TKey>] | [T, MethodNames<T, TKey>]
+  ): RunnableStep<TArgs, TResult> {
+    let config: { name: string };
+    let fn: StepFunction<TArgs, Exclude<TResult, never>>;
+
+    if (args.length === 2) {
+      const [rawObject, methodName] = args;
+      const method = rawObject[methodName] as CallableFunction;
+      config = { name: inflection.underscore(methodName.toString()) };
+
+      fn = (...args: TArgs) => method.bind(rawObject)(...args);
+    } else {
+      const [rawConfig, rawObject, name] = args;
+      const method = rawObject[name] as CallableFunction;
+
+      config = { name: rawConfig.name ?? inflection.underscore(name.toString()) };
+      fn = (...args: TArgs) => method.bind(rawObject)(...args);
+    }
+
+    return {
+      run: ((stepApi: StepApi) => {
+        return (...args: TArgs) => {
+          return stepApi.run(config, () => fn(...args));
+        };
+      })(this.#stepApi),
+    };
+  }
+
+  sleep(name: string, duration: DurationString) {
+    return this.#stepApi.sleep(name, duration);
+  }
+}