freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/src/shim/instructions.js

@@ -0,0 +1,460 @@
+// `openspec instructions <artifact> --change <id> [--json]` over the vendored
+// engine, plus the two special targets the /opsx skills use: `apply` and
+// `archive`.
+//
+// Reconstructed from src/commands/workflow/instructions.ts, minus store /
+// root-selection, the referenced-store index, and project-config-driven
+// context/rules/operation-inputs. Artifact instructions are faithful; `apply`
+// reimplements the schema-aware apply state machine (blocked / all_done / ready)
+// against the change's tracked-tasks file; `archive` returns the archive-inputs brief:
+// the project context and the operation guidance from `openspec/config.yaml`
+// (`operations.archive.guidance`, the upstream shape) merged with the schema's own
+// `archive.guidance` list (the FreeHarness spec-driven override carries the compound step).
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { loadChangeContext, generateInstructions, resolveSchema, resolveSchemaForChange, getSchemaDir, resolveArtifactOutputPath, resolveArtifactOutputs, parseTaskLines, METADATA_FILENAME, } from '../../vendor/openspec/engine/index.js';
+import { planningHomeStub, printJson, validateChangeExists, validateSchemaExists } from './shared.js';
+const SPECIAL_TARGETS = new Set(['apply', 'archive']);
+export function instructionsHandler(projectRoot, artifactId, options) {
+    const changeName = validateChangeExists(options.change, projectRoot);
+    if (options.schema) {
+        validateSchemaExists(options.schema, projectRoot);
+    }
+    if (artifactId === 'apply') {
+        return applyInstructions(projectRoot, changeName, options);
+    }
+    if (artifactId === 'archive') {
+        return archiveInstructions(projectRoot, changeName, options);
+    }
+    const context = loadChangeContext(projectRoot, changeName, options.schema);
+    if (!artifactId) {
+        const validIds = context.graph.getAllArtifacts().map((a) => a.id);
+        throw new Error(`Missing required argument <artifact>. Valid artifacts:\n  ${validIds.join('\n  ')}\n  apply\n  archive`);
+    }
+    const artifact = context.graph.getArtifact(artifactId);
+    if (!artifact) {
+        const validIds = context.graph.getAllArtifacts().map((a) => a.id);
+        throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'. Valid artifacts:\n  ${validIds.join('\n  ')}`);
+    }
+    const instructions = generateInstructions(context, artifactId);
+    const isBlocked = instructions.dependencies.some((d) => !d.done);
+    if (options.json) {
+        printJson({ ...instructions, planningHome: planningHomeStub(projectRoot) });
+        return 0;
+    }
+    printInstructionsText(instructions, isBlocked);
+    return 0;
+}
+export function printInstructionsText(instructions, isBlocked) {
+    const { artifactId, changeName, schemaName, changeDir, resolvedOutputPath, description, instruction, template, dependencies, unlocks, } = instructions;
+    console.log(`<artifact id="${artifactId}" change="${changeName}" schema="${schemaName}">`);
+    console.log();
+    if (instructions.skipped) {
+        console.log('<warning>');
+        console.log(instructions.warning ?? 'This artifact is skipped (skip_specs is set in .openspec.yaml).');
+        console.log('</warning>');
+        console.log();
+        console.log('</artifact>');
+        return;
+    }
+    if (isBlocked) {
+        const missing = dependencies.filter((d) => !d.done).map((d) => d.id);
+        console.log('<warning>');
+        console.log('This artifact has unmet dependencies. Complete them first or proceed with caution.');
+        console.log(`Missing: ${missing.join(', ')}`);
+        console.log('</warning>');
+        console.log();
+    }
+    console.log('<task>');
+    console.log(`Create the ${artifactId} artifact for change "${changeName}".`);
+    console.log(description);
+    console.log('</task>');
+    console.log();
+    if (dependencies.length > 0) {
+        console.log('<dependencies>');
+        console.log('Read the current contents of these files before creating this artifact (re-read them from disk even if you saw them earlier - they may have been edited):');
+        console.log();
+        for (const dep of dependencies) {
+            if (dep.skipped) {
+                console.log(`<dependency id="${dep.id}" status="skipped">`);
+                console.log('  <description>Skipped: the change declares skip_specs, so this artifact has no files to read.</description>');
+                console.log('</dependency>');
+                continue;
+            }
+            const status = dep.done ? 'done' : 'missing';
+            const fullPath = path.join(changeDir, dep.path);
+            console.log(`<dependency id="${dep.id}" status="${status}">`);
+            console.log(`  <path>${fullPath}</path>`);
+            console.log(`  <description>${dep.description}</description>`);
+            console.log('</dependency>');
+        }
+        console.log('</dependencies>');
+        console.log();
+    }
+    console.log('<output>');
+    console.log(`Write to: ${resolvedOutputPath}`);
+    console.log('</output>');
+    console.log();
+    if (instruction) {
+        console.log('<instruction>');
+        console.log(instruction.trim());
+        console.log('</instruction>');
+        console.log();
+    }
+    console.log('<template>');
+    console.log('<!-- Use this as the structure for your output file. Fill in the sections. -->');
+    console.log(template.trim());
+    console.log('</template>');
+    console.log();
+    if (unlocks.length > 0) {
+        console.log('<unlocks>');
+        console.log(`Completing this artifact enables: ${unlocks.join(', ')}`);
+        console.log('</unlocks>');
+        console.log();
+    }
+    console.log('</artifact>');
+}
+function toTaskItems(parsed) {
+    const tasks = [];
+    for (const task of parsed) {
+        if (task.description.length === 0)
+            continue;
+        tasks.push({ id: `${tasks.length + 1}`, description: task.description, done: task.done });
+    }
+    return tasks;
+}
+const SPECS_PATH_PREFIX = 'specs/';
+/** Whether an artifact's `generates` path lands inside the specs/ tree. */
+function isSpecsArtifactPath(generates) {
+    return generates.replace(/^(?:\.\/)+/, '').startsWith(SPECS_PATH_PREFIX);
+}
+/**
+ * Every artifact still to build before apply's own gate is satisfied, in the
+ * schema's declared build order - the transitive closure of `apply.requires`.
+ *
+ * Apply blocks on the first artifact in `requiredArtifactIds` that is not yet
+ * complete, so naming only that one hides the rest of the chain: a change
+ * holding only a proposal, whose schema chains specs -> design -> tasks,
+ * would be told only "Missing artifacts: tasks" - an instruction that, taken
+ * literally, skips every artifact tasks itself depends on.
+ */
+/**
+ * Every artifact still to build (`missing`), plus a warning for any id in the
+ * `requires` chain that names no artifact in the schema. An unknown id used to
+ * be dropped by the `if (!artifact) continue` below with no trace anywhere in
+ * the instructions payload - a typo in a schema's `requires` list read as an
+ * empty, satisfied dependency instead of the configuration error it is.
+ */
+function collectMissingPrerequisites(requiredArtifactIds, schema, buildOrder, completed) {
+    const byId = new Map(schema.artifacts.map((artifact) => [artifact.id, artifact]));
+    const missing = new Set();
+    const unknownIds = [];
+    const queue = [...requiredArtifactIds];
+    const seen = new Set(queue);
+    while (queue.length > 0) {
+        const id = queue.shift();
+        const artifact = byId.get(id);
+        if (!artifact) {
+            unknownIds.push(id);
+            continue;
+        }
+        if (!completed.has(id))
+            missing.add(id);
+        for (const dependency of artifact.requires) {
+            if (seen.has(dependency))
+                continue;
+            seen.add(dependency);
+            queue.push(dependency);
+        }
+    }
+    const order = new Map(buildOrder.map((id, index) => [id, index]));
+    // An id absent from `order` (the build order the schema graph produced) is
+    // itself a schema defect, not a "comes first" signal - sorting it to the
+    // front (the old `?? 0`) silently promoted a broken reference ahead of every
+    // real artifact. Pushing it to the end keeps real artifacts in their proper
+    // order and leaves the broken one visibly last.
+    const missingSorted = [...missing].sort((a, b) => (order.get(a) ?? Number.MAX_SAFE_INTEGER) - (order.get(b) ?? Number.MAX_SAFE_INTEGER));
+    const warnings = unknownIds.length > 0
+        ? [`Schema declares a dependency on an artifact id not defined in this schema: ${unknownIds.join(', ')}.`]
+        : [];
+    return { missing: missingSorted, warnings };
+}
+/**
+ * Non-blocking problems with an otherwise-ready-or-complete change.
+ *
+ * Apply gates on the schema's `apply.requires` alone, so a change whose tasks
+ * file was written ahead of its specs reads as ready even though it has no
+ * delta spec at all - the exact state `openspec validate` rejects. Naming the
+ * gap here, instead of blocking on it, is what keeps apply from being the one
+ * surface that green-lights implementation ahead of every other check.
+ *
+ * Fires only once apply's own gate is satisfied: for a change still missing a
+ * required artifact, the absent specs are the next step, not a warning. A
+ * schema with no spec-producing artifact, or a change carrying `skip_specs`,
+ * never triggers it.
+ */
+function collectApplyWarnings(state, schema, changeDir, changeName, skippedArtifacts) {
+    if (state === 'blocked')
+        return [];
+    const specArtifacts = schema.artifacts.filter((artifact) => isSpecsArtifactPath(artifact.generates));
+    if (specArtifacts.length === 0)
+        return [];
+    if (specArtifacts.some((artifact) => skippedArtifacts?.has(artifact.id)))
+        return [];
+    const hasDeltas = specArtifacts.some((artifact) => resolveArtifactOutputs(changeDir, artifact.generates).length > 0);
+    if (hasDeltas)
+        return [];
+    const metadataPath = path.join(changeDir, METADATA_FILENAME);
+    // Names the artifact this schema actually declares rather than the literal
+    // "specs": a schema whose spec-producing artifact is, say, "contracts" would
+    // otherwise be told to run a command naming an artifact it does not have.
+    // With more than one such artifact there is no single right answer, so the
+    // id becomes a placeholder instead of a guess.
+    const specTarget = specArtifacts.length === 1 ? specArtifacts[0].id : '<artifact-id>';
+    return [
+        `This change has no delta specs and does not declare \`skip_specs: true\`, so \`openspec validate ${changeName}\` fails on it. ` +
+            `Write the delta specs before implementing (\`openspec instructions ${specTarget} --change ${changeName}\`), ` +
+            `or add \`skip_specs: true\` to ${metadataPath} if this change really changes no specified behavior.`,
+    ];
+}
+function buildApplyInstructions(projectRoot, changeName, schemaName) {
+    const context = loadChangeContext(projectRoot, changeName, schemaName);
+    const changeDir = context.changeDir;
+    const schema = resolveSchema(context.schemaName, projectRoot);
+    const applyConfig = schema.apply;
+    const requiredArtifactIds = applyConfig?.requires ?? schema.artifacts.map((a) => a.id);
+    const tracksFile = applyConfig?.tracks ?? null;
+    const schemaInstruction = applyConfig?.instruction ?? null;
+    const missingArtifacts = [];
+    for (const artifactId of requiredArtifactIds) {
+        if (context.skippedArtifacts?.has(artifactId))
+            continue;
+        const artifact = schema.artifacts.find((a) => a.id === artifactId);
+        if (artifact && resolveArtifactOutputs(changeDir, artifact.generates).length === 0) {
+            missingArtifacts.push(artifactId);
+        }
+    }
+    const contextFiles = {};
+    for (const artifact of schema.artifacts) {
+        const outputs = resolveArtifactOutputs(changeDir, artifact.generates);
+        if (outputs.length > 0)
+            contextFiles[artifact.id] = outputs;
+    }
+    let parsedTasks = [];
+    let tracksFileExists = false;
+    if (tracksFile) {
+        const tracksPath = resolveArtifactOutputPath(changeDir, tracksFile);
+        tracksFileExists = fs.existsSync(tracksPath);
+        if (tracksFileExists) {
+            parsedTasks = parseTaskLines(fs.readFileSync(tracksPath, 'utf-8'));
+        }
+    }
+    const tasks = toTaskItems(parsedTasks);
+    const total = parsedTasks.length;
+    const complete = parsedTasks.filter((t) => t.done).length;
+    const remaining = total - complete;
+    let state;
+    let instruction;
+    if (missingArtifacts.length > 0) {
+        state = 'blocked';
+        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the openspec-continue-change skill to create the missing artifacts first.`;
+    }
+    else if (tracksFile && !tracksFileExists) {
+        state = 'blocked';
+        instruction = `The ${path.basename(tracksFile)} file is missing and must be created.\nUse openspec-continue-change to generate the tracking file.`;
+    }
+    else if (tracksFile && tracksFileExists && tasks.length === 0) {
+        state = 'blocked';
+        instruction = `The ${path.basename(tracksFile)} file exists but contains no tasks to work on.\nAdd tasks or regenerate it with openspec-continue-change.`;
+    }
+    else if (tracksFile && remaining === 0 && total > 0) {
+        state = 'all_done';
+        instruction = 'All tasks are complete! This change is ready to be archived.';
+    }
+    else if (!tracksFile) {
+        state = 'ready';
+        instruction = schemaInstruction?.trim() ?? 'All required artifacts complete. Proceed with implementation.';
+    }
+    else {
+        state = 'ready';
+        instruction =
+            schemaInstruction?.trim() ??
+                'Read context files, work through pending tasks, mark complete as you go.\nPause if you hit blockers or need clarification.';
+    }
+    // Computed regardless of state: a "ready" change (apply.requires satisfied)
+    // can still be missing the artifacts its own required artifact transitively
+    // depends on - the schema's own gate does not require them, so this is the
+    // only place that names the rest of the chain.
+    const { missing: missingPrerequisites, warnings: unknownIdWarnings } = collectMissingPrerequisites(requiredArtifactIds, schema, context.graph.getBuildOrder(), context.completed);
+    const warnings = [
+        ...unknownIdWarnings,
+        ...collectApplyWarnings(state, schema, changeDir, changeName, context.skippedArtifacts),
+    ];
+    return {
+        changeName,
+        changeDir,
+        schemaName: context.schemaName,
+        contextFiles,
+        progress: { total, complete, remaining },
+        tasks,
+        state,
+        ...(missingArtifacts.length > 0 ? { missingArtifacts } : {}),
+        ...(missingPrerequisites.length > 0 ? { missingPrerequisites } : {}),
+        ...(warnings.length > 0 ? { warnings } : {}),
+        instruction,
+    };
+}
+/**
+ * Whether the "Not created yet, in build order" line would repeat information
+ * the "Missing artifacts" line already gave in full.
+ *
+ * Compared as sets, not lengths: two equal-length lists naming different ids
+ * (e.g. a schema whose transitive chain swaps one artifact for another at the
+ * same depth) are NOT the same information, and a length-only compare (the
+ * prior `missingPrerequisites.length <= missingArtifacts.length`) would
+ * silently drop the second list even though it names something new.
+ * Exported for direct unit coverage of the comparison rule.
+ */
+export function isChainAlreadyNamed(state, missingArtifacts, missingPrerequisites) {
+    if (state !== 'blocked' || missingArtifacts === undefined)
+        return false;
+    const missingArtifactsSet = new Set(missingArtifacts);
+    return (missingPrerequisites ?? []).every((id) => missingArtifactsSet.has(id));
+}
+function applyInstructions(projectRoot, changeName, options) {
+    const instructions = buildApplyInstructions(projectRoot, changeName, options.schema);
+    if (options.json) {
+        printJson({ ...instructions, planningHome: planningHomeStub(projectRoot) });
+        return 0;
+    }
+    console.log(`## Apply: ${instructions.changeName}`);
+    console.log(`Schema: ${instructions.schemaName}`);
+    console.log();
+    if (instructions.state === 'blocked' && instructions.missingArtifacts) {
+        console.log('### Blocked');
+        console.log(`Missing artifacts: ${instructions.missingArtifacts.join(', ')}`);
+        console.log();
+    }
+    // Named once: when blocked and the chain says nothing past `missingArtifacts`,
+    // the line above already names it in full.
+    const chainAlreadyNamed = isChainAlreadyNamed(instructions.state, instructions.missingArtifacts, instructions.missingPrerequisites);
+    if (instructions.missingPrerequisites && instructions.missingPrerequisites.length > 0 && !chainAlreadyNamed) {
+        console.log(`Not created yet, in build order: ${instructions.missingPrerequisites.join(', ')}`);
+        console.log();
+    }
+    if (instructions.warnings && instructions.warnings.length > 0) {
+        console.log('### Warnings');
+        for (const warning of instructions.warnings) {
+            console.log(`- ${warning}`);
+        }
+        console.log();
+    }
+    const contextEntries = Object.entries(instructions.contextFiles);
+    if (contextEntries.length > 0) {
+        console.log('### Context Files');
+        for (const [id, files] of contextEntries) {
+            for (const file of files)
+                console.log(`- ${id}: ${file}`);
+        }
+        console.log();
+    }
+    if (instructions.progress.total > 0 || instructions.tasks.length > 0) {
+        console.log('### Progress');
+        console.log(`${instructions.progress.complete}/${instructions.progress.total} complete`);
+        console.log();
+    }
+    if (instructions.tasks.length > 0) {
+        console.log('### Tasks');
+        for (const task of instructions.tasks) {
+            console.log(`- ${task.done ? '[x]' : '[ ]'} ${task.description}`);
+        }
+        console.log();
+    }
+    console.log('### Instruction');
+    console.log(instructions.instruction);
+    return 0;
+}
+/**
+ * Reads a string list at `keys` inside a parsed YAML document; non-lists yield [].
+ * @param doc Parsed document.
+ * @param keys Path of keys.
+ * @returns The strings found.
+ */
+function stringList(doc, keys) {
+    let cur = doc;
+    for (const k of keys) {
+        if (!cur || typeof cur !== 'object' || Array.isArray(cur))
+            return [];
+        cur = cur[k];
+    }
+    return Array.isArray(cur) ? cur.filter((x) => typeof x === 'string' && x.trim().length > 0) : [];
+}
+/**
+ * Parses a YAML file when present; a missing or malformed file yields undefined.
+ * @param file Path.
+ * @returns Parsed document.
+ */
+function readYamlIfPresent(file) {
+    if (!fs.existsSync(file))
+        return undefined;
+    try {
+        return parseYaml(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Builds the archive inputs: project context (`openspec/config.yaml` `context`), the
+ * project's `operations.archive.guidance`, then the schema's `archive.guidance`.
+ * @param projectRoot Project root.
+ * @param changeName Change id.
+ * @param explicitSchema `--schema` override.
+ * @returns The brief the archive skill prints.
+ */
+export function buildArchiveInstructions(projectRoot, changeName, explicitSchema) {
+    const config = readYamlIfPresent(path.join(projectRoot, 'openspec', 'config.yaml'));
+    const contextRaw = config && typeof config === 'object' ? config.context : undefined;
+    const context = typeof contextRaw === 'string' && contextRaw.trim().length > 0 ? contextRaw : undefined;
+    const guidance = stringList(config, ['operations', 'archive', 'guidance']);
+    const changeDir = path.join(projectRoot, 'openspec', 'changes', changeName);
+    const schemaName = resolveSchemaForChange(changeDir, explicitSchema, projectRoot);
+    const schemaDir = getSchemaDir(schemaName, projectRoot);
+    if (schemaDir) {
+        for (const g of stringList(readYamlIfPresent(path.join(schemaDir, 'schema.yaml')), ['archive', 'guidance'])) {
+            if (!guidance.includes(g))
+                guidance.push(g);
+        }
+    }
+    return {
+        changeName,
+        ...(context !== undefined ? { context } : {}),
+        ...(guidance.length > 0 ? { operationGuidance: guidance } : {}),
+    };
+}
+function archiveInstructions(projectRoot, changeName, options) {
+    const payload = buildArchiveInstructions(projectRoot, changeName, options.schema);
+    if (options.json) {
+        printJson({ ...payload, planningHome: planningHomeStub(projectRoot) });
+        return 0;
+    }
+    console.log(`## Archive Inputs: ${changeName}`);
+    console.log();
+    if (payload.context) {
+        console.log('### Project Context (required instruction input)');
+        console.log(payload.context);
+        console.log();
+    }
+    if (payload.operationGuidance) {
+        console.log('### Operation Guidance (advisory)');
+        for (const g of payload.operationGuidance)
+            console.log(`- ${g}`);
+        console.log();
+    }
+    if (!payload.context && !payload.operationGuidance) {
+        console.log('No project context or operation guidance configured.');
+    }
+    return 0;
+}
+export { SPECIAL_TARGETS };

package/node_modules/@freeharness/sdd/dist/src/shim/list.d.ts

@@ -0,0 +1,5 @@
+export interface ListOptions {
+    json?: boolean;
+    sort?: 'recent' | 'name';
+}
+export declare function listHandler(projectRoot: string, options: ListOptions): Promise<number>;

package/node_modules/@freeharness/sdd/dist/src/shim/list.js

@@ -0,0 +1,95 @@
+// `openspec list [--json]` over the vendored engine.
+//
+// Reconstructed from src/core/list.ts (changes mode), minus store/root-selection.
+// JSON shape matches upstream: { changes: [{ name, completedTasks, totalTasks,
+// lastModified, status }] }, sorted most-recently-modified first by default.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getTaskProgressForChange, formatTaskStatus } from '../../vendor/openspec/engine/index.js';
+import { changesDirFor, printableId, printJson } from './shared.js';
+/** Most recent mtime of any file under a directory (recursive). */
+function getLastModified(dirPath) {
+    let latest = null;
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else {
+                const stat = fs.statSync(full);
+                if (latest === null || stat.mtime > latest)
+                    latest = stat.mtime;
+            }
+        }
+    };
+    walk(dirPath);
+    return latest ?? fs.statSync(dirPath).mtime;
+}
+export async function listHandler(projectRoot, options) {
+    const { json = false, sort = 'recent' } = options;
+    const changesDir = changesDirFor(projectRoot);
+    let entries;
+    try {
+        entries = fs.readdirSync(changesDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            entries = [];
+        else
+            throw error;
+    }
+    const changeDirs = entries
+        .filter((e) => e.isDirectory() && e.name !== 'archive' && !e.name.startsWith('.'))
+        .map((e) => e.name);
+    if (changeDirs.length === 0) {
+        if (json)
+            printJson({ changes: [] });
+        else
+            console.log('No active changes found.');
+        return 0;
+    }
+    const changes = [];
+    for (const name of changeDirs) {
+        const progress = await getTaskProgressForChange(changesDir, name, projectRoot);
+        changes.push({
+            name,
+            completedTasks: progress.completed,
+            totalTasks: progress.total,
+            openTasks: progress.open,
+            dispositionedTasks: progress.dispositioned,
+            lastModified: getLastModified(path.join(changesDir, name)),
+        });
+    }
+    if (sort === 'recent') {
+        changes.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    }
+    else {
+        changes.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    if (json) {
+        printJson({
+            changes: changes.map((c) => ({
+                name: c.name,
+                completedTasks: c.completedTasks,
+                totalTasks: c.totalTasks,
+                lastModified: c.lastModified.toISOString(),
+                status: c.totalTasks === 0 ? 'no-tasks' : c.openTasks === 0 ? 'complete' : 'in-progress',
+            })),
+        });
+        return 0;
+    }
+    console.log('Changes:');
+    const names = new Map(changes.map((c) => [c.name, printableId(c.name)]));
+    const nameWidth = Math.max(...[...names.values()].map((n) => n.length));
+    for (const change of changes) {
+        const status = formatTaskStatus({
+            total: change.totalTasks,
+            completed: change.completedTasks,
+            open: change.openTasks,
+            dispositioned: change.dispositionedTasks,
+        });
+        console.log(`  ${names.get(change.name).padEnd(nameWidth)}     ${status}`);
+    }
+    return 0;
+}

package/node_modules/@freeharness/sdd/dist/src/shim/new-change.d.ts

@@ -0,0 +1,6 @@
+export interface NewChangeOptions {
+    schema?: string;
+    description?: string;
+    json?: boolean;
+}
+export declare function newChangeHandler(projectRoot: string, name: string | undefined, options: NewChangeOptions): number;