kubun 0.9.0 → 0.11.0

package/lib/commands/serve.js

@@ -0,0 +1,116 @@
+import { NodeSQLiteAdapter } from '@kubun/db-node-sqlite';
+import { PostgresAdapter } from '@kubun/db-postgres';
+import { KubunEngine } from '@kubun/engine';
+import { getKubunLogger } from '@kubun/logger';
+import { createHTTPPlugin } from '@kubun/plugin-http';
+import { createP2PPlugin } from '@kubun/plugin-p2p';
+import { createRPCPlugin } from '@kubun/plugin-rpc';
+import { configureSync, getConsoleSink } from '@logtape/logtape';
+import { Command } from 'commander';
+import { resolvePath } from '../fs.js';
+import { resolveIdentity } from '../identity.js';
+import { withAllowedOrigin, withLogLevel, withPort, withPrivateKey } from '../options.js';
+import { renderNotice, withSpinner } from '../ui.js';
+export function createServeCommand() {
+    const cmd = new Command('serve').description('Start a local Kubun server').option('--auto-accept-peers <dids>', 'comma-separated DIDs to auto-accept for peer join flows').option('--db <path>', 'path to the local SQLite database').option('--id <id>', 'server ID').option('--p2p', 'enable P2P mode with sync and graph protocols over HTTP');
+    withAllowedOrigin(cmd);
+    withLogLevel(cmd);
+    withPort(cmd);
+    withPrivateKey(cmd);
+    cmd.action(async (opts)=>{
+        if (opts.id != null && opts.privateKey != null) {
+            throw new Error('--id and --private-key are mutually exclusive');
+        }
+        if (opts.autoAcceptPeers != null && !opts.p2p) {
+            throw new Error('--auto-accept-peers requires --p2p');
+        }
+        configureSync({
+            reset: true,
+            sinks: {
+                console: getConsoleSink()
+            },
+            loggers: [
+                {
+                    category: [
+                        'logtape',
+                        'meta'
+                    ],
+                    lowestLevel: 'error',
+                    sinks: [
+                        'console'
+                    ]
+                },
+                {
+                    category: [
+                        'kubun'
+                    ],
+                    lowestLevel: opts.logLevel ?? 'warning',
+                    sinks: [
+                        'console'
+                    ]
+                }
+            ]
+        });
+        const logger = getKubunLogger('cli');
+        const identity = resolveIdentity(opts, logger);
+        const adapter = opts.db == null || opts.db === ':memory:' ? new NodeSQLiteAdapter({
+            database: ':memory:'
+        }) : opts.db.startsWith('postgres://') || opts.db.startsWith('postgresql://') ? new PostgresAdapter({
+            url: opts.db
+        }) : new NodeSQLiteAdapter({
+            database: resolvePath(opts.db)
+        });
+        const autoAcceptPeers = opts.autoAcceptPeers ? opts.autoAcceptPeers.split(',').map((s)=>s.trim()) : undefined;
+        const rpcAccessRules = autoAcceptPeers != null ? {
+            '*': {
+                allow: [
+                    identity.id,
+                    ...autoAcceptPeers
+                ]
+            }
+        } : undefined;
+        const port = opts.port == null ? undefined : typeof opts.port === 'number' ? opts.port : Number.parseInt(opts.port, 10);
+        const plugins = [
+            createRPCPlugin({
+                ...rpcAccessRules != null ? {
+                    accessRules: rpcAccessRules
+                } : undefined,
+                allowDelegatedMutations: opts.p2p
+            }),
+            createHTTPPlugin({
+                port,
+                allowedOrigin: opts.allowedOrigin
+            })
+        ];
+        if (opts.p2p) {
+            plugins.push(createP2PPlugin({
+                http: true,
+                autoAcceptPeers
+            }));
+        }
+        const engine = new KubunEngine({
+            db: adapter,
+            identity,
+            plugins
+        });
+        const http = await withSpinner('Starting the server...', async ()=>{
+            const api = await engine.getAPI('http');
+            await api.listening;
+            if (opts.p2p) {
+                const p2p = await engine.getAPI('p2p');
+                await p2p.syncReady;
+            }
+            return api;
+        });
+        renderNotice('success', `HTTP server listening at ${http.getURL()}\n  DID: ${identity.id}`);
+        if (opts.p2p && autoAcceptPeers) {
+            process.stderr.write(`  Auto-accept peers: ${autoAcceptPeers.length} DID(s)\n`);
+        }
+        await new Promise((resolve)=>{
+            process.once('SIGINT', resolve);
+            process.once('SIGTERM', resolve);
+        });
+        await engine.dispose();
+    });
+    return cmd;
+}

package/lib/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function resolvePath(value: string): string;
+export declare function readJSON<T = unknown>(path: string): Promise<T>;
+export declare function writeFile(path: string, value: string): Promise<void>;
+export declare function writeJSON(path: string, value: unknown, format?: boolean): Promise<void>;

package/{dist → lib}/fs.js

@@ -4,10 +4,14 @@ export function resolvePath(value) {
     return isAbsolute(value) ? value : resolve(process.cwd(), value);
 }
 export async function readJSON(path) {
-    return JSON.parse(await read(resolvePath(path), { encoding: 'utf8' }));
+    return JSON.parse(await read(resolvePath(path), {
+        encoding: 'utf8'
+    }));
 }
 export async function writeFile(path, value) {
-    await write(resolvePath(path), value, { encoding: 'utf8' });
+    await write(resolvePath(path), value, {
+        encoding: 'utf8'
+    });
 }
 export async function writeJSON(path, value, format = false) {
     await writeFile(path, format ? JSON.stringify(value, null, 2) : JSON.stringify(value));

package/lib/identity.d.ts

@@ -0,0 +1,19 @@
+import type { Identity, OwnIdentity } from '@kokuin/token';
+type Logger = {
+    warn: (message: string, properties?: Record<string, unknown>) => void;
+};
+export type IdentityOptions = {
+    privateKey?: string;
+    id?: string;
+    p2p?: boolean;
+};
+/**
+ * Resolve the server signing identity from CLI options.
+ *
+ * The random-identity fallback logs only the DID — never the private key — and
+ * flags that the identity is ephemeral so it is not mistaken for a persistent
+ * one. Logging the key would leak the server's signing secret to console sinks
+ * and log aggregation.
+ */
+export declare function resolveIdentity(opts: IdentityOptions, logger: Logger): Identity | OwnIdentity;
+export {};

package/lib/identity.js

@@ -0,0 +1,31 @@
+import { createFullIdentity, randomIdentity } from '@kokuin/token';
+import { fromB64 } from '@sozai/codec';
+/**
+ * Resolve the server signing identity from CLI options.
+ *
+ * The random-identity fallback logs only the DID — never the private key — and
+ * flags that the identity is ephemeral so it is not mistaken for a persistent
+ * one. Logging the key would leak the server's signing secret to console sinks
+ * and log aggregation.
+ */ export function resolveIdentity(opts, logger) {
+    if (opts.privateKey != null) {
+        const privateKey = fromB64(opts.privateKey);
+        return {
+            ...createFullIdentity(privateKey),
+            privateKey
+        };
+    }
+    if (opts.id != null) {
+        if (opts.p2p) {
+            throw new Error('P2P mode requires a signing identity. Use --private-key instead of --id.');
+        }
+        return {
+            id: opts.id
+        };
+    }
+    const generated = randomIdentity();
+    logger.warn('No identity provided; generated an ephemeral one (DID: {id}). It is discarded on exit — pass --private-key or --id to persist.', {
+        id: generated.id
+    });
+    return generated;
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { buildProgram } from './program.js';
+export { buildProgram };
+export declare function run(argv: Array<string>): Promise<void>;

package/lib/index.js

@@ -0,0 +1,19 @@
+import { buildProgram } from './program.js';
+export { buildProgram };
+export async function run(argv) {
+    const program = buildProgram();
+    if (argv.slice(2).length === 0) {
+        program.outputHelp();
+        return;
+    }
+    try {
+        await program.parseAsync(argv);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`✘ ${message}\n`);
+        if (process.env.KUBUN_DEBUG === '1' && error instanceof Error && error.stack != null) {
+            process.stderr.write(`${error.stack}\n`);
+        }
+        process.exitCode = 1;
+    }
+}

package/lib/options.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from 'commander';
+/** Add `-k, --private-key <key>`, bound to KUBUN_PRIVATE_KEY, optionally required. */
+export declare function withPrivateKey(cmd: Command, opts?: {
+    required?: boolean;
+}): Command;
+/** Add `--url <url>` for the Kubun server URL. */
+export declare function withURL(cmd: Command): Command;
+/** Add `-l, --log-level <level>` with the `warning` default and the logtape level set. */
+export declare function withLogLevel(cmd: Command): Command;
+/** Add `-p, --port <port>`, default resolved lazily from @tejika/env at action time. */
+export declare function withPort(cmd: Command): Command;
+/**
+ * Add `-a, --allowed-origin <origin>`, bound to KUBUN_ALLOWED_ORIGIN.
+ *
+ * No default: an unset option denies cross-origin browser requests. Opening a
+ * surface is an explicit choice — pass `-a '*'` to reflect any origin, or a
+ * comma-separated list to allow only those.
+ */
+export declare function withAllowedOrigin(cmd: Command): Command;

package/lib/options.js

@@ -0,0 +1,47 @@
+import { getLogLevels } from '@logtape/logtape';
+import { getAppEnvVar, getPort } from '@tejika/env';
+/** Add `-k, --private-key <key>`, bound to KUBUN_PRIVATE_KEY, optionally required. */ export function withPrivateKey(cmd, opts = {}) {
+    cmd.option('-k, --private-key <key>', 'base64-encoded private key (env: KUBUN_PRIVATE_KEY)');
+    cmd.hook('preAction', (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().privateKey == null && process.env.KUBUN_PRIVATE_KEY != null) {
+            actionCmd.setOptionValue('privateKey', process.env.KUBUN_PRIVATE_KEY);
+        }
+        if (opts.required && actionCmd.opts().privateKey == null) {
+            throw new Error('--private-key is required (or set KUBUN_PRIVATE_KEY)');
+        }
+    });
+    return cmd;
+}
+/** Add `--url <url>` for the Kubun server URL. */ export function withURL(cmd) {
+    return cmd.option('--url <url>', 'Kubun server URL');
+}
+/** Add `-l, --log-level <level>` with the `warning` default and the logtape level set. */ export function withLogLevel(cmd) {
+    return cmd.option('-l, --log-level <level>', `log level (${getLogLevels().join(', ')})`, 'warning');
+}
+/** Add `-p, --port <port>`, default resolved lazily from @tejika/env at action time. */ export function withPort(cmd) {
+    cmd.option('-p, --port <port>', 'port to listen on');
+    cmd.hook('preAction', async (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().port == null) {
+            actionCmd.setOptionValue('port', await getPort('kubun'));
+        }
+    });
+    return cmd;
+}
+/**
+ * Add `-a, --allowed-origin <origin>`, bound to KUBUN_ALLOWED_ORIGIN.
+ *
+ * No default: an unset option denies cross-origin browser requests. Opening a
+ * surface is an explicit choice — pass `-a '*'` to reflect any origin, or a
+ * comma-separated list to allow only those.
+ */ export function withAllowedOrigin(cmd) {
+    cmd.option('-a, --allowed-origin <origin>', 'allowed HTTP origin(s), comma-separated (env: KUBUN_ALLOWED_ORIGIN); unset denies cross-origin browser requests');
+    cmd.hook('preAction', (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().allowedOrigin == null) {
+            const envOrigin = getAppEnvVar('kubun', 'ALLOWED_ORIGIN');
+            if (envOrigin != null) {
+                actionCmd.setOptionValue('allowedOrigin', envOrigin);
+            }
+        }
+    });
+    return cmd;
+}

package/lib/program.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function buildProgram(): Command;

package/lib/program.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildProgram as tejikaBuildProgram } from '@tejika/cli';
+import { createAccountCommand } from './commands/account.js';
+import { createGraphCommand } from './commands/graph.js';
+import { createGraphQLCommand } from './commands/graphql.js';
+import { createMCPCommand } from './commands/mcp.js';
+import { createModelCommand } from './commands/model.js';
+import { createServeCommand } from './commands/serve.js';
+const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+export function buildProgram() {
+    const program = tejikaBuildProgram({
+        name: 'kubun',
+        version: pkg.version,
+        commands: [
+            createAccountCommand(),
+            createGraphCommand(),
+            createGraphQLCommand(),
+            createModelCommand(),
+            createMCPCommand(),
+            createServeCommand()
+        ]
+    });
+    program.description(pkg.description);
+    return program;
+}

package/lib/ui.d.ts

@@ -0,0 +1,5 @@
+import { type SystemNoticeVariant } from '@tejika/ui';
+/** Render a one-shot status notice to stderr, then unmount. */
+export declare function renderNotice(variant: SystemNoticeVariant, text: string): void;
+/** Show a live spinner on stderr for the duration of `fn`, then unmount. */
+export declare function withSpinner<T>(label: string, fn: () => Promise<T>): Promise<T>;

package/lib/ui.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Spinner, SystemNotice } from '@tejika/ui';
+import { render } from 'ink';
+const renderToStderr = {
+    stdout: process.stderr
+};
+/** Render a one-shot status notice to stderr, then unmount. */ export function renderNotice(variant, text) {
+    const { unmount } = render(/*#__PURE__*/ _jsx(SystemNotice, {
+        variant: variant,
+        text: text
+    }), renderToStderr);
+    unmount();
+}
+/** Show a live spinner on stderr for the duration of `fn`, then unmount. */ export async function withSpinner(label, fn) {
+    const app = render(/*#__PURE__*/ _jsx(Spinner, {
+        label: label
+    }), renderToStderr);
+    try {
+        return await fn();
+    } finally{
+        app.unmount();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubun",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "description": "Kubun CLI",
   "keywords": [],
@@ -8,61 +8,52 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "/bin",
-    "/dist",
-    "/oclif.manifest.json"
+    "/lib"
   ],
   "bin": {
     "kubun": "./bin/run.js"
   },
-  "oclif": {
-    "bin": "kubun",
-    "dirname": "kubun",
-    "commands": "./dist/commands",
-    "plugins": [
-      "@oclif/plugin-help"
-    ],
-    "topicSeparator": " "
-  },
   "dependencies": {
-    "@enkaku/codec": "^0.15.0",
-    "@enkaku/token": "^0.15.0",
-    "@logtape/logtape": "^2.0.7",
-    "@mokei/context-server": "^0.6.0",
-    "@oclif/core": "^4.11.0",
-    "@oclif/plugin-help": "^6.2.46",
-    "@oclif/plugin-plugins": "^5.4.63",
-    "graphql": "^16.13.2",
-    "ora": "^9.4.0",
-    "@kubun/client": "^0.9.0",
-    "@kubun/db-node-sqlite": "^0.9.0",
-    "@kubun/db-postgres": "^0.9.0",
-    "@kubun/http-client": "^0.9.0",
-    "@kubun/engine": "^0.9.0",
-    "@kubun/logger": "^0.9.0",
-    "@kubun/graphql": "^0.9.0",
-    "@kubun/plugin-p2p": "^0.9.0",
-    "@kubun/plugin-http": "^0.9.0",
-    "@kubun/mcp": "^0.9.0",
-    "@kubun/plugin-rpc": "^0.9.0",
-    "@kubun/protocol": "^0.9.0"
+    "@kokuin/token": "^0.1.1",
+    "@logtape/logtape": "^2.2.3",
+    "@mokei/context-server": "^0.8.0",
+    "@sozai/codec": "^0.1.0",
+    "@tejika/cli": "^0.1.0",
+    "@tejika/env": "^0.1.0",
+    "@tejika/ui": "^0.1.0",
+    "commander": "^15.0.0",
+    "graphql": "^16.14.2",
+    "ink": "^7.1.0",
+    "react": "19.2.3",
+    "@kubun/client": "^0.11.0",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/db-node-sqlite": "^0.11.0",
+    "@kubun/http-client": "^0.11.0",
+    "@kubun/mcp": "^0.11.0",
+    "@kubun/graphql": "^0.11.0",
+    "@kubun/db-postgres": "^0.11.0",
+    "@kubun/logger": "^0.11.0",
+    "@kubun/plugin-p2p": "^0.11.0",
+    "@kubun/plugin-rpc": "^0.11.0",
+    "@kubun/plugin-http": "^0.11.0",
+    "@kubun/protocol": "^0.11.0"
   },
   "devDependencies": {
-    "@oclif/test": "^4.1.17",
-    "oclif": "^4.22.96",
-    "ts-node": "^10",
-    "typescript": "^6.0.3"
+    "ink-testing-library": "^4.0.0"
   },
   "scripts": {
     "kubun": "./bin/dev.js",
-    "build": "del dist && tsc -b",
-    "posttest": "pnpm run lint",
-    "test:types": "tsc --noEmit",
-    "test:unit": "OCLIF_TEST_ROOT=. vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit",
-    "version": "oclif readme && git add README.md"
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --skipLibCheck --declarationMap false",
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test:types": "tsc --noEmit --skipLibCheck",
+    "test:unit": "vitest run",
+    "test": "pnpm run test:types && pnpm run test:unit"
   }
 }

package/bin/dev.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/run.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\run" %*

package/dist/account.js

@@ -1,5 +0,0 @@
-import { fromB64 } from '@enkaku/codec';
-import { createSigningIdentity } from '@enkaku/token';
-export function getSigner(key) {
-    return createSigningIdentity(fromB64(key));
-}

package/dist/commands/account/generate.js

@@ -1,10 +0,0 @@
-import { toB64 } from '@enkaku/codec';
-import { randomPrivateKey } from '@enkaku/token';
-import { Command } from '@oclif/core';
-export default class GenerateAccount extends Command {
-    static description = 'Generate a random private key to use as account signer';
-    async run() {
-        const key = await randomPrivateKey();
-        this.log(toB64(key));
-    }
-}

package/dist/commands/account/id.js

@@ -1,18 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { getSigner } from '../../account.js';
-export default class AccountID extends Command {
-    static description = 'Display the DID of an account given its private key';
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(AccountID);
-        const signer = getSigner(flags.privateKey);
-        this.log(signer.id);
-    }
-}

package/dist/commands/graph/deploy.js

@@ -1,32 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-import { readJSON } from '../../fs.js';
-export default class DeployGraph extends Command {
-    static description = 'Deploy a documents model graph';
-    static flags = {
-        cluster: Flags.string({
-            description: 'path of the JSON file of the cluster',
-            char: 'c',
-            required: true,
-            multiple: true,
-        }),
-        id: Flags.string({ description: 'graph ID' }),
-        name: Flags.string({ description: 'graph name', char: 'n' }),
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-    };
-    async run() {
-        const spinner = ora('Deploying graph clusters...').start();
-        const { flags } = await this.parse(DeployGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const clusters = await Promise.all(flags.cluster.map((path) => readJSON(path)));
-        const graph = await client.deployGraph({ clusters, id: flags.id, name: flags.name });
-        spinner.succeed(`Deployed graph with ID: ${graph.id}`);
-    }
-}

package/dist/commands/graph/mutate.js

@@ -1,32 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-export default class MutateGraph extends Command {
-    static description = 'Execute a GraphQL mutation on a graph';
-    static args = {
-        id: Args.string({ description: 'graph ID', required: true }),
-        text: Args.string({ description: 'mutation text', required: true }),
-    };
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-        variables: Flags.string({ description: 'query variables as JSON string' }),
-    };
-    async run() {
-        const spinner = ora('Executing graph mutation...').start();
-        const { args, flags } = await this.parse(MutateGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const result = await client.mutateGraph({
-            id: args.id,
-            text: args.text,
-            variables: flags.variables ? JSON.parse(flags.variables) : {},
-        });
-        spinner.succeed('Graph mutation executed');
-        this.log(JSON.stringify(result, null, 2));
-    }
-}

package/dist/commands/graph/query.js

@@ -1,32 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-export default class QueryGraph extends Command {
-    static description = 'Execute a GraphQL query on a graph';
-    static args = {
-        id: Args.string({ description: 'graph ID', required: true }),
-        text: Args.string({ description: 'query text', required: true }),
-    };
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-        variables: Flags.string({ description: 'query variables as JSON string' }),
-    };
-    async run() {
-        const spinner = ora('Querying graph...').start();
-        const { args, flags } = await this.parse(QueryGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const result = await client.queryGraph({
-            id: args.id,
-            text: args.text,
-            variables: flags.variables ? JSON.parse(flags.variables) : {},
-        });
-        spinner.succeed('Graph query executed');
-        this.log(JSON.stringify(result, null, 2));
-    }
-}

package/dist/commands/graphql/schema.js

@@ -1,41 +0,0 @@
-import { createSchema } from '@kubun/graphql';
-import { clusterToRecord, GraphModel, } from '@kubun/protocol';
-import { Command, Flags } from '@oclif/core';
-import { printSchema } from 'graphql';
-import ora from 'ora';
-import { readJSON, writeFile } from '../../fs.js';
-export default class CreateGraphQLSchema extends Command {
-    static description = 'Create a GraphQL schema from clusters of document models';
-    static flags = {
-        cluster: Flags.string({
-            description: 'path of the JSON file of the cluster',
-            char: 'c',
-            required: true,
-            multiple: true,
-        }),
-        output: Flags.file({
-            description: 'output file for the GraphQL schema',
-            char: 'o',
-        }),
-    };
-    async run() {
-        const spinner = ora('Loading clusters...').start();
-        const { flags } = await this.parse(CreateGraphQLSchema);
-        const clusterModels = await Promise.all(flags.cluster.map((path) => readJSON(path)));
-        const clusters = {};
-        for (const cluster of clusterModels) {
-            Object.assign(clusters, clusterToRecord(cluster));
-        }
-        const model = GraphModel.fromClusters({ clusters });
-        const schema = printSchema(createSchema(model));
-        if (flags.output == null) {
-            spinner.succeed('GraphQL schema generated');
-            this.log(schema);
-        }
-        else {
-            await writeFile(flags.output, schema);
-            spinner.succeed(`GraphQL schema written to ${flags.output}`);
-        }
-        return schema;
-    }
-}