k8ts 0.1.0

package/src/runner/exporter/stage.ts

@@ -0,0 +1,36 @@
+import { displayers } from "@k8ts/instruments"
+import chalk from "chalk"
+import { AssemblyStage } from "./assembler"
+
+@displayers({
+    simple: s => s.text,
+    pretty: stage => chalk.bgGreenBright.bold.black(` ${stage.text} `)
+})
+export class Stage {
+    text: string
+    constructor(private stage: AssemblyStage) {
+        this.text = `${stage.toUpperCase()}`
+    }
+
+    private get _emoji() {
+        switch (this.stage) {
+            case "gathering":
+                return "🛒"
+            case "loading":
+                return "🚚"
+            case "manifesting":
+                return "👻"
+            case "start":
+                return "🚀"
+            case "saving":
+                return "💾"
+            case "serializing":
+                return "🖨️"
+            case "done":
+                return "✅"
+        }
+    }
+}
+export function stage(stage: AssemblyStage) {
+    return new Stage(stage)
+}

package/src/runner/index.ts

@@ -0,0 +1 @@
+export * from "./runner"

package/src/runner/runner.ts

@@ -0,0 +1,53 @@
+import { GitTrace, Trace } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import chalk from "chalk"
+import StackTracey from "stacktracey"
+import { File } from "../file"
+import { proverbsPath } from "../paths"
+import { Assembler, AssemblerOptions, ProgressOptions, ProgressShower } from "./exporter"
+import { k8ts_namespace } from "./exporter/meta"
+import { Proverbs } from "./silly/proverbs"
+import { Summarizer } from "./summarizer"
+
+export interface RunnerOptions extends AssemblerOptions {
+    cwd?: string
+    printOptions?: boolean
+    progress: ProgressOptions
+}
+
+export class Runner {
+    constructor(private readonly _options: RunnerOptions) {}
+
+    async run(input: Iterable<File.Input>) {
+        const proverbs = await Proverbs.make(proverbsPath)
+        console.log(chalk.italic.magentaBright(proverbs.random))
+        const gitInfo = await GitTrace.make({
+            cwd: this._options.cwd
+        })
+        const runTrace = new Trace(new StackTracey().slice(1))
+        const options = {
+            cwd: ".",
+            ...this._options,
+            meta: Meta.make(this._options.meta).add(k8ts_namespace, {
+                "^emitted-at": runTrace.format({
+                    cwd: this._options.cwd
+                }),
+                "^source-git": gitInfo?.text
+            })
+        }
+
+        const progressShower = new ProgressShower(options.progress)
+        const assembler = new Assembler(options)
+        const summarizer = new Summarizer({
+            printOptions: this._options.printOptions
+        })
+        const visualizer = progressShower.visualize(assembler)
+        const result = await assembler.assemble(input)
+
+        const viz = summarizer.result(result)
+
+        await visualizer
+        console.log()
+        console.log(viz)
+    }
+}

package/src/runner/silly/proverbs.ts

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises"
+export class Proverbs {
+    constructor(private _proverbs: string[]) {}
+    static async make(file: string) {
+        const loaded = await readFile(file, "utf-8")
+        const lines = loaded.split("\n")
+        return new Proverbs(lines)
+    }
+
+    get random() {
+        const idx = Math.floor(Math.random() * this._proverbs.length)
+        return `K8ts says: ${this._proverbs[idx]}`
+    }
+}

package/src/runner/summarizer.ts

@@ -0,0 +1,133 @@
+import {
+    Displayers,
+    NeedsEdge,
+    Origin,
+    pretty,
+    ResourceNode,
+    TextPostProcessor
+} from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { List, Map } from "immutable"
+import { dump } from "js-yaml"
+import { AssembledResult } from "./exporter"
+export interface SummarizerOptions {
+    printOptions?: boolean
+}
+export class Summarizer {
+    private _post = new TextPostProcessor()
+    constructor(private readonly _options: SummarizerOptions) {}
+    _formatRefFromTo(node: ResourceNode, edge: NeedsEdge<ResourceNode>) {
+        return this._token(pretty`${edge}`)
+    }
+
+    private _token(text: string | object) {
+        if (typeof text === "object") {
+            text = pretty`${text}`
+        }
+        const token = this._post.token(text)
+        return token
+    }
+
+    private _resource(resource: ResourceNode): any[] | null {
+        const subs = resource.kids
+            .map(sub => {
+                const heading = Displayers.get(sub).pretty("local")
+                const description = this._resource(sub)
+                return { [this._token(heading)]: description }
+            })
+            .toArray()
+            .pull()
+        const depends = resource.needs
+            .map(x => this._formatRefFromTo(resource, x))
+            .toArray()
+            .pull()
+        if (depends.length === 0 && subs.length === 0) {
+            return null
+        }
+        return [...subs, ...depends]
+    }
+
+    private _resources(resources: ResourceNode[]): object {
+        const resourceContainer = List(resources)
+            .map(resource => {
+                const text = pretty`${resource}`
+                const token = this._token(text)
+                const objForm = this._resource(resource)
+                if (!objForm) {
+                    return token
+                }
+                return {
+                    [token]: [...objForm, ...(resource.isRoot ? ["SPACE"] : [])]
+                }
+            })
+            .reduce((a, b) => {
+                return [...a, b]
+            }, [] as any)
+
+        return resourceContainer
+    }
+
+    private _yaml(input: object) {
+        const result = dump(input, {
+            lineWidth: 800,
+            noArrayIndent: true,
+            indent: 2,
+            noRefs: true,
+            replacer(key, value) {
+                if (value instanceof Meta.Meta) {
+                    return value.values
+                }
+                return value
+            }
+        })
+        return result
+    }
+
+    private _serialize(input: object) {
+        const tree = this._yaml(input)
+        const rendered = this._post.render(tree)
+        return rendered.replaceAll("- SPACE", "")
+    }
+
+    private _getOptions(result: AssembledResult) {
+        const obj = {
+            options: result.options,
+            output: result.files.map(x => {
+                return {
+                    path: x.path,
+                    name: x.filename,
+                    saved: x.bytes,
+                    manifested: x.artifacts.length
+                }
+            })
+        }
+        return this._serialize(obj)
+    }
+
+    result(result: AssembledResult) {
+        const outputs = [] as string[]
+        if (this._options.printOptions) {
+            outputs.push(this._getOptions(result))
+        }
+        outputs.push(
+            this.files(
+                result.files.map(x => ({
+                    origin: x.file,
+                    resources: x.artifacts.map(x => x.k8ts)
+                }))
+            )
+        )
+        return outputs.join("\n")
+    }
+
+    files(obj: { origin: Origin; resources: ResourceNode[] }[]) {
+        let pairs = obj.flatMap(({ origin, resources }) => {
+            return [
+                [this._token(pretty`\n${origin}`), this._resources(resources)] as [string, object]
+            ]
+        })
+
+        const x = Map(pairs).toJS()
+        return this._serialize(x)
+    }
+}

package/src/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "references": [
+    {
+      "path": "./_imports/tsconfig.json"
+    }
+  ],
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": false,
+    "outDir": "../dist",
+    "tsBuildInfoFile": "../dist/src.tsbuildinfo"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["_imports/**/*.ts"]
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const version = "0.0.1"

package/src/world/index.ts

@@ -0,0 +1 @@
+export * from "./world"

package/src/world/world.ts

@@ -0,0 +1,62 @@
+import { BaseOriginEntity, KindMap, Origin, type Kind } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { External } from "../external"
+import { File } from "../file"
+import { k8tsBuildKind } from "../k8ts-sys-kind"
+import { K8tsRootOrigin } from "../kind-map"
+import type { ManifestResource } from "../node"
+import type { Namespace } from "../resources"
+export type ManifestFileName = `${string}.yaml`
+export namespace World {
+    export interface Props {
+        name: string
+        meta?: Meta.Input
+        kinds?: KindMap
+    }
+
+    const ident = k8tsBuildKind.kind("World")
+    export class Builder extends BaseOriginEntity<Props> {
+        readonly kind = ident
+        readonly ExternalOrigin: ExternalOriginEntity
+        constructor(props: Props) {
+            super("World", props, K8tsRootOrigin.node)
+            this.ExternalOrigin = new ExternalOriginEntity(this.node)
+        }
+
+        External<K extends Kind>(kind: K, name: string, namespace?: string) {
+            return new External(this.ExternalOrigin.node, kind, name, namespace)
+        }
+
+        File<T extends ManifestResource>(
+            name: ManifestFileName,
+            props: File.Props<Namespace, T>
+        ): File<T>
+        File<T extends ManifestResource>(
+            name: ManifestFileName,
+            props: File.Props<"cluster", T>
+        ): File<T>
+        File<T extends ManifestResource>(
+            name: ManifestFileName,
+            props: File.Props<any, T>
+        ): File<T> {
+            return File.make(name, props, this.node)
+        }
+    }
+
+    export function make(props: Props) {
+        return new Builder(props)
+    }
+}
+const ident = k8tsBuildKind.kind("External")
+export class ExternalOriginEntity extends BaseOriginEntity {
+    kind = ident
+    constructor(parent: Origin) {
+        super(
+            "EXTERNAL",
+            {
+                meta: {}
+            },
+            parent
+        )
+    }
+}