@niujiajie/freespec 0.0.0-stage → 1.15.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 OpenSpec Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,3 +1,59 @@
-# Temporary Holding Version
+# FreeSpec
 
-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.
+AI 原生的规格驱动开发（spec-driven development）命令行工具（[@niujiajie/freespec](https://gitee.com/niu_jiajie/openspec.git)）。核心思路：先在 `freespec/` 目录下为每次变更写规格文档（需求、设计、任务清单、用例），再由 AI 编码工具按文档实现，文档与实现互相约束。
+
+## 工作流
+
+- 变更目录在 `freespec/<名称>变更/`，默认 schema 是 `默认`。
+- `默认` schema（见 [schema.yaml](schemas/默认/schema.yaml)）定义四份可选的中文文档，无先后依赖，可单独写：
+  - `需求文档.md` —— 给人看的需求说明；
+  - `设计文档.md` —— 按章写的设计说明，由 `scripts/check-design.mjs` 校验；
+  - `任务清单.md` —— 可勾选（`- [ ]` / `- [x]`）的执行清单；
+  - `测试用例.md` —— 输入、操作、期望三段式用例，不写具体语言的测试代码。
+- 每份文档都有配套模板（[schemas/默认/templates/](schemas/默认/templates/)）和给 AI 的写作指令。
+- `apply` 阶段：以已有文档为上下文实现代码，有用例时先落成失败的测试再写实现。
+
+## 命令
+
+终端里的全局 `freespec` 若是旧版本，请统一用本仓库编出来的命令：
+
+```powershell
+node bin/freespec.js init --tools cursor --profile core --no-animation
+node bin/freespec.js new change 登录改造
+```
+
+已有项目在项目目录里执行 `node bin/freespec.js update` 更新指令文件。装完后重启 Cursor，入口是 `/freespec-新建` 等斜杠命令（技能见 [skill-files/](skill-files/)：新建、需求、设计、任务、用例、写Java、审Java、审文档、深思、验收）。
+
+| 命令 | 说明 |
+| --- | --- |
+| `init [path]` | 初始化项目，为指定 AI 工具生成指令文件和技能 |
+| `update [path]` | 更新已生成文件，支持 `--dry-run` / `--json` |
+| `new change <name>` | 新建变更目录，支持 `--schema`、`--json` |
+| `list` | 列出 `freespec/` 下的变更目录，支持 `--sort` / `--json` |
+| `status` | 查看变更产物完成度，支持 `--change`、`--all`、`--json` |
+| `instructions [artifact]` | 输出某产物或 `apply` 的增强指令 |
+
+## 支持的 AI 工具
+
+`--tools` 可选 `all`、`none` 或逗号分隔列表，覆盖 50+ 工具（定义在 [config.ts](src/core/config.ts)），包括 Cursor、Claude Code、Codex、Gemini CLI、GitHub Copilot、Trae、Qwen Code、OpenCode 等，以及通用的 `.agents` 共享技能目录。
+
+## 目录结构
+
+```
+bin/            CLI 入口（freespec.js）
+src/cli/        Commander 命令定义
+src/commands/   命令实现（workflow：new-change、status、instructions）
+src/core/       核心逻辑（init、update、change-layout、profiles、config 等）
+schemas/        工作流 schema 与文档模板（默认 schema：默认）
+skill-files/    生成到各 AI 工具的技能源文件
+scripts/        构建与校验脚本
+dist/           构建产物（tsc 输出）
+```
+
+## 开发
+
+- Node.js >= 20.19，pnpm 包管理，ESM + TypeScript。
+- `pnpm build`：清理 `dist/` 并用本地 tsc 编译（[build.js](build.js)）。
+- `pnpm dev`：tsc watch；`pnpm dev:cli`：构建后直接跑本地 CLI。
+- `pnpm lint`：ESLint 检查 `src/`。
+- 命令实现全部按需 `import()` 懒加载（见 [cli/index.ts](src/cli/index.ts)），`--version`、`--help` 不加载其他命令的实现，启动零开销。

package/bin/freespec.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runCli } from '../dist/cli/index.js';
+
+runCli();

package/dist/cli/index.d.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+declare const program: Command;
+/**
+ * Get the full command path for nested commands.
+ * For example: 'change show' -> 'change:show'
+ */
+export declare function getCommandPath(command: Command): string;
+/**
+ * True when the executing command asked for JSON output — used to suppress the
+ * first-run telemetry notice so stdout stays a single valid JSON document.
+ *
+ * `--json` reaches commands three ways, so a single parsed option is not enough:
+ * - declared on the leaf (`freespec status --json`) → `opts().json`
+ * - declared on a parent group and read via globals (`freespec workset --json list`)
+ *   → `optsWithGlobals().json`
+ * - a residual arg on a permissive group that never declares the option
+ *   (`freespec store --json`, which detects it from `command.args`) → `args`
+ *
+ * Suppressing is always safe: the disclosure is only deferred to the next
+ * non-JSON run, never lost, whereas printing it on a JSON run corrupts stdout.
+ */
+export declare function isJsonRun(command: Command): boolean;
+export { program };
+export declare function runCli(argv?: string[]): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,359 @@
+import { Command, Option } from 'commander';
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync, promises as fs } from 'fs';
+import { AI_TOOLS, TOOL_ID_ALIASES } from '../core/config.js';
+import { DEFAULT_SCHEMA } from '../commands/workflow/default-schema.js';
+// Startup cost: every command's implementation, and the packages it uses,
+// loads with `await import()` inside its action. This module and
+// ./commands/ only define commands (names, options, help), so `--version`,
+// `--help`, and each command load no other command's implementation.
+async function failWithError(error, json) {
+    // The agent contract: every --json failure leaves exactly one JSON
+    // document on stdout (the command's null-shape plus a status array).
+    if (json?.enabled) {
+        const { asStatus } = await import('../commands/shared-output.js');
+        console.log(JSON.stringify({ ...(json.payload ?? {}), status: [asStatus(error, json.fallbackCode ?? 'command_error')] }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const { default: ora } = await import('ora');
+    ora().fail(`Error: ${error.message}`);
+    // Resolution and store errors carry a pasteable fix - never drop it.
+    const fix = error.diagnostic?.fix;
+    if (fix) {
+        console.error(`Fix: ${fix}`);
+    }
+    process.exitCode = process.exitCode ?? 1;
+}
+const program = new Command();
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+/**
+ * Get the full command path for nested commands.
+ * For example: 'change show' -> 'change:show'
+ */
+export function getCommandPath(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        // Skip the root 'freespec' command
+        if (name && name !== 'freespec') {
+            names.unshift(name);
+        }
+        current = current.parent;
+    }
+    return names.join(':') || 'freespec';
+}
+/**
+ * True when the executing command asked for JSON output — used to suppress the
+ * first-run telemetry notice so stdout stays a single valid JSON document.
+ *
+ * `--json` reaches commands three ways, so a single parsed option is not enough:
+ * - declared on the leaf (`freespec status --json`) → `opts().json`
+ * - declared on a parent group and read via globals (`freespec workset --json list`)
+ *   → `optsWithGlobals().json`
+ * - a residual arg on a permissive group that never declares the option
+ *   (`freespec store --json`, which detects it from `command.args`) → `args`
+ *
+ * Suppressing is always safe: the disclosure is only deferred to the next
+ * non-JSON run, never lost, whereas printing it on a JSON run corrupts stdout.
+ */
+export function isJsonRun(command) {
+    return (command.optsWithGlobals().json === true ||
+        command.args.includes('--json'));
+}
+program
+    .name('freespec')
+    .description('AI-native system for spec-driven development')
+    .version(version);
+// Global options
+program.option('--no-color', 'Disable color output');
+// Apply global flags and telemetry before any command runs
+// Note: preAction receives (thisCommand, actionCommand) where:
+// - thisCommand: the command where hook was added (root program)
+// - actionCommand: the command actually being executed (subcommand)
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.color === false) {
+        process.env.NO_COLOR = '1';
+    }
+    // Show first-run telemetry notice (if not seen). It's written to stderr, so it
+    // never pollutes stdout — but --json runs still defer it (see isJsonRun) so the
+    // very first invocation stays free of any incidental output on either stream.
+    const { maybeShowTelemetryNotice, trackCommand } = await import('../telemetry/index.js');
+    await maybeShowTelemetryNotice({ silent: isJsonRun(actionCommand) });
+    // Track command execution (use actionCommand to get the actual subcommand)
+    const commandPath = getCommandPath(actionCommand);
+    await trackCommand(commandPath, version);
+});
+// Shutdown telemetry after command completes
+program.hook('postAction', async (_thisCommand, actionCommand) => {
+    const { shutdown } = await import('../telemetry/index.js');
+    await shutdown();
+});
+const availableToolIds = AI_TOOLS
+    .filter((tool) => tool.skillsDir || tool.globalSkillsDir)
+    .map((tool) => tool.value);
+const toolAliasNote = Object.entries(TOOL_ID_ALIASES)
+    .map(([retired, current]) => `${retired} (now ${current})`)
+    .join(', ');
+const toolsOptionDescription = `Configure AI tools non-interactively. Use "all", "none", or a comma-separated list of: ${availableToolIds.join(', ')}. Also accepted: ${toolAliasNote}`;
+program
+    .command('init [path]')
+    .description('Initialize FreeSpec in your project')
+    .option('--tools <tools>', toolsOptionDescription)
+    .option('--language <language>', 'Write new FreeSpec artifacts in this language')
+    .option('--force', 'Auto-cleanup legacy files without prompting')
+    .option('--profile <profile>', 'Override global config profile (core or custom)')
+    .option('--no-animation', 'Show a static welcome screen instead of the animated one')
+    .action(async (targetPath = '.', options) => {
+    try {
+        // Validate that the path is a valid directory
+        const resolvedPath = path.resolve(targetPath);
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`Path "${targetPath}" is not a directory`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Directory doesn't exist, but we can create it
+                console.log(`Directory "${targetPath}" doesn't exist, it will be created.`);
+            }
+            else if (error.message && error.message.includes('not a directory')) {
+                throw error;
+            }
+            else {
+                throw new Error(`Cannot access path "${targetPath}": ${error.message}`);
+            }
+        }
+        const { InitCommand } = await import('../core/init.js');
+        const initCommand = new InitCommand({
+            tools: options?.tools,
+            language: options?.language,
+            force: options?.force,
+            profile: options?.profile,
+            animation: options?.animation,
+        });
+        await initCommand.execute(targetPath);
+    }
+    catch (error) {
+        await failWithError(error);
+        process.exit(1);
+    }
+});
+program
+    .command('update [path]')
+    .description('Update FreeSpec instruction files')
+    .option('--force', 'Force update even when tools are up to date')
+    .option('--dry-run', 'Report what the update would change without writing anything')
+    .option('--json', 'With --dry-run, print the planned changes as JSON')
+    .action(async (targetPath = '.', options) => {
+    try {
+        if (options?.json && !options?.dryRun) {
+            console.error('--json is only available with --dry-run.');
+            process.exitCode = 1;
+            return;
+        }
+        // A dry run reports the plan and nothing else: no network check, no
+        // upgrade prompt, no output that would break --json.
+        if (options?.dryRun) {
+            const [{ UpdateCommand }, { formatUpdatePlan }] = await Promise.all([
+                import('../core/update.js'),
+                import('../core/update-plan.js'),
+            ]);
+            const plan = await new UpdateCommand({
+                force: options?.force,
+                dryRun: true,
+            }).plan(targetPath);
+            console.log(options?.json ? JSON.stringify(plan, null, 2) : formatUpdatePlan(plan));
+            return;
+        }
+        const [{ getInstallDir, isSourceCheckout, getAvailableCliUpdate, shouldOfferUpgrade, displayCliUpdateNote, offerCliUpgrade, rerunUpdateWithUpgradedCli, displayUpgradeCommand, }, { isInteractive }, { UpdateCommand },] = await Promise.all([
+            import('../core/version-check.js'),
+            import('../utils/interactive.js'),
+            import('../core/update.js'),
+        ]);
+        const installDir = getInstallDir();
+        // Running from a clone: the version is whatever the branch says, so any
+        // upgrade advice would be noise. Decided before the request, so a
+        // contributor never waits on an answer that gets thrown away.
+        const latestVersion = isSourceCheckout(installDir) ? null : await getAvailableCliUpdate();
+        const announce = latestVersion !== null;
+        // Offer to upgrade first: this process generates files from its own
+        // templates, so upgrading afterwards would leave the old ones on disk.
+        // Both streams must be a terminal — with stdout redirected the question
+        // lands in the file and the user waits at a blank screen forever.
+        const canOffer = announce &&
+            shouldOfferUpgrade({
+                installDir,
+                projectPath: targetPath,
+                interactive: isInteractive(),
+                stdoutIsTty: Boolean(process.stdout.isTTY),
+            });
+        let declined = false;
+        if (latestVersion && canOffer) {
+            displayCliUpdateNote(latestVersion, targetPath, { withCommand: false });
+            const outcome = await offerCliUpgrade(latestVersion);
+            // Set the code and return rather than process.exit: exiting here would
+            // skip commander's postAction hook, killing the telemetry flush
+            // mid-request.
+            if (outcome === 'cancelled') {
+                // Ctrl-C means stop the command, not fall through to more prompts.
+                process.exitCode = 130;
+                return;
+            }
+            if (outcome === 'upgraded') {
+                process.exitCode = await rerunUpdateWithUpgradedCli(targetPath, {
+                    force: options?.force,
+                });
+                return;
+            }
+            // Declined, failed, or upgraded-but-unreachable: fall through to the
+            // update, then leave the command on screen underneath it.
+            declined = true;
+        }
+        const updateCommand = new UpdateCommand({ force: options?.force });
+        await updateCommand.execute(targetPath);
+        if (declined) {
+            // The headline was printed before the prompt; only the manual route is
+            // still owed, and it belongs where the user is looking now.
+            displayUpgradeCommand(targetPath);
+        }
+        else if (latestVersion) {
+            displayCliUpdateNote(latestVersion, targetPath);
+        }
+    }
+    catch (error) {
+        // The --json dry run follows the agent contract: exactly one JSON
+        // document on stdout, even on failure.
+        // failWithError sets the exit code. Returning instead of process.exit()
+        // lets piped stdout drain - an exit can cut the JSON document short where
+        // pipes are asynchronous (macOS, Windows) - and keeps commander's
+        // postAction telemetry flush, as the upgrade paths above already do.
+        await failWithError(error, {
+            enabled: options?.dryRun && options?.json,
+            payload: { changes: [], notes: [], failures: [] },
+            fallbackCode: 'update_error',
+        });
+    }
+});
+program
+    .command('list')
+    .description('List change directories under freespec/')
+    .option('--sort <order>', 'Sort order: "recent" (default) or "name"', 'recent')
+    .option('--json', 'Output as JSON (for programmatic use)')
+    .action(async (options) => {
+    try {
+        const [{ resolveRootForCommand, toRootOutput }, { ListCommand }] = await Promise.all([
+            import('../core/root-selection.js'),
+            import('../core/list.js'),
+        ]);
+        const root = await resolveRootForCommand(options ?? {}, {
+            json: options?.json,
+            failurePayload: { changes: [], root: null },
+            allowImplicitRoot: existsSync(path.join(process.cwd(), 'freespec', 'project.md')),
+        });
+        if (!root) {
+            return;
+        }
+        const listCommand = new ListCommand();
+        const sort = options?.sort === 'name' ? 'name' : 'recent';
+        await listCommand.execute(root.path, {
+            sort,
+            json: options?.json,
+            ...(options?.json ? { root: toRootOutput(root) } : {}),
+        });
+    }
+    catch (error) {
+        await failWithError(error, {
+            enabled: options?.json,
+            payload: { changes: [], root: null },
+            fallbackCode: 'list_error',
+        });
+        process.exit(1);
+    }
+});
+// Status command
+program
+    .command('status')
+    .description('Display artifact completion status for a change')
+    .option('--change <id>', 'Change name to show status for')
+    .option('--all', 'Show status for all active changes')
+    .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { statusCommand } = await import('../commands/workflow/status.js');
+        await statusCommand(options);
+    }
+    catch (error) {
+        await failWithError(error, {
+            enabled: options.json,
+            // The batch null-shape; the single-change failure shape is
+            // pre-existing contract and stays payload-free.
+            payload: options.all
+                ? (await import('../commands/workflow/status.js')).BATCH_STATUS_FAILURE_PAYLOAD
+                : undefined,
+            fallbackCode: 'change_error',
+        });
+        process.exit(1);
+    }
+});
+// Instructions command
+program
+    .command('instructions [artifact]')
+    .description('Output enriched instructions for an artifact or for apply')
+    .option('--change <id>', 'Change name')
+    .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+    .option('--json', 'Output as JSON')
+    .action(async (artifactId, options) => {
+    try {
+        const { applyInstructionsCommand, instructionsCommand } = await import('../commands/workflow/instructions.js');
+        if (artifactId === 'apply') {
+            await applyInstructionsCommand(options);
+        }
+        else {
+            await instructionsCommand(artifactId, options);
+        }
+    }
+    catch (error) {
+        await failWithError(error, { enabled: options.json, fallbackCode: 'change_error' });
+        process.exit(1);
+    }
+});
+// New command group with change subcommand
+const newCmd = program.command('new').description('Create new items');
+newCmd
+    .command('change <name>')
+    .description('Create a new change directory')
+    .option('--description <text>', 'Description to add to README.md')
+    .option('--goal <text>', 'Optional goal metadata to store with the change')
+    .option('--schema <name>', `Workflow schema to use (default: ${DEFAULT_SCHEMA})`)
+    .option('--json', 'Output as JSON')
+    // Removed options kept registered (hidden) so users get a deliberate
+    // explanation instead of a generic unknown-option error.
+    .addOption(new Option('--initiative <id>', 'No longer supported').hideHelp())
+    .addOption(new Option('--areas <names>', 'No longer supported').hideHelp())
+    .action(async (name, options) => {
+    try {
+        const { newChangeCommand } = await import('../commands/workflow/new-change.js');
+        await newChangeCommand(name, options);
+    }
+    catch (error) {
+        await failWithError(error);
+        process.exit(1);
+    }
+});
+export { program };
+export function runCli(argv = process.argv) {
+    program.parse(argv);
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    runCli();
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/shared-output.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared JSON/failure output plumbing for command groups whose errors
+ * carry the StoreDiagnostic envelope. One definition of the failure
+ * contract: exit code 1, Error:/Fix: lines in human mode, a status
+ * array in JSON mode.
+ */
+import { type StoreDiagnostic } from '../core/store/errors.js';
+export declare function printJson(payload: unknown): void;
+export declare function asErrorMessage(error: unknown): string;
+/**
+ * @inquirer prompts reject with ExitPromptError on Ctrl-C; commands
+ * translate that to `Cancelled.` + exit 130 (third caller extracted
+ * this here in slice 7.1).
+ */
+export declare function isPromptCancellationError(error: unknown): boolean;
+export declare function asStatus(error: unknown, fallbackCode: string): StoreDiagnostic;
+export declare function emitFailure(json: boolean | undefined, payload: Record<string, unknown>, error: unknown, fallbackCode: string): void;
+//# sourceMappingURL=shared-output.d.ts.map

package/dist/commands/shared-output.js

@@ -0,0 +1,61 @@
+/**
+ * Shared JSON/failure output plumbing for command groups whose errors
+ * carry the StoreDiagnostic envelope. One definition of the failure
+ * contract: exit code 1, Error:/Fix: lines in human mode, a status
+ * array in JSON mode.
+ */
+import { StoreError } from '../core/store/errors.js';
+export function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+export function asErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * @inquirer prompts reject with ExitPromptError on Ctrl-C; commands
+ * translate that to `Cancelled.` + exit 130 (third caller extracted
+ * this here in slice 7.1).
+ */
+export function isPromptCancellationError(error) {
+    return (error instanceof Error &&
+        (error.name === 'ExitPromptError' ||
+            error.message.includes('force closed the prompt with SIGINT')));
+}
+export function asStatus(error, fallbackCode) {
+    if (error instanceof StoreError) {
+        return error.diagnostic;
+    }
+    // RootSelectionError (and siblings) carry the same envelope without
+    // sharing a class hierarchy; duck-type the diagnostic once, here.
+    const diagnostic = error.diagnostic;
+    if (diagnostic && typeof diagnostic.code === 'string') {
+        return diagnostic;
+    }
+    return {
+        severity: 'error',
+        code: fallbackCode,
+        message: asErrorMessage(error),
+    };
+}
+export function emitFailure(json, payload, error, fallbackCode) {
+    // Ctrl-C in a prompt is the user's choice, not an error: every
+    // command group gets the Cancelled./130 convention through here.
+    if (!json && isPromptCancellationError(error)) {
+        console.error('Cancelled.');
+        process.exitCode = 130;
+        return;
+    }
+    const status = asStatus(error, fallbackCode);
+    if (json) {
+        const prior = Array.isArray(payload.status) ? payload.status : [];
+        printJson({ ...payload, status: [...prior, status] });
+        process.exitCode = 1;
+        return;
+    }
+    console.error(`Error: ${status.message}`);
+    if (status.fix) {
+        console.error(`Fix: ${status.fix}`);
+    }
+    process.exitCode = 1;
+}
+//# sourceMappingURL=shared-output.js.map

package/dist/commands/workflow/default-schema.d.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_SCHEMA } from '../../core/change-layout.js';
+//# sourceMappingURL=default-schema.d.ts.map

package/dist/commands/workflow/default-schema.js

@@ -0,0 +1,4 @@
+// Its own module so the CLI's command definitions can show it in help text
+// without loading the workflow implementation.
+export { DEFAULT_SCHEMA } from '../../core/change-layout.js';
+//# sourceMappingURL=default-schema.js.map

package/dist/commands/workflow/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Workflow CLI Commands
+ *
+ * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
+ */
+export { statusCommand, BATCH_STATUS_FAILURE_PAYLOAD } from './status.js';
+export type { StatusOptions } from './status.js';
+export { instructionsCommand, applyInstructionsCommand, } from './instructions.js';
+export type { InstructionsOptions } from './instructions.js';
+export { newChangeCommand } from './new-change.js';
+export type { NewChangeOptions } from './new-change.js';
+export { DEFAULT_SCHEMA } from './shared.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.js

@@ -0,0 +1,10 @@
+/**
+ * Workflow CLI Commands
+ *
+ * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
+ */
+export { statusCommand, BATCH_STATUS_FAILURE_PAYLOAD } from './status.js';
+export { instructionsCommand, applyInstructionsCommand, } from './instructions.js';
+export { newChangeCommand } from './new-change.js';
+export { DEFAULT_SCHEMA } from './shared.js';
+//# sourceMappingURL=index.js.map

package/dist/commands/workflow/instructions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Instructions Command
+ *
+ * Generates enriched instructions for creating artifacts or applying tasks.
+ * Includes both artifact instructions and apply instructions.
+ */
+import { type ArtifactInstructions } from '../../core/artifact-graph/index.js';
+import { type PlanningHome } from '../../core/planning-home.js';
+import { type ProjectConfig } from '../../core/project-config.js';
+import { type ApplyInstructions } from './shared.js';
+export interface InstructionsOptions {
+    change?: string;
+    schema?: string;
+    store?: string;
+    storePath?: string;
+    json?: boolean;
+}
+export interface ApplyInstructionsOptions {
+    change?: string;
+    schema?: string;
+    store?: string;
+    storePath?: string;
+    json?: boolean;
+}
+export declare function instructionsCommand(artifactId: string | undefined, options: InstructionsOptions): Promise<void>;
+export declare function printInstructionsText(instructions: ArtifactInstructions, isBlocked: boolean): void;
+export interface GenerateApplyInstructionsOptions {
+    planningHome?: PlanningHome;
+    projectConfig?: ProjectConfig | null;
+}
+/**
+ * Generates apply instructions for implementing tasks from a change.
+ * Schema-aware: reads apply phase configuration from schema to determine
+ * required artifacts, tracking file, and instruction.
+ */
+export declare function generateApplyInstructions(projectRoot: string, changeName: string, schemaName?: string, options?: GenerateApplyInstructionsOptions): Promise<ApplyInstructions>;
+export declare function applyInstructionsCommand(options: ApplyInstructionsOptions): Promise<void>;
+export declare function printApplyInstructionsText(instructions: ApplyInstructions): void;
+//# sourceMappingURL=instructions.d.ts.map