@shahimat/cli 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Журнал @shahimat/cli
+
+Свежее сверху.
+
+## 0.1.1
+
+- `@shahimat/ai-core` 0.1.1.
+
+## 0.1.0
+
+- Опции `--all`, `--every`, `--until`, `--job`, `--timeout` для команд
+  `ai ops …`.
+
+- Пакет — точка входа: бинарь `ai`, скрипты `check`, `refresh`,
+  `docs verify` (перенесены из `@shahimat/ai-core`), оболочка, дерево
+  команд из `ai-core`, автоматов `@shahimat/harness` (динамически, если
+  установлен) и расширений проекта из `.agents/commands`,
+  `.agents/scripts`, `.agents/harnesses`.
+- `runtime` для автоматов и ролей: исполнитель скриптов и команда `ai`.

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# @shahimat/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CLI `ai` — единая точка входа для проектов на контракте
+[`agent-operational-contract-v3`](https://github.com/Shahimat/ai-prompts/blob/main/prompts/productivity/agent-operational-contract-v3.md):
+команды ядра [`@shahimat/ai-core`](https://www.npmjs.com/package/@shahimat/ai-core),
+скрипты, автоматы [`@shahimat/harness`](https://www.npmjs.com/package/@shahimat/harness)
+(если пакет установлен) и расширения проекта.
+
+Node ≥ 24. macOS, Linux, Windows.
+
+## Запуск
+
+Пакеты — в `devDependencies` проекта с точными версиями, вызов — из корня:
+
+```bash
+npx ai <команда | скрипт | автомат> … [--root <dir>]
+npx ai --help                 # дерево всего, что видно в этом проекте
+npx ai                        # оболочка с переходом по уровням
+```
+
+## Скрипты
+
+- `ai check` — все проверки, включённые в `context/ai-core.yml`.
+- `ai refresh` — `context index`, `adapters sync` (если включены), затем
+  шаги `check`.
+
+Скрипт — только последовательность команд, без своей логики. Скрипт
+`docs verify` — шаг автомата `docs-delta`, в справке не виден.
+
+## Расширения проекта
+
+`ai` подхватывает их при каждом запуске:
+
+- `.agents/commands/<name>.{ts,mjs,js}` — своя команда:
+  `export default { path: [...], effect: 'query' | 'mutation', options?, run }`;
+- `.agents/scripts/<name>.yml` — свой скрипт: `path` и `steps`
+  (`command: [...]`);
+- `.agents/harnesses/<name>/` — свой автомат: `harness.yaml` и
+  `handlers/*.ts`; нужен `@shahimat/harness`;
+- `.agents/agents/<name>.md` — свои роли (их запускает `ai role run` и
+  автоматы).
+
+Имя, занятое встроенной командой, скриптом или автоматом, — ошибка. Своя
+команда — атомарная операция; скрипт — последовательность команд.
+
+## Runtime
+
+При старте `ai` задаёт `runtime` из `@shahimat/ai-core`: исполнитель
+скриптов по пути и команду самого себя. Через него автоматы зовут
+скрипты (`docs verify`, `refresh`), роли поднимают MCP-канал
+(`ai role channel`), `expect serve` рендерит отчёт. Без `ai` runtime не
+задан — ошибка.
+
+## Лицензия
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from './cli.js';
+process.exitCode = await run(process.argv.slice(2));

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+import { type CommandTree } from '@shahimat/ai-core';
+export declare function projectOf(start: string): string | undefined;
+export declare function cliMain(tree: CommandTree, argv: string[], now?: Date): Promise<number>;
+export declare function selfCommand(): string[];
+export declare function prepare(argv: readonly string[]): Promise<CommandTree>;
+export declare const main: (argv: string[], now?: Date) => Promise<number>;
+export declare function runCli(tree: CommandTree, argv: string[]): Promise<number>;
+export declare function run(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,155 @@
+import { existsSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { runShell } from './shell.js';
+import { fileURLToPath } from 'node:url';
+import { setRuntime } from '@shahimat/ai-core';
+import { runScript } from './scripts/index.js';
+import { loadTree } from './tree.js';
+import { UsageError } from '@shahimat/ai-core';
+import { errorCode, errorMessage } from '@shahimat/ai-core';
+export function projectOf(start) {
+    const home = path.resolve(homedir());
+    for (let dir = path.resolve(start);; dir = path.dirname(dir)) {
+        const claude = path.join(dir, '.claude');
+        if (dir !== home && existsSync(claude) && statSync(claude).isDirectory())
+            return dir;
+        if (path.dirname(dir) === dir)
+            return undefined;
+    }
+}
+export async function cliMain(tree, argv, now = new Date()) {
+    const { childrenOf, findCommand, isNamespace, renderUsage } = tree;
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            root: { type: 'string' },
+            out: { type: 'string' },
+            file: { type: 'string' },
+            html: { type: 'string' },
+            port: { type: 'string' },
+            'raw-base': { type: 'string' },
+            apply: { type: 'boolean' },
+            run: { type: 'boolean' },
+            home: { type: 'string' },
+            name: { type: 'string' },
+            request: { type: 'string' },
+            all: { type: 'boolean' },
+            every: { type: 'string' },
+            until: { type: 'string' },
+            job: { type: 'string' },
+            timeout: { type: 'string' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    if (values.help === true) {
+        console.log(renderUsage(positionals));
+        return 0;
+    }
+    const match = findCommand(positionals);
+    const root = values.root !== undefined
+        ? path.resolve(values.root)
+        : match?.command.kind === 'harness'
+            ? (projectOf(process.cwd()) ?? process.cwd())
+            : path.resolve('.');
+    const args = { root, now };
+    if (values.out !== undefined)
+        args.out = values.out;
+    if (values.file !== undefined)
+        args.file = values.file;
+    if (values.html !== undefined)
+        args.html = values.html;
+    if (values.port !== undefined)
+        args.port = values.port;
+    if (values['raw-base'] !== undefined)
+        args.rawBase = values['raw-base'];
+    if (values.apply === true)
+        args.apply = true;
+    if (values.run === true)
+        args.run = true;
+    if (values.home !== undefined)
+        args.home = values.home;
+    if (values.name !== undefined)
+        args.name = values.name;
+    if (values.request !== undefined)
+        args.request = values.request;
+    if (values.all === true)
+        args.all = true;
+    if (values.every !== undefined)
+        args.every = values.every;
+    if (values.until !== undefined)
+        args.until = values.until;
+    if (values.job !== undefined)
+        args.job = values.job;
+    if (values.timeout !== undefined)
+        args.timeout = values.timeout;
+    if (match !== undefined)
+        return match.command.run({ ...args, params: match.params });
+    const last = positionals.at(-1);
+    const prefix = positionals.slice(0, -1);
+    if (last === 'help' && (prefix.length === 0 || isNamespace(prefix))) {
+        console.log(renderUsage(prefix));
+        return 0;
+    }
+    if (last === 'list' && (prefix.length === 0 || isNamespace(prefix))) {
+        console.log(childrenOf(prefix).join('\n'));
+        return 0;
+    }
+    if (positionals.length > 0 && isNamespace(positionals))
+        throw new UsageError(`${positionals.join(' ')} — уровень, а не команда: ${childrenOf(positionals).join(' | ')}`);
+    throw new UsageError(`неизвестная команда: ${positionals.join(' ') || '<пусто>'}`);
+}
+export function selfCommand() {
+    const bin = fileURLToPath(import.meta.resolve('#bin'));
+    return bin.endsWith('.ts')
+        ? [process.execPath, '--conditions=source', bin]
+        : [process.execPath, bin];
+}
+function rootOf(argv) {
+    const i = argv.indexOf('--root');
+    const given = i >= 0 ? argv[i + 1] : argv.find((a) => a.startsWith('--root='))?.slice(7);
+    return given !== undefined ? path.resolve(given) : (projectOf(process.cwd()) ?? process.cwd());
+}
+export async function prepare(argv) {
+    const { tree, scripts } = await loadTree(rootOf(argv));
+    setRuntime({
+        self: selfCommand(),
+        runScript: (scriptPath, args) => {
+            const def = scripts.find((s) => s.path.join(' ') === scriptPath.join(' '));
+            if (def === undefined)
+                throw new UsageError(`нет скрипта ${scriptPath.join(' ')}`);
+            return runScript(def, args);
+        },
+    });
+    return tree;
+}
+export const main = async (argv, now = new Date()) => cliMain(await prepare(argv), argv, now);
+export async function runCli(tree, argv) {
+    const again = (words) => runCli(tree, words);
+    if (argv.length === 0 && process.stdin.isTTY && process.stdout.isTTY)
+        return runShell(again, tree);
+    try {
+        return await cliMain(tree, argv);
+    }
+    catch (error) {
+        console.error(`ERROR: ${errorMessage(error)}`);
+        if (error instanceof UsageError) {
+            console.error(tree.renderUsage());
+            return 2;
+        }
+        return (errorCode(error) ?? '').startsWith('ERR_PARSE_ARGS') ? 2 : 1;
+    }
+}
+export async function run(argv) {
+    let tree;
+    try {
+        tree = await prepare(argv);
+    }
+    catch (error) {
+        console.error(`ERROR: ${errorMessage(error)}`);
+        return 2;
+    }
+    return runCli(tree, argv);
+}

package/dist/extensions.d.ts

@@ -0,0 +1,14 @@
+import { type CommandNode, type ScriptDef } from '@shahimat/ai-core';
+export declare const EXTENSION_DIRS: {
+    readonly commands: '.agents/commands';
+    readonly scripts: '.agents/scripts';
+    readonly harnesses: '.agents/harnesses';
+};
+export declare function projectCommands(root: string): Promise<CommandNode[]>;
+export declare function projectScripts(root: string): Promise<ScriptDef[]>;
+export interface HarnessApi {
+    nodes: readonly CommandNode[];
+    project: (dir: string) => CommandNode[];
+}
+export declare function loadHarness(): Promise<HarnessApi | undefined>;
+export declare function projectHarnesses(root: string, harness: HarnessApi | undefined): Promise<CommandNode[]>;

package/dist/extensions.js

@@ -0,0 +1,128 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { errorCode, errorMessage, isRecord, isStringArray, UsageError, } from '@shahimat/ai-core';
+import { parse } from 'yaml';
+export const EXTENSION_DIRS = {
+    commands: '.agents/commands',
+    scripts: '.agents/scripts',
+    harnesses: '.agents/harnesses',
+};
+async function listDir(dir) {
+    try {
+        return (await readdir(dir)).sort();
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+function asCommand(value, where) {
+    if (!isRecord(value) ||
+        !isStringArray(value['path']) ||
+        value['path'].length === 0 ||
+        (value['effect'] !== 'query' && value['effect'] !== 'mutation') ||
+        typeof value['run'] !== 'function')
+        throw new UsageError(`${where}: export default { path: string[], effect: query | mutation, run }`);
+    const run = value['run'];
+    const node = {
+        path: value['path'],
+        kind: 'command',
+        effect: value['effect'],
+        run: async (args) => {
+            const code = await Reflect.apply(run, undefined, [args]);
+            return typeof code === 'number' ? code : 0;
+        },
+    };
+    if (typeof value['options'] === 'string')
+        node.options = value['options'];
+    return node;
+}
+export async function projectCommands(root) {
+    const dir = path.join(root, EXTENSION_DIRS.commands);
+    const out = [];
+    for (const name of (await listDir(dir)).filter((n) => /\.(ts|js|mjs)$/.test(n))) {
+        const where = `${EXTENSION_DIRS.commands}/${name}`;
+        let mod;
+        try {
+            mod = await import(__rewriteRelativeImportExtension(pathToFileURL(path.join(dir, name)).href));
+        }
+        catch (error) {
+            throw new UsageError(`${where}: ${errorMessage(error).split('\n')[0] ?? ''}`);
+        }
+        out.push(asCommand(isRecord(mod) ? mod['default'] : undefined, where));
+    }
+    return out;
+}
+function asStep(value, where) {
+    if (!isRecord(value) || !isStringArray(value['command']))
+        throw new UsageError(`${where}: шаг — { command: string[] }`);
+    return { command: value['command'] };
+}
+export async function projectScripts(root) {
+    const dir = path.join(root, EXTENSION_DIRS.scripts);
+    const out = [];
+    for (const name of (await listDir(dir)).filter((n) => n.endsWith('.yml'))) {
+        const where = `${EXTENSION_DIRS.scripts}/${name}`;
+        const data = parse(await readFile(path.join(dir, name), 'utf8'));
+        if (!isRecord(data) || !isStringArray(data['path']) || !Array.isArray(data['steps']))
+            throw new UsageError(`${where}: скрипт — { path: string[], steps: [{ command: string[] }] }`);
+        out.push({
+            path: data['path'],
+            steps: data['steps'].map((s, i) => asStep(s, `${where}: steps[${i}]`)),
+        });
+    }
+    return out;
+}
+export async function loadHarness() {
+    let mod;
+    try {
+        mod = await import('@shahimat/harness');
+    }
+    catch (error) {
+        if (errorCode(error) === 'ERR_MODULE_NOT_FOUND')
+            return undefined;
+        throw error;
+    }
+    if (!isRecord(mod))
+        return undefined;
+    const { HARNESS_NODES, harnessNodes, projectHarnessModule } = mod;
+    if (!Array.isArray(HARNESS_NODES) ||
+        typeof harnessNodes !== 'function' ||
+        typeof projectHarnessModule !== 'function')
+        throw new UsageError('@shahimat/harness: несовместимая версия — нет HARNESS_NODES');
+    const nodes = HARNESS_NODES.filter(isCommandNode);
+    return {
+        nodes,
+        project: (dir) => {
+            const module = Reflect.apply(projectHarnessModule, undefined, [dir]);
+            const list = Reflect.apply(harnessNodes, undefined, [module]);
+            return Array.isArray(list) ? list.filter(isCommandNode) : [];
+        },
+    };
+}
+function isCommandNode(v) {
+    return (isRecord(v) &&
+        isStringArray(v['path']) &&
+        (v['kind'] === 'command' || v['kind'] === 'harness') &&
+        typeof v['run'] === 'function');
+}
+export async function projectHarnesses(root, harness) {
+    const dir = path.join(root, EXTENSION_DIRS.harnesses);
+    const names = (await listDir(dir)).filter((n) => existsSync(path.join(dir, n, 'harness.yaml')));
+    if (names.length === 0)
+        return [];
+    if (harness === undefined)
+        throw new UsageError(`${EXTENSION_DIRS.harnesses}: свои автоматы есть, а пакета @shahimat/harness нет — подключи модуль harness`);
+    return names.flatMap((n) => harness.project(path.join(dir, n)));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { cliMain, main, prepare, projectOf, run, runCli, selfCommand } from './cli.ts';
+export { promptOf, runShell, shellStep, splitWords, type ShellStep } from './shell.ts';
+export { BIN, BUILTIN, BUILTIN_TREE, loadTree, scriptCommand, SCRIPTS, type LoadedTree, } from './tree.ts';
+export { CHECK, DOCS_VERIFY, REFRESH, runScript } from './scripts/index.ts';
+export { EXTENSION_DIRS, loadHarness, projectCommands, projectHarnesses, projectScripts, type HarnessApi, } from './extensions.ts';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { cliMain, main, prepare, projectOf, run, runCli, selfCommand } from './cli.js';
+export { promptOf, runShell, shellStep, splitWords } from './shell.js';
+export { BIN, BUILTIN, BUILTIN_TREE, loadTree, scriptCommand, SCRIPTS, } from './tree.js';
+export { CHECK, DOCS_VERIFY, REFRESH, runScript } from './scripts/index.js';
+export { EXTENSION_DIRS, loadHarness, projectCommands, projectHarnesses, projectScripts, } from './extensions.js';

package/dist/scripts/check.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptDef } from '@shahimat/ai-core';
+export declare const CHECK: ScriptDef;

package/dist/scripts/check.js

@@ -0,0 +1,9 @@
+export const CHECK = {
+    path: ['check'],
+    steps: [
+        { command: ['changelog', 'lint'], enabledBy: 'changelog' },
+        { command: ['context', 'check'], enabledBy: 'context-index' },
+        { command: ['adapters', 'check'], enabledBy: 'adapters' },
+        { command: ['secrets', 'scan'], enabledBy: 'secrets' },
+    ],
+};

package/dist/scripts/docs-verify.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptDef } from '@shahimat/ai-core';
+export declare const DOCS_VERIFY: ScriptDef;

package/dist/scripts/docs-verify.js

@@ -0,0 +1,10 @@
+import { CHECK } from './check.js';
+export const DOCS_VERIFY = {
+    path: ['docs', 'verify'],
+    steps: [
+        { command: ['context', 'index'], enabledBy: 'context-index' },
+        { command: ['adapters', 'sync'], enabledBy: 'adapters' },
+        { command: ['delta', 'check'] },
+        ...CHECK.steps,
+    ],
+};

package/dist/scripts/index.d.ts

@@ -0,0 +1,4 @@
+export { CHECK } from './check.ts';
+export { DOCS_VERIFY } from './docs-verify.ts';
+export { REFRESH } from './refresh.ts';
+export { runScript } from './run.ts';

package/dist/scripts/index.js

@@ -0,0 +1,4 @@
+export { CHECK } from './check.js';
+export { DOCS_VERIFY } from './docs-verify.js';
+export { REFRESH } from './refresh.js';
+export { runScript } from './run.js';

package/dist/scripts/refresh.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptDef } from '@shahimat/ai-core';
+export declare const REFRESH: ScriptDef;

package/dist/scripts/refresh.js

@@ -0,0 +1,9 @@
+import { CHECK } from './check.js';
+export const REFRESH = {
+    path: ['refresh'],
+    steps: [
+        { command: ['context', 'index'], enabledBy: 'context-index' },
+        { command: ['adapters', 'sync'], enabledBy: 'adapters' },
+        ...CHECK.steps,
+    ],
+};

package/dist/scripts/run.d.ts

@@ -0,0 +1,3 @@
+import type { CommandArgs } from '@shahimat/ai-core';
+import type { ScriptDef } from '@shahimat/ai-core';
+export declare function runScript(script: ScriptDef, args: CommandArgs): Promise<number>;

package/dist/scripts/run.js

@@ -0,0 +1,29 @@
+import { CONFIG_PATH, loadConfig } from '@shahimat/ai-core';
+import { UsageError } from '@shahimat/ai-core';
+import { COMMAND_NODES } from '@shahimat/ai-core';
+const commandOf = (path) => COMMAND_NODES.find((c) => c.path.length === path.length && c.path.every((p, i) => p === path[i]));
+export async function runScript(script, args) {
+    const name = script.path.join(' ');
+    const gated = script.steps.some((s) => s.enabledBy !== undefined);
+    const config = gated ? await loadConfig(args.root) : null;
+    if (gated && config === null)
+        throw new UsageError(`нет ${CONFIG_PATH}: harness в проекте не настроен`);
+    const steps = script.steps.filter((s) => s.enabledBy === undefined || config?.checks[s.enabledBy] !== undefined);
+    if (steps.length === 0) {
+        console.log(`${name}: в ${CONFIG_PATH} не включено ни одной проверки`);
+        return 0;
+    }
+    let code = 0;
+    for (const step of steps) {
+        const command = commandOf(step.command);
+        if (command === undefined)
+            throw new Error(`${name}: нет команды ${step.command.join(' ')}`);
+        code = Math.max(code, await command.run({ ...args, params: {} }));
+    }
+    const ran = steps.map((s) => s.command.join(' ')).join(', ');
+    if (code === 0)
+        console.log(`${name} (${ran}): ok`);
+    else
+        console.error(`${name} (${ran}): есть нарушения`);
+    return code;
+}

package/dist/shell.d.ts

@@ -0,0 +1,11 @@
+import type { CommandTree } from '@shahimat/ai-core';
+export declare function splitWords(line: string): string[];
+export interface ShellStep {
+    cwd: string[];
+    run?: string[];
+    output?: string;
+    exit?: boolean;
+}
+export declare function shellStep(cwd: readonly string[], line: string, tree: CommandTree): ShellStep;
+export declare const promptOf: (cwd: readonly string[], bin?: string) => string;
+export declare function runShell(exec: (words: string[]) => Promise<number>, tree: CommandTree): Promise<number>;

package/dist/shell.js

@@ -0,0 +1,57 @@
+import { createInterface } from 'node:readline/promises';
+export function splitWords(line) {
+    const words = [];
+    for (const m of line.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g))
+        words.push(m[1] ?? m[2] ?? m[3] ?? '');
+    return words;
+}
+export function shellStep(cwd, line, tree) {
+    const { childrenOf, findCommand, isNamespace, renderUsage } = tree;
+    const words = splitWords(line);
+    const here = [...cwd];
+    if (words.length === 0)
+        return { cwd: here };
+    const [first = ''] = words;
+    if (words.length === 1 && (first === 'exit' || first === 'quit'))
+        return { cwd: here, exit: true };
+    if (words.length === 1 && first === '..')
+        return { cwd: here.slice(0, -1) };
+    if (words.length === 1 && first === 'help')
+        return { cwd: here, output: renderUsage(here) };
+    const full = [...here, ...words];
+    const own = isNamespace([...here, 'list']) || findCommand([...here, 'list']) !== undefined;
+    if (first === 'list' && words.length === 1 && !own) {
+        return { cwd: here, output: childrenOf(here).join('\n') };
+    }
+    if (isNamespace(full) && words.every((w) => w !== 'list' && w !== 'help'))
+        return { cwd: full };
+    return { cwd: here, run: full };
+}
+export const promptOf = (cwd, bin = 'ai') => `/${[bin, ...cwd].join('/')}> `;
+export async function runShell(exec, tree) {
+    let cwd = [];
+    for (;;) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        let line;
+        try {
+            line = await rl.question(promptOf(cwd, tree.bin));
+        }
+        catch {
+            return 0;
+        }
+        finally {
+            rl.close();
+        }
+        const step = shellStep(cwd, line, tree);
+        cwd = step.cwd;
+        if (step.exit === true)
+            return 0;
+        if (step.output !== undefined)
+            console.log(step.output);
+        if (step.run !== undefined) {
+            const code = await exec(step.run);
+            if (code !== 0)
+                console.log(`код ${code}`);
+        }
+    }
+}

package/dist/tree.d.ts

@@ -0,0 +1,11 @@
+import { type Command, type CommandTree, type ScriptDef } from '@shahimat/ai-core';
+export declare const BIN = "ai";
+export declare const SCRIPTS: readonly ScriptDef[];
+export declare const scriptCommand: (def: ScriptDef) => Command;
+export declare const BUILTIN: readonly Command[];
+export declare const BUILTIN_TREE: CommandTree;
+export interface LoadedTree {
+    tree: CommandTree;
+    scripts: readonly ScriptDef[];
+}
+export declare function loadTree(root: string): Promise<LoadedTree>;

package/dist/tree.js

@@ -0,0 +1,38 @@
+import { COMMAND_NODES, commandTree, UsageError, } from '@shahimat/ai-core';
+import { loadHarness, projectCommands, projectHarnesses, projectScripts } from './extensions.js';
+import { CHECK, DOCS_VERIFY, REFRESH, runScript } from './scripts/index.js';
+export const BIN = 'ai';
+export const SCRIPTS = [CHECK, REFRESH, DOCS_VERIFY];
+const CLI_SCRIPTS = [CHECK, REFRESH];
+export const scriptCommand = (def) => ({
+    path: def.path,
+    kind: 'script',
+    steps: def.steps,
+    run: (args) => runScript(def, args),
+});
+export const BUILTIN = [...CLI_SCRIPTS.map(scriptCommand), ...COMMAND_NODES];
+export const BUILTIN_TREE = commandTree(BIN, BUILTIN);
+function noClashes(builtin, own) {
+    const key = (c) => c.path.join(' ');
+    const taken = new Set(builtin.map(key));
+    const seen = new Set();
+    for (const c of own) {
+        if (taken.has(key(c)))
+            throw new UsageError(`${key(c)}: имя занято встроенной командой — переименуй расширение`);
+        if (seen.has(key(c)))
+            throw new UsageError(`${key(c)}: два расширения с одним именем`);
+        seen.add(key(c));
+    }
+}
+export async function loadTree(root) {
+    const harness = await loadHarness();
+    const builtin = [...BUILTIN, ...(harness?.nodes ?? [])];
+    const scripts = await projectScripts(root);
+    const own = [
+        ...scripts.map(scriptCommand),
+        ...(await projectCommands(root)),
+        ...(await projectHarnesses(root, harness)),
+    ];
+    noClashes(builtin, own);
+    return { tree: commandTree(BIN, [...builtin, ...own]), scripts: [...SCRIPTS, ...scripts] };
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@shahimat/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "CLI ai для проектов на контрактах ai-prompts: команды ai-core, скрипты, автоматы harness и расширения проекта",
+  "license": "MIT",
+  "author": "Gevorg Nakhapetyan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Shahimat/ai-prompts.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/Shahimat/ai-prompts/tree/main/packages/cli#readme",
+  "bugs": {
+    "url": "https://github.com/Shahimat/ai-prompts/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "cli",
+    "agents-md",
+    "claude-code"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "ai": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#*": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "node ../build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "@shahimat/ai-core": "0.1.1",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.2",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
+  },
+  "peerDependencies": {
+    "@shahimat/harness": ">=0.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@shahimat/harness": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}