weaver-work-cli 0.1.0

package/dist/cmd/index.js

@@ -0,0 +1,18 @@
+import { commandsCommand } from './commands/index.js';
+import { configCommand } from './config/index.js';
+import { docsCommand } from './docs/index.js';
+import { doctorCommand } from './doctor/index.js';
+import { e10Command } from './e10/index.js';
+import { runCommand } from './run/index.js';
+import { setupCommand } from './setup/index.js';
+import { skillsCommand } from './skills/index.js';
+export const builtinCommands = [
+    configCommand,
+    docsCommand,
+    doctorCommand,
+    commandsCommand,
+    runCommand,
+    e10Command,
+    setupCommand,
+    skillsCommand,
+];

package/dist/cmd/register.js

@@ -0,0 +1,19 @@
+import { createAction } from './action.js';
+export async function registerCommands(program, ctx, commands) {
+    ctx.commands = commands.map((command) => ({
+        name: command.name,
+        description: command.description,
+        category: command.category,
+    }));
+    ctx.modules = ctx.commands;
+    for (const command of commands) {
+        if (command.hooks) {
+            ctx.hooks.register(command.hooks);
+        }
+    }
+    const action = createAction(ctx);
+    for (const command of commands) {
+        await command.register({ program, ctx, action });
+    }
+}
+export const registerModules = registerCommands;

package/dist/cmd/root.js

@@ -0,0 +1,36 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { createCliContext } from '../core/context.js';
+import { HookManager } from '../core/hooks.js';
+const CLI_COMMAND_NAME = 'weaver-work-cli';
+function readPackageInfo() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    return {
+        name: pkg.name || CLI_COMMAND_NAME,
+        version: pkg.version || '0.0.0',
+        description: pkg.description,
+    };
+}
+export function createProgram() {
+    const packageInfo = readPackageInfo();
+    const program = new Command();
+    const hooks = new HookManager();
+    const ctx = createCliContext(program, hooks, packageInfo);
+    program
+        .name(CLI_COMMAND_NAME)
+        .description(packageInfo.description || 'Extensible TypeScript CLI')
+        .version(packageInfo.version)
+        .option('--json', 'print command output as JSON')
+        .option('--quiet', 'suppress non-error logs')
+        .option('--verbose', 'print debug logs')
+        .option('--config <path>', 'use a custom weaver-work-cli config file')
+        .option('--auth <path>', 'use a specific E10 auth file')
+        .option('--profile <name>', 'use a specific E10 profile')
+        .option('--base-url <url>', 'override E10 base URL')
+        .option('--passport-url <url>', 'override E10 passport URL');
+    program.showHelpAfterError();
+    return { program, ctx };
+}

package/dist/cmd/run/index.js

@@ -0,0 +1,38 @@
+import { resolve } from 'node:path';
+import { CliError, ExitCode } from '../../core/errors.js';
+import { CommandRunner } from '../../services/command-runner.js';
+export const runCommand = {
+    name: 'run',
+    description: 'Generic external command runner with hooks',
+    category: 'system',
+    register({ program, action }) {
+        program.command('run')
+            .description('Run an external command through the shared command runner')
+            .argument('<command>', 'command to run')
+            .argument('[args...]', 'command arguments')
+            .option('--cwd <dir>', 'working directory')
+            .option('--shell', 'run through the platform shell')
+            .option('--inherit', 'inherit stdio instead of capturing output')
+            .allowUnknownOption(true)
+            .action(action(async (ctx, command, args, options) => {
+            if (typeof command !== 'string') {
+                throw new CliError('command must be a string', ExitCode.UsageError);
+            }
+            const opts = options && typeof options === 'object'
+                ? options
+                : {};
+            const result = await new CommandRunner(ctx).run(command, Array.isArray(args) ? args.map(String) : [], {
+                cwd: opts.cwd ? resolve(opts.cwd) : undefined,
+                shell: opts.shell,
+                stdio: opts.inherit ? 'inherit' : 'pipe',
+            });
+            if (!opts.inherit && result.stdout)
+                process.stdout.write(result.stdout);
+            if (!opts.inherit && result.stderr)
+                process.stderr.write(result.stderr);
+            if (result.code && result.code !== 0) {
+                throw new CliError('command exited with code ' + result.code, result.code);
+            }
+        }));
+    },
+};

package/dist/cmd/setup/index.js

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { findAuthFile } from '../../internal/e10/auth/session.js';
+import { defaultCodexSkillsRoot, installPackagedSkills, resolvePackagedSkillNames } from '../../internal/skills/install.js';
+const SKILLS_DIR = fileURLToPath(new URL('../../../skills/', import.meta.url));
+function versionMajor(version) {
+    return Number(version.replace(/^v/, '').split('.')[0] || 0);
+}
+export const setupCommand = {
+    name: 'setup',
+    description: 'One-step setup checks for business shortcuts',
+    category: 'system',
+    register({ program, action }) {
+        const setup = program.command('setup')
+            .description('One-step setup checks for business shortcuts');
+        setup.command('invoice')
+            .description('Check invoice CLI readiness and optionally install Agent skills')
+            .option('--install-skill', 'install packaged invoice Agent skill into Codex skills directory')
+            .option('--skill-target-dir <path>', 'override target Codex skills directory')
+            .action(action((ctx, options) => {
+            const opts = options && typeof options === 'object'
+                ? options
+                : {};
+            const authFile = findAuthFile(ctx.cwd, ctx.getGlobalOptions());
+            const packagedSkills = resolvePackagedSkillNames(SKILLS_DIR, 'invoice');
+            const checks = [
+                {
+                    name: 'node',
+                    ok: versionMajor(process.version) >= 18,
+                    detail: process.version,
+                },
+                {
+                    name: 'package',
+                    ok: true,
+                    detail: ctx.packageInfo.name + '@' + ctx.packageInfo.version,
+                },
+                {
+                    name: 'invoiceSkillPackaged',
+                    ok: packagedSkills.includes('weaver-work-cli-invoice'),
+                    detail: packagedSkills.join(', '),
+                },
+                {
+                    name: 'e10Auth',
+                    ok: Boolean(authFile && existsSync(authFile)),
+                    detail: authFile || 'not found',
+                },
+            ];
+            const skillInstall = opts.installSkill
+                ? installPackagedSkills(SKILLS_DIR, opts.skillTargetDir || defaultCodexSkillsRoot(ctx.env), 'invoice')
+                : null;
+            const nextActions = [];
+            if (!checks.find((check) => check.name === 'e10Auth')?.ok) {
+                nextActions.push('Run: weaver-work-cli auth login --base-url <E10_BASE_URL>');
+            }
+            if (!skillInstall) {
+                nextActions.push('Optional Agent setup: weaver-work-cli skills install invoice');
+            }
+            nextActions.push('Verify invoice operations: weaver-work-cli invoice schema');
+            const ok = checks.every((check) => check.ok);
+            ctx.output.write({
+                ok,
+                module: 'invoice',
+                checks,
+                skillInstall,
+                nextActions,
+            }, {
+                text: [
+                    ok ? 'Invoice setup checks passed.' : 'Invoice setup needs attention.',
+                    ...checks.map((check) => `- ${check.name}: ${check.ok ? 'ok' : 'missing'} (${check.detail})`),
+                    ...(skillInstall ? skillInstall.installed.map((entry) => `- installed skill: ${entry.name} -> ${entry.target}`) : []),
+                    'Next:',
+                    ...nextActions.map((actionText) => `- ${actionText}`),
+                ].join('\n'),
+            });
+        }));
+    },
+};

package/dist/cmd/skills/index.js

@@ -0,0 +1,72 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { CliError } from '../../core/errors.js';
+import { defaultCodexSkillsRoot, installPackagedSkills } from '../../internal/skills/install.js';
+import { SkillReader } from '../../internal/skills/reader.js';
+const SKILLS_DIR = fileURLToPath(new URL('../../../skills/', import.meta.url));
+function reader() {
+    if (!existsSync(SKILLS_DIR)) {
+        throw new CliError('skills directory does not exist: ' + SKILLS_DIR);
+    }
+    return new SkillReader(SKILLS_DIR);
+}
+function commandOptions(value) {
+    if (!value || typeof value !== 'object' || !('opts' in value))
+        return {};
+    const opts = value.opts();
+    return opts && typeof opts === 'object' ? opts : {};
+}
+export const skillsCommand = {
+    name: 'skills',
+    description: 'Read packaged agent skill content',
+    category: 'skills',
+    register({ program, action }) {
+        const skills = program.command('skills')
+            .description('Read packaged agent skill content');
+        skills.command('list')
+            .description('List skills, or list one layer under a skill path')
+            .argument('[target]', 'skill name or name/path')
+            .option('--json', 'accepted for symmetry; output is always JSON')
+            .action(action((ctx, target) => {
+            const skillReader = reader();
+            if (typeof target !== 'string' || !target) {
+                const listed = skillReader.list();
+                ctx.output.write({ ok: true, skills: listed, count: listed.length }, { json: true });
+                return;
+            }
+            const listed = skillReader.listPath(target);
+            ctx.output.write({ ok: true, ...listed, count: listed.entries.length }, { json: true });
+        }));
+        skills.command('read')
+            .description('Print a skill SKILL.md or a file under the skill')
+            .argument('<target>', 'skill name or name/path')
+            .argument('[path]', 'path under the skill')
+            .option('--json', 'output as a JSON envelope instead of raw markdown')
+            .action(action((ctx, target, pathArg, command) => {
+            if (typeof target !== 'string')
+                throw new CliError('target must be a string');
+            const opts = commandOptions(command || pathArg);
+            const result = reader().read(target, typeof pathArg === 'string' ? pathArg : '');
+            if (opts.json || ctx.getGlobalOptions().json) {
+                ctx.output.write(result, { json: true });
+                return;
+            }
+            ctx.output.raw(result.content);
+        }));
+        skills.command('install')
+            .description('Install packaged skills into Codex skills directory')
+            .argument('[target]', 'skill name, short name such as invoice, or all', 'all')
+            .option('--target-dir <path>', 'override target skills directory')
+            .action(action((ctx, target, options) => {
+            const opts = options && typeof options === 'object' ? options : {};
+            const targetRoot = opts.targetDir || defaultCodexSkillsRoot(ctx.env);
+            const result = installPackagedSkills(SKILLS_DIR, targetRoot, typeof target === 'string' ? target : 'all');
+            ctx.output.write(result, {
+                text: [
+                    'Installed packaged skills:',
+                    ...result.installed.map((entry) => `- ${entry.name} -> ${entry.target}`),
+                ].join('\n'),
+            });
+        }));
+    },
+};

package/dist/core/config-store.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class ConfigStore {
+    getPath;
+    constructor(getPath) {
+        this.getPath = getPath;
+    }
+    path() {
+        return this.getPath();
+    }
+    all() {
+        const filePath = this.path();
+        if (!existsSync(filePath))
+            return {};
+        try {
+            const value = JSON.parse(readFileSync(filePath, 'utf-8'));
+            return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    get(key) {
+        return this.all()[key];
+    }
+    set(key, value) {
+        const data = this.all();
+        data[key] = value;
+        this.save(data);
+    }
+    delete(key) {
+        const data = this.all();
+        const existed = Object.prototype.hasOwnProperty.call(data, key);
+        delete data[key];
+        this.save(data);
+        return existed;
+    }
+    save(data) {
+        const filePath = this.path();
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    }
+}

package/dist/core/context.js

@@ -0,0 +1,31 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { ConfigStore } from './config-store.js';
+import { Logger } from './logger.js';
+import { Output } from './output.js';
+export function createCliContext(program, hooks, packageInfo) {
+    const getGlobalOptions = () => program.opts();
+    const configStore = new ConfigStore(() => {
+        const opts = getGlobalOptions();
+        const home = process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+        return opts.config ? resolve(opts.config) : resolve(home, 'config.json');
+    });
+    const partialCtx = {
+        cwd: process.cwd(),
+        env: process.env,
+        program,
+        hooks,
+        packageInfo,
+        commands: [],
+        modules: [],
+        getGlobalOptions,
+        forCommand(command) {
+            return { ...ctx, activeCommand: command };
+        },
+    };
+    const ctx = partialCtx;
+    ctx.logger = new Logger(getGlobalOptions);
+    ctx.output = new Output(ctx);
+    ctx.config = configStore;
+    return ctx;
+}

package/dist/core/errors.js

@@ -0,0 +1,60 @@
+export var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["Success"] = 0] = "Success";
+    ExitCode[ExitCode["GeneralError"] = 1] = "GeneralError";
+    ExitCode[ExitCode["UsageError"] = 2] = "UsageError";
+    ExitCode[ExitCode["AuthError"] = 3] = "AuthError";
+    ExitCode[ExitCode["NetworkError"] = 4] = "NetworkError";
+    ExitCode[ExitCode["InternalError"] = 5] = "InternalError";
+    ExitCode[ExitCode["PolicyError"] = 6] = "PolicyError";
+    ExitCode[ExitCode["ConfirmationRequired"] = 10] = "ConfirmationRequired";
+    ExitCode[ExitCode["Partial"] = 11] = "Partial";
+})(ExitCode || (ExitCode = {}));
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = ExitCode.GeneralError) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+export function isCliError(error) {
+    return error instanceof CliError;
+}
+export function isStructuredError(error) {
+    return Boolean(error
+        && typeof error === 'object'
+        && 'type' in error
+        && 'subtype' in error
+        && 'message' in error
+        && typeof error.type === 'string'
+        && typeof error.subtype === 'string'
+        && typeof error.message === 'string');
+}
+export function toErrorEnvelope(error) {
+    if (isStructuredError(error)) {
+        return {
+            type: error.type,
+            subtype: error.subtype,
+            ...(error.code === undefined ? {} : { code: error.code }),
+            message: error.message,
+            retryable: error.retryable ?? false,
+            ...(error.stage ? { stage: error.stage } : {}),
+            ...(error.details === undefined ? {} : { details: error.details }),
+        };
+    }
+    if (isCliError(error)) {
+        return {
+            type: error.exitCode === ExitCode.AuthError ? 'authentication' : 'cli',
+            subtype: error.exitCode === ExitCode.UsageError ? 'usage' : 'error',
+            message: error.message,
+            retryable: false,
+        };
+    }
+    return {
+        type: 'internal',
+        subtype: 'unexpected',
+        message: error instanceof Error ? error.message : String(error),
+        retryable: false,
+    };
+}

package/dist/core/hooks.js

@@ -0,0 +1,41 @@
+export class HookManager {
+    hooks = {
+        beforeCommand: [],
+        afterCommand: [],
+        onError: [],
+        beforeRun: [],
+        afterRun: [],
+    };
+    register(hooks) {
+        for (const [name, handler] of Object.entries(hooks)) {
+            if (handler) {
+                this.hooks[name].push(handler);
+            }
+        }
+    }
+    async beforeCommand(ctx) {
+        for (const hook of this.hooks.beforeCommand) {
+            await hook(ctx);
+        }
+    }
+    async afterCommand(ctx, result) {
+        for (const hook of this.hooks.afterCommand) {
+            await hook(ctx, result);
+        }
+    }
+    async onError(ctx, error) {
+        for (const hook of this.hooks.onError) {
+            await hook(ctx, error);
+        }
+    }
+    async beforeRun(ctx) {
+        for (const hook of this.hooks.beforeRun) {
+            await hook(ctx);
+        }
+    }
+    async afterRun(ctx, result) {
+        for (const hook of this.hooks.afterRun) {
+            await hook(ctx, result);
+        }
+    }
+}

package/dist/core/logger.js

@@ -0,0 +1,27 @@
+export class Logger {
+    getOptions;
+    constructor(getOptions) {
+        this.getOptions = getOptions;
+    }
+    info(message) {
+        const opts = this.getOptions();
+        if (!opts.quiet && !opts.json) {
+            console.log(message);
+        }
+    }
+    warn(message) {
+        const opts = this.getOptions();
+        if (!opts.quiet && !opts.json) {
+            console.warn(message);
+        }
+    }
+    error(message) {
+        console.error(message);
+    }
+    debug(message) {
+        const opts = this.getOptions();
+        if (opts.verbose && !opts.json) {
+            console.error('[debug] ' + message);
+        }
+    }
+}

package/dist/core/output.js

@@ -0,0 +1,25 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+export function writeRawJson(outputPath, value) {
+    const absolutePath = resolve(outputPath);
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, JSON.stringify(value, null, 2), 'utf-8');
+    return absolutePath;
+}
+export class Output {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    write(value, options = {}) {
+        const globalOptions = this.ctx.getGlobalOptions();
+        if (globalOptions.json || options.json || !options.text) {
+            console.log(JSON.stringify(value, null, 2));
+            return;
+        }
+        console.log(options.text);
+    }
+    raw(message) {
+        console.log(message);
+    }
+}

package/dist/core/write-with-retry.js

@@ -0,0 +1,21 @@
+import { writeFileSync } from 'node:fs';
+const RETRIABLE_WRITE_ERRORS = new Set(['EPERM', 'EACCES', 'EBUSY', 'ENOTEMPTY']);
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export function writeWithRetry(path, data, options) {
+    const maxAttempts = 4;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            writeFileSync(path, data, options);
+            return;
+        }
+        catch (error) {
+            const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+            if (!RETRIABLE_WRITE_ERRORS.has(code) || attempt === maxAttempts - 1) {
+                throw error;
+            }
+            sleepSync(80 * (attempt + 1));
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { builtinCommands } from './cmd/index.js';
+import { createProgram } from './cmd/root.js';
+import { registerCommands } from './cmd/register.js';
+import { builtinShortcuts } from './shortcuts/index.js';
+const { program, ctx } = createProgram();
+await registerCommands(program, ctx, [
+    ...builtinCommands,
+    ...builtinShortcuts,
+]);
+await program.parseAsync();