stego-cli 0.4.1 → 0.4.2

package/dist/stego-cli/src/modules/scaffold/application/scaffold-workspace.js

@@ -0,0 +1,307 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { ROOT_CONFIG_FILENAME } from "../../workspace/index.js";
+import { COMMENT_AUTHOR_PROMPT, PROJECT_EXTENSION_RECOMMENDATIONS, PROSE_FONT_PROMPT, PROSE_MARKDOWN_EDITOR_SETTINGS, SCAFFOLD_AGENTS_CONTENT, SCAFFOLD_GITIGNORE_CONTENT, SCAFFOLD_README_CONTENT } from "../domain/templates.js";
+import { copyDirectory, copyFile, ensureDirectory, listDirectoryEntries, pathExists, readTextFile, statPath, writeTextFile } from "../infra/template-repo.js";
+export async function scaffoldWorkspace(input) {
+    const targetRoot = path.resolve(input.cwd);
+    const entries = listDirectoryEntries(targetRoot)
+        .filter((entry) => entry.name !== "." && entry.name !== "..");
+    if (entries.length > 0 && !input.force) {
+        throw new Error(`Target directory is not empty: ${targetRoot}. Re-run with --force to continue.`);
+    }
+    const packageRoot = resolvePackageRoot();
+    const copiedPaths = [];
+    writeScaffoldGitignore(targetRoot, copiedPaths);
+    writeScaffoldReadme(targetRoot, copiedPaths);
+    writeScaffoldAgents(targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, ".markdownlint.json", targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, ".markdownlint.manuscript.json", targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, ".cspell.json", targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, ROOT_CONFIG_FILENAME, targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, "projects", targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, path.join(".vscode", "tasks.json"), targetRoot, copiedPaths);
+    copyTemplateAsset(packageRoot, path.join(".vscode", "extensions.json"), targetRoot, copiedPaths, { optional: true });
+    rewriteTemplateProjectPackageScripts(targetRoot);
+    const enableProseFont = await promptYesNo(PROSE_FONT_PROMPT, true);
+    const suggestedCommentAuthor = resolveSuggestedCommentAuthor(targetRoot);
+    const commentAuthor = (await promptText(COMMENT_AUTHOR_PROMPT, suggestedCommentAuthor)).trim();
+    if (enableProseFont || commentAuthor) {
+        writeProjectProseEditorSettings(targetRoot, copiedPaths, {
+            enableProseFont,
+            commentAuthor
+        });
+    }
+    writeInitRootPackageJson(targetRoot, packageRoot);
+    return {
+        targetRoot,
+        copiedPaths
+    };
+}
+function resolvePackageRoot() {
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(scriptDir, "../../../../"),
+        path.resolve(scriptDir, "../../../../../../")
+    ];
+    for (const candidate of candidates) {
+        const configPath = path.join(candidate, ROOT_CONFIG_FILENAME);
+        const projectsPath = path.join(candidate, "projects");
+        if (pathExists(configPath) && pathExists(projectsPath)) {
+            return candidate;
+        }
+    }
+    throw new CliError("INTERNAL_ERROR", "Unable to resolve stego-cli package root for scaffolding.");
+}
+async function promptYesNo(question, defaultYes) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return defaultYes;
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+    try {
+        while (true) {
+            const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
+            if (!answer) {
+                return defaultYes;
+            }
+            if (answer === "y" || answer === "yes") {
+                return true;
+            }
+            if (answer === "n" || answer === "no") {
+                return false;
+            }
+            process.stdout.write("Please answer y or n.\n");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptText(question, defaultValue = "") {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return defaultValue;
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const suffix = defaultValue ? ` [${defaultValue}] ` : " ";
+    try {
+        const answer = (await rl.question(`${question}${suffix}`)).trim();
+        return answer || defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+function resolveSuggestedCommentAuthor(cwd) {
+    const gitAuthor = spawnSync("git", ["config", "--get", "user.name"], {
+        cwd,
+        encoding: "utf8"
+    });
+    const fromGit = (gitAuthor.stdout || "").trim();
+    if (gitAuthor.status === 0 && fromGit) {
+        return fromGit;
+    }
+    try {
+        const username = os.userInfo().username.trim();
+        if (username) {
+            return username;
+        }
+    }
+    catch {
+        // ignore and fall back to empty string
+    }
+    return "";
+}
+function copyTemplateAsset(packageRoot, sourceRelativePath, targetRoot, copiedPaths, options) {
+    const sourcePath = path.join(packageRoot, sourceRelativePath);
+    if (!pathExists(sourcePath)) {
+        if (options?.optional) {
+            return;
+        }
+        throw new Error(`Template asset is missing from stego-cli package: ${sourceRelativePath}`);
+    }
+    const destinationPath = path.join(targetRoot, sourceRelativePath);
+    const stats = statPath(sourcePath);
+    if (stats.isDirectory()) {
+        copyDirectory(sourcePath, destinationPath, (currentSourcePath) => shouldCopyTemplatePath(packageRoot, currentSourcePath));
+    }
+    else {
+        copyFile(sourcePath, destinationPath);
+    }
+    copiedPaths.push(sourceRelativePath);
+}
+function writeScaffoldGitignore(targetRoot, copiedPaths) {
+    writeTextFile(path.join(targetRoot, ".gitignore"), SCAFFOLD_GITIGNORE_CONTENT);
+    copiedPaths.push(".gitignore");
+}
+function writeScaffoldReadme(targetRoot, copiedPaths) {
+    writeTextFile(path.join(targetRoot, "README.md"), SCAFFOLD_README_CONTENT);
+    copiedPaths.push("README.md");
+}
+function writeScaffoldAgents(targetRoot, copiedPaths) {
+    writeTextFile(path.join(targetRoot, "AGENTS.md"), SCAFFOLD_AGENTS_CONTENT);
+    copiedPaths.push("AGENTS.md");
+}
+function shouldCopyTemplatePath(packageRoot, currentSourcePath) {
+    const relativePath = path.relative(packageRoot, currentSourcePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+        return true;
+    }
+    const parts = relativePath.split(path.sep);
+    const name = parts[parts.length - 1] || "";
+    if (name === ".DS_Store") {
+        return false;
+    }
+    if (parts[0] === "projects") {
+        if (parts[parts.length - 2] === ".vscode" && name === "settings.json") {
+            return false;
+        }
+        const distIndex = parts.indexOf("dist");
+        if (distIndex >= 0) {
+            const isDistRoot = distIndex === parts.length - 1;
+            const isGitkeep = name === ".gitkeep";
+            return isDistRoot || isGitkeep;
+        }
+    }
+    return true;
+}
+function rewriteTemplateProjectPackageScripts(targetRoot) {
+    const projectsRoot = path.join(targetRoot, "projects");
+    if (!pathExists(projectsRoot)) {
+        return;
+    }
+    for (const entry of listDirectoryEntries(projectsRoot)) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const projectRoot = path.join(projectsRoot, entry.name);
+        const packageJsonPath = path.join(projectRoot, "package.json");
+        if (!pathExists(packageJsonPath)) {
+            continue;
+        }
+        const parsed = tryReadJsonObject(packageJsonPath) ?? {};
+        const scripts = isPlainObject(parsed.scripts) ? { ...parsed.scripts } : {};
+        scripts.validate = "npx --no-install stego validate";
+        scripts.build = "npx --no-install stego build";
+        scripts["check-stage"] = "npx --no-install stego check-stage";
+        scripts.export = "npx --no-install stego export";
+        scripts.new = "npx --no-install stego new";
+        writeTextFile(packageJsonPath, `${JSON.stringify({ ...parsed, scripts }, null, 2)}\n`);
+        ensureProjectExtensionsRecommendations(projectRoot);
+    }
+}
+function ensureProjectExtensionsRecommendations(projectRoot) {
+    const vscodeDir = path.join(projectRoot, ".vscode");
+    const extensionsPath = path.join(vscodeDir, "extensions.json");
+    ensureDirectory(vscodeDir);
+    let existingRecommendations = [];
+    const parsed = tryReadJsonObject(extensionsPath);
+    if (parsed && Array.isArray(parsed.recommendations)) {
+        existingRecommendations = parsed.recommendations.filter((value) => typeof value === "string");
+    }
+    const mergedRecommendations = [
+        ...new Set([...PROJECT_EXTENSION_RECOMMENDATIONS, ...existingRecommendations])
+    ];
+    writeTextFile(extensionsPath, `${JSON.stringify({ recommendations: mergedRecommendations }, null, 2)}\n`);
+}
+function writeProjectProseEditorSettings(targetRoot, copiedPaths, options) {
+    const projectsRoot = path.join(targetRoot, "projects");
+    if (!pathExists(projectsRoot)) {
+        return;
+    }
+    for (const entry of listDirectoryEntries(projectsRoot)) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const projectRoot = path.join(projectsRoot, entry.name);
+        const settingsPath = writeProseEditorSettingsForProject(projectRoot, options);
+        copiedPaths.push(path.relative(targetRoot, settingsPath));
+    }
+}
+function writeProseEditorSettingsForProject(projectRoot, options) {
+    const vscodeDir = path.join(projectRoot, ".vscode");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+    ensureDirectory(vscodeDir);
+    const enableProseFont = options?.enableProseFont ?? true;
+    const commentAuthor = (options?.commentAuthor ?? "").trim();
+    const existingSettings = tryReadJsonObject(settingsPath) ?? {};
+    const proseMarkdownSettings = isPlainObject(PROSE_MARKDOWN_EDITOR_SETTINGS["[markdown]"])
+        ? PROSE_MARKDOWN_EDITOR_SETTINGS["[markdown]"]
+        : {};
+    const nextSettings = {
+        ...existingSettings
+    };
+    if (enableProseFont) {
+        const existingMarkdownSettings = isPlainObject(existingSettings["[markdown]"])
+            ? existingSettings["[markdown]"]
+            : {};
+        nextSettings["[markdown]"] = {
+            ...existingMarkdownSettings,
+            ...proseMarkdownSettings
+        };
+        nextSettings["markdown.preview.fontFamily"] = PROSE_MARKDOWN_EDITOR_SETTINGS["markdown.preview.fontFamily"];
+    }
+    if (commentAuthor) {
+        nextSettings["stego.comments.author"] = commentAuthor;
+    }
+    writeTextFile(settingsPath, `${JSON.stringify(nextSettings, null, 2)}\n`);
+    return settingsPath;
+}
+function writeInitRootPackageJson(targetRoot, packageRoot) {
+    const cliPackagePath = path.join(packageRoot, "package.json");
+    const cliPackage = tryReadJsonObject(cliPackagePath) ?? {};
+    const cliVersion = typeof cliPackage.version === "string" ? cliPackage.version : "0.1.0";
+    const manifest = {
+        name: path.basename(targetRoot) || "stego-workspace",
+        private: true,
+        type: "module",
+        description: "Stego writing workspace",
+        engines: {
+            node: ">=20"
+        },
+        scripts: {
+            "list-projects": "stego list-projects",
+            "new-project": "stego new-project",
+            new: "stego new",
+            spine: "stego spine",
+            metadata: "stego metadata",
+            lint: "stego lint",
+            validate: "stego validate",
+            build: "stego build",
+            "check-stage": "stego check-stage",
+            export: "stego export"
+        },
+        devDependencies: {
+            "stego-cli": `^${cliVersion}`,
+            cspell: "^9.6.4",
+            "markdownlint-cli": "^0.47.0"
+        }
+    };
+    writeTextFile(path.join(targetRoot, "package.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function tryReadJsonObject(filePath) {
+    if (!pathExists(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readTextFile(filePath));
+        return isPlainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/stego-cli/src/modules/scaffold/commands/init.js

@@ -0,0 +1,34 @@
+import { writeText } from "../../../app/output-renderer.js";
+import { scaffoldWorkspace } from "../application/scaffold-workspace.js";
+export function registerInitCommand(registry) {
+    registry.register({
+        name: "init",
+        description: "Initialize a new Stego workspace",
+        options: [
+            {
+                flags: "--force",
+                description: "Allow init in non-empty directory"
+            }
+        ],
+        action: async (context) => {
+            const result = await scaffoldWorkspace({
+                cwd: context.cwd,
+                force: readBooleanOption(context.options, "force")
+            });
+            writeText(`Initialized Stego workspace in ${result.targetRoot}`);
+            for (const relativePath of result.copiedPaths) {
+                writeText(`- ${relativePath}`);
+            }
+            writeText("- package.json");
+            writeText("");
+            writeText("Next steps:");
+            writeText("  npm install");
+            writeText("  stego list-projects");
+            writeText("  stego validate --project fiction-example");
+            writeText("  stego build --project fiction-example");
+        }
+    });
+}
+function readBooleanOption(options, key) {
+    return options[key] === true;
+}

package/dist/stego-cli/src/modules/scaffold/domain/templates.js

@@ -0,0 +1,182 @@
+export const PROSE_FONT_PROMPT = "Switch workspace to proportional (prose-style) font? (recommended)";
+export const COMMENT_AUTHOR_PROMPT = "Default comment author for stego.comments.author?";
+export const SCAFFOLD_GITIGNORE_CONTENT = `node_modules/
+/dist/
+.DS_Store
+*.log
+projects/*/dist/*
+!projects/*/dist/.gitkeep
+projects/*/.vscode/settings.json
+.vscode/settings.json
+`;
+export const SCAFFOLD_README_CONTENT = `# Stego Workspace
+
+This directory is a Stego writing workspace (a monorepo for one or more writing projects).
+
+## What was scaffolded
+
+- \`stego.config.json\` workspace configuration
+- \`projects/\` demo projects (\`stego-docs\` and \`fiction-example\`)
+- root \`package.json\` scripts for Stego commands
+- root \`.vscode/tasks.json\` tasks for common workflows
+
+Full documentation lives in \`projects/stego-docs\`.
+
+## First run
+
+\`\`\`bash
+npm install
+stego list-projects
+\`\`\`
+
+## Run commands for a specific project (from workspace root)
+
+\`\`\`bash
+stego validate --project fiction-example
+stego build --project fiction-example
+stego check-stage --project fiction-example --stage revise
+stego export --project fiction-example --format md
+stego new --project fiction-example
+\`\`\`
+
+## Work inside one project
+
+Each project also has local scripts, so you can run commands from inside a project directory:
+
+\`\`\`bash
+cd projects/fiction-example
+npm run validate
+npm run build
+\`\`\`
+
+## VS Code recommendation
+
+When you are actively working on one project, open that project directory directly in VS Code (for example \`projects/fiction-example\`).
+
+This keeps your editor context focused and applies the project's recommended extensions (including Stego + Saurus) for that project.
+
+## Create a new project
+
+\`\`\`bash
+stego new-project --project my-book --title "My Book"
+\`\`\`
+
+## Add a new manuscript file
+
+\`\`\`bash
+stego new --project fiction-example
+\`\`\`
+`;
+export const SCAFFOLD_AGENTS_CONTENT = `# AGENTS.md
+
+## Purpose
+
+This workspace is designed to be AI-friendly for writing workflows.
+
+## Canonical CLI Interface
+
+- Run \`stego --help\` for the full command reference.
+- Run \`stego --version\` to confirm which CLI is active.
+- Run project docs commands in \`projects/stego-docs\` when available.
+
+## CLI Resolution Rules
+
+- Prefer local CLI over global CLI:
+  - \`npm exec -- stego ...\`
+  - \`npx --no-install stego ...\`
+- At the start of mutation tasks, run \`stego --version\` and report the version used.
+
+## Workspace Discovery Checklist
+
+1. Confirm workspace root contains \`stego.config.json\`.
+2. Run \`stego list-projects\`.
+3. Use explicit \`--project <id>\` for project-scoped commands.
+
+## CLI-First Policy (Required)
+
+When asked to edit Stego project content, use documented Stego CLI commands first.
+
+Typical targets:
+
+- manuscript files
+- spine categories and entries
+- frontmatter metadata
+- comments
+- stage/build/export workflows
+
+Preferred commands include:
+
+- \`stego new\`
+- \`stego spine read\`
+- \`stego spine new-category\`
+- \`stego spine new\`
+- \`stego metadata read\`
+- \`stego metadata apply\`
+- \`stego comments ...\`
+
+## Machine-Mode Output
+
+- For automation and integrations, prefer \`--format json\` and parse structured output.
+- Use text output only for human-facing summaries.
+
+## Mutation Protocol
+
+1. Read current state first (\`metadata read\`, \`spine read\`, \`comments read\`).
+2. Mutate via CLI commands.
+3. Verify after writes (\`stego validate --project <id>\` and relevant read commands).
+
+## Manual Edit Fallback
+
+Manual file edits are a last resort.
+
+If manual edits are required, the agent must:
+
+1. warn that CLI was bypassed,
+2. explain why CLI could not be used, and
+3. list which files were manually edited.
+
+## Failure Contract
+
+When CLI fails:
+
+1. show the attempted command,
+2. summarize the error briefly,
+3. report the recovery attempt, and
+4. if fallback is required, apply the Manual Edit Fallback policy.
+
+## Validation Expectations
+
+After mutations, run relevant checks when feasible (for example \`stego validate --project <id>\`) and report results.
+
+## Scope Guardrails
+
+- Do not manually edit \`dist/\` outputs or compiled export artifacts.
+- Do not modify files outside the requested project scope unless the user explicitly asks.
+
+## Task To Command Quick Map
+
+- New manuscript: \`stego new --project <id> [--filename <name>]\`
+- Read spine: \`stego spine read --project <id> --format json\`
+- New spine category: \`stego spine new-category --project <id> --key <category>\`
+- New spine entry: \`stego spine new --project <id> --category <category> [--filename <path>]\`
+- Read metadata: \`stego metadata read <markdown-path> --format json\`
+- Apply metadata: \`stego metadata apply <markdown-path> --input <path|-> --format json\`
+- Read comments: \`stego comments read <manuscript> --format json\`
+- Mutate comments: \`stego comments add|reply|set-status|delete|clear-resolved|sync-anchors ... --format json\`
+`;
+export const PROSE_MARKDOWN_EDITOR_SETTINGS = {
+    "[markdown]": {
+        "editor.fontFamily": "Inter, Helvetica Neue, Helvetica, Arial, sans-serif",
+        "editor.fontSize": 17,
+        "editor.lineHeight": 28,
+        "editor.wordWrap": "wordWrapColumn",
+        "editor.wordWrapColumn": 72,
+        "editor.lineNumbers": "off"
+    },
+    "markdown.preview.fontFamily": "Inter, Helvetica Neue, Helvetica, Arial, sans-serif"
+};
+export const PROJECT_EXTENSION_RECOMMENDATIONS = [
+    "matt-gold.stego-extension",
+    "matt-gold.saurus-extension",
+    "streetsidesoftware.code-spell-checker"
+];

package/dist/stego-cli/src/modules/scaffold/index.js

@@ -0,0 +1,8 @@
+import { registerInitCommand } from "./commands/init.js";
+export const scaffoldModule = {
+    registerCommands(registry) {
+        registerInitCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/scaffold-workspace.js";

package/dist/stego-cli/src/modules/scaffold/infra/template-repo.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+export function listDirectoryEntries(dirPath) {
+    return fs.readdirSync(dirPath, { withFileTypes: true });
+}
+export function pathExists(filePath) {
+    return fs.existsSync(filePath);
+}
+export function statPath(filePath) {
+    return fs.statSync(filePath);
+}
+export function ensureDirectory(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+export function copyFile(sourcePath, destinationPath) {
+    ensureDirectory(path.dirname(destinationPath));
+    fs.copyFileSync(sourcePath, destinationPath);
+}
+export function copyDirectory(sourcePath, destinationPath, filter) {
+    ensureDirectory(destinationPath);
+    fs.cpSync(sourcePath, destinationPath, {
+        recursive: true,
+        force: true,
+        filter
+    });
+}
+export function writeTextFile(filePath, content) {
+    ensureDirectory(path.dirname(filePath));
+    fs.writeFileSync(filePath, content, "utf8");
+}
+export function readTextFile(filePath) {
+    return fs.readFileSync(filePath, "utf8");
+}

package/dist/stego-cli/src/modules/scaffold/types.js

@@ -0,0 +1 @@
+export {};

package/dist/stego-cli/src/modules/spine/application/create-category.js

@@ -0,0 +1,14 @@
+import { createSpineCategory } from "../domain/spine.js";
+import { readRequiredMetadata, writeRequiredMetadata } from "../infra/spine-repo.js";
+export function createSpineCategoryForProject(input) {
+    const requiredMetadata = readRequiredMetadata(input.project.meta);
+    const result = createSpineCategory(input.project.root, input.project.spineDir, input.key, input.label, requiredMetadata, input.requireMetadata);
+    if (input.requireMetadata && result.requiredMetadataUpdated) {
+        writeRequiredMetadata(input.project.root, input.project.meta, requiredMetadata);
+    }
+    return {
+        ok: true,
+        operation: "new-category",
+        result
+    };
+}

package/dist/stego-cli/src/modules/spine/application/create-entry.js

@@ -0,0 +1,9 @@
+import { createSpineEntry } from "../domain/spine.js";
+export function createSpineEntryForProject(input) {
+    const result = createSpineEntry(input.project.root, input.project.spineDir, input.category, input.filename);
+    return {
+        ok: true,
+        operation: "new",
+        result
+    };
+}

package/dist/stego-cli/src/modules/spine/application/read-catalog.js

@@ -0,0 +1,13 @@
+import { readSpineCatalog } from "../domain/spine.js";
+export function readSpineCatalogForProject(project) {
+    const catalog = readSpineCatalog(project.root, project.spineDir);
+    return {
+        ok: true,
+        operation: "read",
+        state: {
+            projectId: project.id,
+            categories: catalog.categories,
+            issues: catalog.issues
+        }
+    };
+}

package/dist/stego-cli/src/modules/spine/commands/spine-deprecated-aliases.js

@@ -0,0 +1,33 @@
+export function registerSpineDeprecatedAliases(registry) {
+    registry.register({
+        name: "spine add-category",
+        description: "Deprecated alias for spine new-category",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--project <project-id>", description: "Project id" },
+            { flags: "--key <category>", description: "Category key" },
+            { flags: "--label <label>", description: "Category display label" },
+            { flags: "--require-metadata", description: "Append key to required metadata" },
+            { flags: "--format <format>", description: "text|json" },
+            { flags: "--root <path>", description: "Workspace root path" }
+        ],
+        action: () => {
+            throw new Error("`stego spine add-category` was renamed. Use `stego spine new-category`.");
+        }
+    });
+    registry.register({
+        name: "spine new-entry",
+        description: "Deprecated alias for spine new",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--project <project-id>", description: "Project id" },
+            { flags: "--category <category>", description: "Category key" },
+            { flags: "--filename <path>", description: "Relative entry path" },
+            { flags: "--format <format>", description: "text|json" },
+            { flags: "--root <path>", description: "Workspace root path" }
+        ],
+        action: () => {
+            throw new Error("`stego spine new-entry` was renamed. Use `stego spine new`.");
+        }
+    });
+}