@telorun/kernel 0.2.5 → 0.2.7

package/src/controllers/module/module.yaml

@@ -1,32 +0,0 @@
-type: 'object'
-properties:
-  metadata:
-    type: 'object'
-    properties:
-      name:
-        type: 'string'
-    required: ['name']
-  source:
-    type: 'string'
-    description: 'Path to module directory (relative to runtime root)'
-  imports:
-    type: 'array'
-    items:
-      type: 'string'
-    description: 'Paths to other modules to import'
-  definitions:
-    type: 'array'
-    items:
-      type: 'string'
-    description: 'Paths to ResourceDefinition files'
-  resources:
-    type: 'array'
-    items:
-      oneOf:
-        - type: 'string'
-        - type: 'object'
-          properties:
-            path:
-              type: 'string'
-    description: 'Paths to resource instance files to load'
-required: ['metadata', 'source']

package/src/loader.ts

@@ -1,245 +0,0 @@
-import { ResourceManifest, RuntimeResource } from "@telorun/sdk";
-import { compile } from "@telorun/yaml-cel-templating";
-import * as path from "path";
-import { HttpAdapter } from "./manifest-adapters/http-adapter.js";
-import { LocalFileAdapter } from "./manifest-adapters/local-file-adapter.js";
-import type { ManifestAdapter, ManifestSourceData } from "./manifest-adapters/manifest-adapter.js";
-import { RegistryAdapter } from "./manifest-adapters/registry-adapter.js";
-import { formatAjvErrors, validateRuntimeResource } from "./manifest-schemas.js";
-
-/**
- * Loader: Ingests resolved YAML manifests from disk or remote URLs into memory
- */
-export class Loader {
-  private static projectRoot: string | null = null;
-
-  private readonly adapters: ManifestAdapter[] = [
-    new HttpAdapter(),
-    new RegistryAdapter(),
-    new LocalFileAdapter(),
-  ];
-
-  private getAdapter(pathOrUrl: string): ManifestAdapter {
-    const adapter = this.adapters.find((a) => a.supports(pathOrUrl));
-    if (!adapter) {
-      throw new Error(`No manifest adapter found for: ${pathOrUrl}`);
-    }
-    return adapter;
-  }
-
-  private static ensureProjectRoot(baseDir: string): void {
-    if (!Loader.projectRoot) {
-      Loader.projectRoot = path.resolve(baseDir);
-    }
-  }
-
-  resolvePath(base: string, relative: string): string {
-    return this.getAdapter(base).resolveRelative(base, relative);
-  }
-
-  async loadDirectory(pathOrUrl: string): Promise<ResourceManifest[]> {
-    const files = await this.getAdapter(pathOrUrl).readAll(pathOrUrl);
-    Loader.ensureProjectRoot(files[0]?.baseDir ?? process.cwd());
-    const resources: RuntimeResource[] = [];
-    for (const file of files) {
-      await this.processFile(file, resources, { env: process.env });
-    }
-    return this.orderResourcesByKindDependencies(resources);
-  }
-
-  async loadManifest(
-    pathOrUrl: string,
-    baseUrl: string,
-    compileContext: Record<string, unknown> = {},
-  ): Promise<ResourceManifest[]> {
-    if (!baseUrl) {
-      throw new Error("Base URL is required to load target manifest");
-    }
-    const url = new URL(pathOrUrl, baseUrl).toString();
-    const file = await this.getAdapter(url).read(url);
-    if (!Loader.projectRoot) {
-      Loader.ensureProjectRoot(file.baseDir);
-    }
-
-    const resolved: ResourceManifest[] = [];
-    for (const rawDoc of file.documents) {
-      let compiled: any;
-      try {
-        compiled = compile(rawDoc, { context: compileContext });
-      } catch (error) {
-        throw new Error(
-          `Failed to compile manifest in ${file.source}: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-      const compiledDocs = Array.isArray(compiled) ? compiled : [compiled];
-      for (const manifest of compiledDocs) {
-        if (manifest === null) {
-          // Ignore empty documents
-          continue;
-        }
-        const resource: ResourceManifest = {
-          ...manifest,
-          metadata: {
-            ...manifest.metadata,
-            source: file.source,
-          },
-        };
-        resolved.push(resource);
-      }
-    }
-
-    // Auto-assign metadata.module from the file's Kernel.Module declaration to
-    // any resource that doesn't explicitly declare one. This matches the implicit
-    // convention that resources in the same file belong to the declared module.
-    const moduleName = resolved.find((m) => m.kind === "Kernel.Module")?.metadata?.name;
-    if (moduleName) {
-      for (const manifest of resolved) {
-        if (manifest.kind !== "Kernel.Module" && !manifest.metadata?.module) {
-          manifest.metadata = { ...manifest.metadata, module: moduleName };
-        }
-      }
-    }
-
-    return resolved;
-  }
-
-  private async processFile(
-    file: ManifestSourceData,
-    resources: RuntimeResource[],
-    compileContext: Record<string, unknown> = {},
-  ): Promise<void> {
-    const documents = file.documents;
-
-    for (const rawDoc of documents) {
-      let compiled: any;
-      try {
-        compiled = compile(rawDoc, { context: compileContext });
-      } catch (error) {
-        throw new Error(
-          `Failed to compile manifest in ${file.source}: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-      const compiledDocs = Array.isArray(compiled) ? compiled : [compiled];
-      for (const doc of compiledDocs) {
-        const resource = this.normalizeResource(doc);
-        if (!resource) {
-          continue;
-        }
-        if (!validateRuntimeResource(resource)) {
-          const kind = (resource as any).kind;
-          const name = (resource as any).metadata?.name;
-          throw new Error(
-            `Resource validation failed for ${kind}.${name}: ${formatAjvErrors(validateRuntimeResource.errors)}`,
-          );
-        }
-
-        const { kind, name } = resource.metadata;
-        resource.metadata.source = file.source;
-        resource.metadata.uri = `${file.uriBase}#${kind}.${name}`;
-        resource.metadata.generationDepth = 0;
-
-        resources.push(resource);
-      }
-    }
-  }
-
-  private normalizeResource(doc: any): RuntimeResource | null {
-    if (!doc || typeof doc !== "object" || typeof doc.kind !== "string") {
-      return null;
-    }
-
-    // Already in correct format
-    if (doc.metadata && typeof doc.metadata === "object" && typeof doc.metadata.name === "string") {
-      return doc as RuntimeResource;
-    }
-
-    return null;
-  }
-
-  // Validation handled by TypeBox + Ajv schemas.
-
-  private orderResourcesByKindDependencies(resources: RuntimeResource[]): RuntimeResource[] {
-    if (resources.length <= 1) {
-      return resources;
-    }
-
-    const indicesByName = new Map<string, number[]>();
-    for (let i = 0; i < resources.length; i += 1) {
-      const name = resources[i]?.metadata?.name;
-      if (!name) {
-        continue;
-      }
-      const list = indicesByName.get(name);
-      if (list) {
-        list.push(i);
-      } else {
-        indicesByName.set(name, [i]);
-      }
-    }
-
-    const edges = new Map<number, Set<number>>();
-    const indegree = new Map<number, number>();
-    for (let i = 0; i < resources.length; i += 1) {
-      indegree.set(i, 0);
-    }
-
-    for (let i = 0; i < resources.length; i += 1) {
-      const kind = resources[i]?.kind;
-      if (!kind) {
-        continue;
-      }
-      const definers = indicesByName.get(kind);
-      if (!definers) {
-        continue;
-      }
-      for (const definerIndex of definers) {
-        if (definerIndex === i) {
-          continue;
-        }
-        let set = edges.get(definerIndex);
-        if (!set) {
-          set = new Set();
-          edges.set(definerIndex, set);
-        }
-        if (!set.has(i)) {
-          set.add(i);
-          indegree.set(i, (indegree.get(i) || 0) + 1);
-        }
-      }
-    }
-
-    const ready: number[] = [];
-    for (let i = 0; i < resources.length; i += 1) {
-      if ((indegree.get(i) || 0) === 0) {
-        ready.push(i);
-      }
-    }
-    ready.sort((a, b) => a - b);
-
-    const ordered: RuntimeResource[] = [];
-    while (ready.length > 0) {
-      const index = ready.shift() as number;
-      ordered.push(resources[index]);
-      const next = edges.get(index);
-      if (!next) {
-        continue;
-      }
-      for (const dependent of next) {
-        const count = (indegree.get(dependent) || 0) - 1;
-        indegree.set(dependent, count);
-        if (count === 0) {
-          ready.push(dependent);
-        }
-      }
-      if (ready.length > 1) {
-        ready.sort((a, b) => a - b);
-      }
-    }
-
-    if (ordered.length !== resources.length) {
-      throw new Error("Resource dependency cycle detected");
-    }
-
-    return ordered;
-  }
-}

package/src/manifest-adapters/http-adapter.ts

@@ -1,35 +0,0 @@
-import * as yaml from "js-yaml";
-import type { ManifestAdapter, ManifestSourceData } from "./manifest-adapter.js";
-
-export class HttpAdapter implements ManifestAdapter {
-  supports(pathOrUrl: string): boolean {
-    return pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://");
-  }
-
-  async read(url: string): Promise<ManifestSourceData> {
-    return (await this.readAll(url))[0];
-  }
-
-  async readAll(url: string): Promise<ManifestSourceData[]> {
-    const fetchUrl = url.includes(".yaml") ? url : url + "/module.yaml";
-    const response = await fetch(fetchUrl);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch manifest from ${fetchUrl}: ${response.status} ${response.statusText}`,
-      );
-    }
-    return [
-      {
-        documents: yaml.loadAll(await response.text()),
-        source: fetchUrl,
-        baseDir: process.cwd(),
-        uriBase: url,
-      },
-    ];
-  }
-
-  resolveRelative(base: string, relative: string): string {
-    const baseWithSlash = base.endsWith("/") ? base : `${base}/`;
-    return new URL(relative, baseWithSlash).href;
-  }
-}

package/src/manifest-adapters/registry-adapter.ts

@@ -1,56 +0,0 @@
-import * as yaml from "js-yaml";
-import type { ManifestAdapter, ManifestSourceData } from "./manifest-adapter.js";
-
-const REGISTRY_BASE = "https://registry.telo.run";
-
-export class RegistryAdapter implements ManifestAdapter {
-  supports(pathOrUrl: string): boolean {
-    // Matches "owner/module@version" — has @ and /, but not an http/https URL or local path
-    return (
-      !pathOrUrl.startsWith("http://") &&
-      !pathOrUrl.startsWith("https://") &&
-      !pathOrUrl.startsWith("/") &&
-      !pathOrUrl.startsWith(".") &&
-      pathOrUrl.includes("@") &&
-      pathOrUrl.includes("/")
-    );
-  }
-
-  async read(moduleRef: string): Promise<ManifestSourceData> {
-    return (await this.readAll(moduleRef))[0];
-  }
-
-  async readAll(moduleRef: string): Promise<ManifestSourceData[]> {
-    const url = this.toRegistryUrl(moduleRef);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch manifest ${moduleRef}: ${response.status} ${response.statusText}`,
-      );
-    }
-    return [
-      {
-        documents: yaml.loadAll(await response.text()),
-        source: url,
-        baseDir: process.cwd(),
-        uriBase: url.replace("/module.yaml", ""),
-      },
-    ];
-  }
-
-  resolveRelative(base: string, relative: string): string {
-    const baseUrl = this.supports(base)
-      ? this.toRegistryUrl(base).replace("/module.yaml", "")
-      : base;
-    const baseWithSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    return new URL(relative, baseWithSlash).href;
-  }
-
-  private toRegistryUrl(moduleRef: string): string {
-    const atIdx = moduleRef.lastIndexOf("@");
-    const path = moduleRef.slice(0, atIdx); // "example/module"
-    const version = moduleRef.slice(atIdx + 1); // "1.2.3" or "v1.2.3"
-    const versionSegment = version.startsWith("v") ? version.substring(1) : version;
-    return `${REGISTRY_BASE}/${path}/${versionSegment}/module.yaml`;
-  }
-}