Add BeDoc core implementation with action discovery and processing pipeline

dist/schema/bedoc.action.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schema.gesslar.dev/v1/bedoc-action.json",
+  "title": "BeDoc Action Schema",
+  "type": "object",
+  "properties": {
+    "accepts": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "object"
+        }
+      },
+      "required": [
+        "type"
+      ]
+    },
+    "provides": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "object"
+        }
+      },
+      "required": [
+        "type"
+      ]
+    }
+  },
+  "oneOf": [
+    {
+      "required": [
+        "accepts"
+      ]
+    },
+    {
+      "required": [
+        "provides"
+      ]
+    }
+  ]
+}

dist/types/Action.d.ts

@@ -0,0 +1,3 @@
+declare const _default: object;
+export default _default;
+//# sourceMappingURL=Action.d.ts.map

dist/types/BeDoc.d.ts

@@ -0,0 +1,208 @@
+/**
+ * @import {Glog} from "@gesslar/toolkit"
+ */
+export default class BeDoc {
+    /**
+     * Create a new instance of Core.
+     *
+     * @param {object} args
+     * @param {object} args.options - The options passed into BeDoc
+     * @param {string} args.source - The environment BeDoc is running in
+     * @param {Glog} args.glog - The Glog logger instance
+     * @returns {Promise<BeDoc>} A new instance of Core
+     */
+    static "new"({ options, source, glog, validateBeDocSchema }: {
+        options: object;
+        source: string;
+        glog: {
+            new (options?: {
+                name?: string;
+                debugLevel?: number;
+                logLevel?: number;
+                prefix?: string;
+                colours?: object;
+                symbols?: object;
+                stackTrace?: boolean;
+                tagsAsStrings?: boolean;
+                displayName?: boolean;
+                env?: string;
+            }): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            logLevel: number;
+            logPrefix: string;
+            colours: any;
+            stackTrace: boolean;
+            name: string;
+            tagsAsStrings: boolean;
+            symbols: any;
+            setLogPrefix(prefix: string): /*elided*/ any;
+            setLogLevel(level: number): /*elided*/ any;
+            withName(name: string): /*elided*/ any;
+            withColours(colours?: object): /*elided*/ any;
+            withStackTrace(enabled?: boolean): /*elided*/ any;
+            withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+            withSymbols(symbols?: object): /*elided*/ any;
+            use(prefix: string): object;
+            create(options?: object): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            execute(...args: unknown[]): void;
+            colourize(strings: Array<string>, ...values: unknown[]): void;
+            success(message: string, ...args: unknown[]): void;
+            group(...args: unknown[]): void;
+            groupEnd(): void;
+            groupDebug(message: string, level?: number): void;
+            groupInfo(message: string): void;
+            groupSuccess(message: string): void;
+            table(data: object | any[], labelOrOptions?: string | object, options?: {
+                properties?: Array<string>;
+                showHeader?: boolean;
+                quotedStrings?: boolean;
+            }): void;
+            setAlias(alias: string, colourCode: string): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            get raw(): object;
+        };
+    }): Promise<BeDoc>;
+    constructor(glog: any);
+    processFiles(): Promise<{
+        totalFiles: any;
+        succeeded: any;
+        warned: any;
+        errored: any;
+        duration: string;
+    }>;
+    #private;
+}
+//# sourceMappingURL=BeDoc.d.ts.map

dist/types/Configuration.d.ts

@@ -0,0 +1,11 @@
+export default class Configuration {
+    validate({ options, source }: {
+        options: any;
+        source: any;
+    }): Promise<{
+        status: string;
+        validated: boolean;
+    }>;
+    #private;
+}
+//# sourceMappingURL=Configuration.d.ts.map

dist/types/ConfigurationParameters.d.ts

@@ -0,0 +1,3 @@
+export const ConfigurationParameters: object;
+export const ConfigurationPriorityKeys: object;
+//# sourceMappingURL=ConfigurationParameters.d.ts.map

dist/types/Conveyor.d.ts

@@ -0,0 +1,27 @@
+export default class Conveyor {
+    constructor({ parse, print, glog, contract, output }: {
+        parse: any;
+        print: any;
+        glog: any;
+        contract: any;
+        output: any;
+    });
+    /**
+     * Defines the per-file processing pipeline.
+     *
+     * @param {ActionBuilder} builder - The Actioneer builder instance.
+     */
+    setup(builder: ActionBuilder): void;
+    /**
+     * Processes files through the parse→print pipeline with concurrency.
+     *
+     * @param {Array<FileObject>} files - List of files to process.
+     * @param {number} maxConcurrent - Maximum number of concurrent tasks.
+     * @returns {Promise<object>} - Resolves with {succeeded, errored, warned}.
+     */
+    convey(files: Array<FileObject>, maxConcurrent?: number): Promise<object>;
+    #private;
+}
+import { ActionBuilder } from "@gesslar/actioneer";
+import { FileObject } from "@gesslar/toolkit";
+//# sourceMappingURL=Conveyor.d.ts.map