@taurgis/bonsai 1.0.0

package/dist/commands/config/get.js

@@ -0,0 +1,48 @@
+import { Args } from '@oclif/core';
+import { ConfigCommand, configScopeFlags } from './base.js';
+import { KEY_META, BUILT_IN_DEFAULTS, readScopedConfig } from '../../lib/config/index.js';
+export default class ConfigGet extends ConfigCommand {
+    static id = 'config get';
+    static summary = 'Get the effective value of a research configuration key.';
+    static description = 'Print a config value. Without --global/--local, shows the merged effective value (flag > env > project > user > default).\n\nValid keys: storage.';
+    static examples = [
+        {
+            description: 'Get the effective storage mode',
+            command: '<%= config.bin %> config get storage',
+        },
+        {
+            description: 'Read only the project-level value',
+            command: '<%= config.bin %> config get storage --local',
+        },
+    ];
+    static args = {
+        key: Args.string({ required: true, description: 'The configuration key to read.' }),
+    };
+    static flags = {
+        ...configScopeFlags({
+            global: 'Read from user-level config only.',
+            local: 'Read from project-level config only.',
+        }),
+    };
+    static stdoutIsPrimaryData = true;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse(ConfigGet);
+        this.args = args;
+        this.flags = flags;
+    }
+    async execute() {
+        const key = this.args.key;
+        this.assertKnownKey(key);
+        this.assertScopeFlagsExclusive(this.flags.global, this.flags.local);
+        const scope = this.readScope(this.flags.global, this.flags.local);
+        const value = readScopedConfig(scope, this.config.configDir, process.cwd())[key];
+        const meta = KEY_META[key];
+        const displayValue = value !== undefined ? value : BUILT_IN_DEFAULTS[key];
+        const formatted = meta.format(displayValue);
+        const suffix = value === undefined ? ' (not configured)' : '';
+        if (!this.requestedJson())
+            this.log(formatted + suffix);
+        return { key, value: displayValue };
+    }
+}

package/dist/commands/config/list.d.ts

@@ -0,0 +1,17 @@
+import { ConfigCommand } from './base.js';
+export default class ConfigList extends ConfigCommand<typeof ConfigList> {
+    static id: string;
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static stdoutIsPrimaryData: boolean;
+    init(): Promise<void>;
+    execute(): Promise<unknown>;
+}

package/dist/commands/config/list.js

@@ -0,0 +1,48 @@
+import { ConfigCommand, configScopeFlags } from './base.js';
+import { ALL_KEYS, KEY_META, BUILT_IN_DEFAULTS, readScopedConfig } from '../../lib/config/index.js';
+export default class ConfigList extends ConfigCommand {
+    static id = 'config list';
+    static summary = 'List all research configuration keys and their effective values.';
+    static description = 'Show every configuration key with its current value. Use --global/--local to show a single scope.\n\nValid keys: storage.';
+    static examples = [
+        {
+            description: 'Show all effective config values',
+            command: '<%= config.bin %> config list',
+        },
+        {
+            description: 'Show only project-level config',
+            command: '<%= config.bin %> config list --local',
+        },
+    ];
+    static flags = {
+        ...configScopeFlags({
+            global: 'Show user-level config only.',
+            local: 'Show project-level config only.',
+        }),
+    };
+    static stdoutIsPrimaryData = true;
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(ConfigList);
+        this.flags = flags;
+    }
+    async execute() {
+        this.assertScopeFlagsExclusive(this.flags.global, this.flags.local);
+        const scope = this.readScope(this.flags.global, this.flags.local);
+        const scoped = readScopedConfig(scope, this.config.configDir, process.cwd());
+        if (!this.requestedJson()) {
+            const width = Math.max(...ALL_KEYS.map((k) => k.length)) + 2;
+            for (const key of ALL_KEYS) {
+                const raw = scoped[key];
+                const formatted = raw !== undefined ? KEY_META[key].format(raw) : '(not configured)';
+                this.log(`${key.padEnd(width)}${formatted}`);
+            }
+        }
+        const values = {};
+        for (const key of ALL_KEYS) {
+            const raw = scoped[key];
+            values[key] = raw !== undefined ? raw : BUILT_IN_DEFAULTS[key];
+        }
+        return values;
+    }
+}

package/dist/commands/config/set.d.ts

@@ -0,0 +1,31 @@
+import { ConfigCommand } from './base.js';
+export default class ConfigSet extends ConfigCommand<typeof ConfigSet> {
+    static id: string;
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        key: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static stdoutIsPrimaryData: boolean;
+    init(): Promise<void>;
+    execute(): Promise<unknown>;
+}
+/**
+ * Accept the `key=value` convenience form alongside the canonical `key value`.
+ * Splits only when no separate value positional was supplied, and on the FIRST `=`
+ * so a value may itself contain `=`.
+ */
+export declare function splitInlineKeyValue(rawKey: string | undefined, rawValue: string | undefined): {
+    keyArg: string | undefined;
+    valueArg: string | undefined;
+};

package/dist/commands/config/set.js

@@ -0,0 +1,94 @@
+import { Args, Flags } from '@oclif/core';
+import { ConfigCommand, configScopeFlags } from './base.js';
+import { KEY_META, writeUserConfig, writeProjectConfig } from '../../lib/config/index.js';
+export default class ConfigSet extends ConfigCommand {
+    static id = 'config set';
+    static summary = 'Set a research configuration key.';
+    static description = 'Persist a configuration value. Writes user-level config by default; pass --local to write the project-level config (.bonsai.json in cwd).\n\n' +
+        'Valid keys: storage. The inline form `<key>=<value>` is also accepted.';
+    static examples = [
+        {
+            description: 'Store research cache inside the current project',
+            command: '<%= config.bin %> config set storage project --local',
+        },
+        {
+            description: 'Set the user-level default using the inline key=value form',
+            command: '<%= config.bin %> config set storage=global',
+        },
+    ];
+    static args = {
+        key: Args.string({ required: false, description: 'The configuration key to set.' }),
+        value: Args.string({ required: false, description: 'The value to assign.' }),
+    };
+    static flags = {
+        ...configScopeFlags({
+            global: 'Write to user-level config (default).',
+            local: 'Write to project-level config (.bonsai.json in cwd).',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Show what would be written without saving.',
+            default: false,
+        }),
+    };
+    static stdoutIsPrimaryData = true;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse(ConfigSet);
+        this.args = args;
+        this.flags = flags;
+    }
+    async execute() {
+        const { keyArg, valueArg } = splitInlineKeyValue(this.args.key, this.args.value);
+        if (!keyArg) {
+            this.error('Missing required argument: key', { exit: 2 });
+        }
+        this.assertKnownKey(keyArg);
+        this.assertScopeFlagsExclusive(this.flags.global, this.flags.local);
+        const meta = KEY_META[keyArg];
+        if (valueArg === undefined) {
+            this.error(`Missing required argument: value for key "${keyArg}"`, { exit: 2 });
+        }
+        const parsed = meta.parseValue(valueArg);
+        if (!meta.isValid(parsed)) {
+            const guidance = meta.values ? `Valid values: ${meta.values.join(', ')}.` : meta.description;
+            this.error(`Invalid value "${valueArg}" for "${keyArg}". ${guidance}`, { exit: 2 });
+        }
+        const scope = this.writeScope(this.flags.local);
+        const formatted = meta.format(parsed);
+        if (this.flags['dry-run']) {
+            if (!this.requestedJson())
+                this.log(`[dry-run] Would set ${keyArg} = ${formatted} (${scope})`);
+            return { key: keyArg, value: parsed, scope, dryRun: true };
+        }
+        const patch = { [keyArg]: parsed };
+        if (scope === 'project') {
+            writeProjectConfig(process.cwd(), patch);
+        }
+        else {
+            const configDir = this.config.configDir;
+            if (!configDir) {
+                this.error('Could not determine user config directory. Use --local to write project config.', {
+                    exit: 1,
+                });
+            }
+            writeUserConfig(configDir, patch);
+        }
+        if (!this.requestedJson())
+            this.log(`Set ${keyArg} = ${formatted} (${scope})`);
+        return { key: keyArg, value: parsed, scope, dryRun: false };
+    }
+}
+/**
+ * Accept the `key=value` convenience form alongside the canonical `key value`.
+ * Splits only when no separate value positional was supplied, and on the FIRST `=`
+ * so a value may itself contain `=`.
+ */
+export function splitInlineKeyValue(rawKey, rawValue) {
+    if (rawValue === undefined && rawKey !== undefined) {
+        const eq = rawKey.indexOf('=');
+        if (eq !== -1) {
+            return { keyArg: rawKey.slice(0, eq), valueArg: rawKey.slice(eq + 1) };
+        }
+    }
+    return { keyArg: rawKey, valueArg: rawValue };
+}

package/dist/commands/config/unset.d.ts

@@ -0,0 +1,21 @@
+import { ConfigCommand } from './base.js';
+export default class ConfigUnset extends ConfigCommand<typeof ConfigUnset> {
+    static id: string;
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static stdoutIsPrimaryData: boolean;
+    init(): Promise<void>;
+    execute(): Promise<unknown>;
+}

package/dist/commands/config/unset.js

@@ -0,0 +1,65 @@
+import { Args, Flags } from '@oclif/core';
+import { ConfigCommand, configScopeFlags } from './base.js';
+import { writeUserConfig, writeProjectConfig } from '../../lib/config/index.js';
+export default class ConfigUnset extends ConfigCommand {
+    static id = 'config unset';
+    static summary = 'Remove a research configuration key.';
+    static description = 'Delete a key from user-level config (default) or project-level config (--local), restoring the built-in default.\n\nValid keys: storage.';
+    static examples = [
+        {
+            description: 'Remove the user-level storage setting',
+            command: '<%= config.bin %> config unset storage',
+        },
+        {
+            description: 'Remove the project-level storage setting',
+            command: '<%= config.bin %> config unset storage --local',
+        },
+    ];
+    static args = {
+        key: Args.string({ required: true, description: 'The configuration key to remove.' }),
+    };
+    static flags = {
+        ...configScopeFlags({
+            global: 'Remove from user-level config (default).',
+            local: 'Remove from project-level config (.bonsai.json in cwd).',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Show what would be removed without saving.',
+            default: false,
+        }),
+    };
+    static stdoutIsPrimaryData = true;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse(ConfigUnset);
+        this.args = args;
+        this.flags = flags;
+    }
+    async execute() {
+        const key = this.args.key;
+        this.assertKnownKey(key);
+        this.assertScopeFlagsExclusive(this.flags.global, this.flags.local);
+        const scope = this.writeScope(this.flags.local);
+        if (this.flags['dry-run']) {
+            if (!this.requestedJson())
+                this.log(`[dry-run] Would unset ${key} (${scope})`);
+            return { key, scope, dryRun: true };
+        }
+        const patch = { [key]: undefined };
+        if (scope === 'project') {
+            writeProjectConfig(process.cwd(), patch);
+        }
+        else {
+            const configDir = this.config.configDir;
+            if (!configDir) {
+                this.error('Could not determine user config directory. Use --local to remove project config.', {
+                    exit: 1,
+                });
+            }
+            writeUserConfig(configDir, patch);
+        }
+        if (!this.requestedJson())
+            this.log(`Unset ${key} (${scope})`);
+        return { key, scope, dryRun: false };
+    }
+}

package/dist/commands/fetch.d.ts

@@ -0,0 +1,38 @@
+import { BaseCommand } from '../base-command.js';
+export default class FetchCommand extends BaseCommand<typeof FetchCommand> {
+    static id: string;
+    static hidden: boolean;
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        url: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        topic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tags: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<"compressed" | "detailed", import("@oclif/core/interfaces").CustomOptions>;
+        tier: import("@oclif/core/interfaces").OptionFlag<"stable" | "standard" | "volatile", import("@oclif/core/interfaces").CustomOptions>;
+        ttl: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-age': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'allow-stale': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        rendered: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        storage: import("@oclif/core/interfaces").OptionFlag<"global" | "project" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static stdoutIsPrimaryData: boolean;
+    protected envelopeCommandId(): string;
+    init(): Promise<void>;
+    private executeCacheHit;
+    private executeCacheMiss;
+    private buildResultData;
+    private validateDurationFlags;
+    private resolveArtifact;
+    private persistFreshArtifact;
+    private persistSectionsIfFresh;
+    execute(): Promise<unknown>;
+}