stego-cli 0.1.5 → 0.1.7

package/.gitignore

@@ -6,3 +6,4 @@ projects/*/dist/*
 !projects/*/dist/.gitkeep
 projects/*/.vscode/settings.json
 .vscode/settings.json
+local-only/

package/.markdownlint.manuscript.json

@@ -0,0 +1,8 @@
+{
+  "default": true,
+  "MD013": false,
+  "MD033": false,
+  "MD026": false,
+  "MD036": false,
+  "MD041": false
+}

package/README.md

@@ -1,22 +1,12 @@
-# Stego
+# Stego CLI
 
-Stego is a Markdown-first creative writing workflow packaged as an installable CLI: `stego-cli`.
+`stego-cli` is an installable CLI for the Stego writing workflow.
 
-This repository is the source for the CLI and the example/template content that `stego init` scaffolds into a new workspace.
+It scaffolds a Stego workspace, validates manuscript structure and metadata, runs stage-aware quality gates, builds compiled markdown outputs, and exports release formats.
 
-## What this includes
+This repository is the source for the CLI and the template/example projects that `stego init` scaffolds.
 
-- Installable CLI (`stego`) for creating and operating Stego workspaces
-- Project-per-folder structure inside one monorepo.
-- Flexible manuscript files with per-project metadata requirements.
-- Configurable manuscript grouping via `compileStructure.levels` (for example `part` + `chapter`).
-- Project-defined spine categories (configured in each `stego-project.json`).
-- Deterministic build into one manuscript Markdown file.
-- Stage-based quality gates (`draft` -> `final`).
-- Export abstraction (`md` always, `docx`/`pdf` via optional `pandoc`).
-- Example/demo projects (`docs-demo`, `plague-demo`) included in `stego init`.
-
-## Getting started (from npm)
+## Quick start (install + init)
 
 ```bash
 npm install -g stego-cli
@@ -24,73 +14,69 @@ npm install -g stego-cli
 mkdir my-stego-workspace
 cd my-stego-workspace
 stego init
-
 npm install
-npm run list-projects
-npm run validate -- --project plague-demo
-npm run build -- --project plague-demo
-npm run check-stage -- --project plague-demo --stage revise
-npm run export -- --project plague-demo --format md
+
+stego list-projects
+stego validate --project fiction-example
+stego build --project fiction-example
 ```
 
-`stego init` scaffolds a new workspace in the current directory (it must be empty unless you pass `--force`).
+`stego init` scaffolds two example projects:
 
-Create another project in the workspace:
+- `stego-docs` (the full documentation project)
+- `fiction-example` (a fiction-oriented demo with rich Spine usage)
 
-```bash
-stego new-project --project my-new-project --title "My New Project"
-```
+For day-to-day editing, open a project folder in VS Code (for example `projects/stego-docs`) and use the Stego VS Code extension, which is the official UI for Stego projects.
+
+## Full documentation
 
-`stego new-project` scaffolds `manuscript/`, `spine/`, `notes/`, and `dist/`, seeds `stego-project.json`, creates a project-local `package.json`, and writes `.vscode/extensions.json` recommendations (Stego + Saurus) for that project.
+The full user documentation lives in the `stego-docs` project.
 
-## Running commands for a specific project
+- In a scaffolded workspace: `projects/stego-docs`
+- In this source repo: `projects/stego-docs`
 
-From the workspace root, target a project with `--project`:
+Start by reading the manuscript files in order, or build the docs project:
 
 ```bash
-npm run validate -- --project plague-demo
-npm run build -- --project plague-demo
-npm run check-stage -- --project plague-demo --stage proof
-npm run export -- --project plague-demo --format md
+stego build --project stego-docs
 ```
 
-Each project also has local scripts, so you can work from inside the project directory:
+## Core commands
+
+Run commands from the workspace root and target a project with `--project`.
 
 ```bash
-cd projects/plague-demo
-npm run validate
-npm run build
-npm run check-stage -- --stage proof
-npm run export -- --format md
+stego list-projects
+stego new-project --project my-book --title "My Book"
+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
 ```
 
-## VS Code workflow
+Projects also include local npm scripts so you can work from inside a project directory.
 
-When you are actively working on one project, open that project directory directly in VS Code (for example `projects/plague-demo`) rather than the whole workspace.
+## VS Code workflow
 
-This keeps editor context focused and applies the project's recommended extensions via `projects/<project-id>/.vscode/extensions.json`.
+When actively working on one project, open that project directory directly in VS Code (for example `projects/fiction-example`).
 
-## Developing `stego-cli` (this repo)
+The Stego VS Code extension is the official UI for Stego projects, and opening a single project keeps its UI context and Spine Browser focused. Project folders also include extension recommendations.
 
-If you are working on the CLI itself (this repository), use the local development scripts:
+## Develop `stego-cli` (this repo)
 
 ```bash
 npm install
 npm run list-projects
-npm run validate -- --project docs-demo
-npm run build -- --project plague-demo
-npm run test:compile-structure
+npm run validate -- --project stego-docs
+npm run build -- --project fiction-example
+npm run test
 npm run build:cli
 npm run pack:dry-run
 ```
 
-These source-repo scripts run the TypeScript CLI directly with Node (`--experimental-strip-types`) for local development.
-
-## Export requirements (DOCX/PDF)
+## Export requirements (`docx`, `pdf`, `epub`)
 
-`docx` and `pdf` export require `pandoc` on your system `PATH`.
-
-Install:
+These formats require `pandoc` on your `PATH`.
 
 ```bash
 # macOS (Homebrew)
@@ -106,139 +92,3 @@ sudo apt-get update && sudo apt-get install -y pandoc
 # Windows (winget)
 winget install --id JohnMacFarlane.Pandoc -e
 ```
-
-Verify:
-
-```bash
-pandoc --version
-```
-
-Then run:
-
-```bash
-npm run export -- --project plague-demo --format docx
-npm run export -- --project plague-demo --format pdf
-```
-
-## Scaffolded workspace layout
-
-- `projects/<project-id>/manuscript/` source manuscript files
-- `projects/<project-id>/spine/` canonical spine category files (`spineCategories[*].notesFile`)
-- `projects/<project-id>/notes/` regular notes and planning docs
-- `projects/<project-id>/dist/` generated outputs only
-- `stego.config.json` workspace configuration
-- `docs/` workflow and conventions
-- `.vscode/tasks.json` root VS Code tasks for common Stego commands
-
-## This repo layout (`stego-cli` source)
-
-- `tools/` CLI source code and exporters
-- `projects/` template/demo projects bundled by `stego init`
-- `docs/` user-facing docs copied into scaffolded workspaces
-- `.github/workflows/` CI + Changesets release automation
-
-## Project spine categories
-
-Spine categories are not fixed. Each project can declare them in `stego-project.json` under `spineCategories`.
-
-Example:
-
-```json
-{
-  "spineCategories": [
-    { "key": "cast", "prefix": "CHAR", "notesFile": "characters.md" },
-    { "key": "places", "prefix": "LOC", "notesFile": "locations.md" },
-    { "key": "incidents", "prefix": "EVENT", "notesFile": "timeline.md" },
-    { "key": "ordinances", "prefix": "STATUTE", "notesFile": "ordinances.md" }
-  ]
-}
-```
-
-Use those keys as metadata arrays in manuscript files (for example `cast`, `places`, `incidents`, `ordinances`).
-Each `notesFile` is a filename resolved in `spine/` (for example `spine/characters.md`).
-
-If `spineCategories` is omitted or empty, category-based continuity validation is disabled.
-
-## Project metadata requirements
-
-Base config defaults to `status`.
-
-Each project can override required keys in `stego-project.json`:
-
-```json
-{
-  "requiredMetadata": ["status", "chapter", "pov", "timeline"]
-}
-```
-
-These keys are advisory and reported as warnings when missing; they do not block validate/build/export.
-Files may omit metadata entirely.
-
-## Compile structure (grouped manuscript output)
-
-Build grouping is configured per project with `compileStructure.levels`.
-
-Example:
-
-```json
-{
-  "compileStructure": {
-    "levels": [
-      {
-        "key": "part",
-        "label": "Part",
-        "titleKey": "part_title",
-        "injectHeading": true,
-        "headingTemplate": "{label} {value}: {title}",
-        "pageBreak": "between-groups"
-      },
-      {
-        "key": "chapter",
-        "label": "Chapter",
-        "titleKey": "chapter_title",
-        "injectHeading": true,
-        "headingTemplate": "{label} {value}: {title}",
-        "pageBreak": "between-groups"
-      }
-    ]
-  }
-}
-```
-
-Notes:
-
-- `pageBreak` currently supports `none` or `between-groups`.
-- TOC entries are nested by level depth.
-- Missing group key/title values inherit from the previous manuscript file, so you only need to set metadata at structural boundaries.
-- `validate` reports configuration errors for invalid `compileStructure` entries.
-
-## Included examples
-
-- `plague-demo`: full configuration — rich metadata (`pov`, `timeline`), three spine categories (`characters`, `locations`, `sources`), cross-linked spine with Wikipedia reference links
-- `docs-demo`: nonfiction documentation configuration — no spine categories, freeform notes only, primarily `status` metadata
-
-## Placeholder edit workflow (`{{...}}` + Cmd+I)
-
-This repo includes Copilot instruction files to keep placeholder edits scoped:
-
-- `.github/copilot-instructions.md`
-- `.github/instructions/placeholder-fill.instructions.md`
-
-Placeholder convention:
-
-- Write draft placeholders as `{{...}}` in manuscript prose.
-- Select the placeholder text and run Cmd+I.
-- Use short prompts like `fill placeholder` or `replace only inside {{}}`.
-
-Expected behavior:
-
-- Replace only the content inside braces.
-- Preserve surrounding sentence/paragraph text.
-
-## Next Steps
-
-- Add Mermaid graphs of metadata (entity relationships, co-occurrence, chapter sequence).
-
-## VS Code tasks
-
-Tasks are defined in `.vscode/tasks.json` for validate/build/stage-check/export.

package/dist/stego-cli.js

@@ -34,25 +34,26 @@ This directory is a Stego writing workspace (a monorepo for one or more writing
 ## What was scaffolded
 
 - \`stego.config.json\` workspace configuration
-- \`projects/\` demo projects (\`docs-demo\` and \`plague-demo\`)
-- \`docs/\` workflow and conventions docs
+- \`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
-npm run list-projects
+stego list-projects
 \`\`\`
 
 ## Run commands for a specific project (from workspace root)
 
 \`\`\`bash
-npm run validate -- --project plague-demo
-npm run build -- --project plague-demo
-npm run check-stage -- --project plague-demo --stage revise
-npm run export -- --project plague-demo --format md
+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
 \`\`\`
 
 ## Work inside one project
@@ -60,14 +61,14 @@ npm run export -- --project plague-demo --format md
 Each project also has local scripts, so you can run commands from inside a project directory:
 
 \`\`\`bash
-cd projects/plague-demo
+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/plague-demo\`).
+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.
 
@@ -156,6 +157,18 @@ async function main() {
                 }
                 return;
             }
+            case "lint": {
+                activateWorkspace(options);
+                const project = resolveProject(readStringOption(options, "project"));
+                const selection = resolveLintSelection(options);
+                const result = runProjectLint(project, selection);
+                printReport(result.issues);
+                exitIfErrors(result.issues);
+                const scopeLabel = formatLintSelection(selection);
+                const fileLabel = result.fileCount === 1 ? "file" : "files";
+                logLine(`Lint passed for '${project.id}' (${scopeLabel}, ${result.fileCount} ${fileLabel}).`);
+                return;
+            }
             case "export": {
                 activateWorkspace(options);
                 const project = resolveProject(readStringOption(options, "project"));
@@ -463,9 +476,9 @@ async function initWorkspace(options) {
     writeScaffoldGitignore(targetRoot, copiedPaths);
     writeScaffoldReadme(targetRoot, copiedPaths);
     copyTemplateAsset(".markdownlint.json", targetRoot, copiedPaths);
+    copyTemplateAsset(".markdownlint.manuscript.json", targetRoot, copiedPaths);
     copyTemplateAsset(".cspell.json", targetRoot, copiedPaths);
     copyTemplateAsset(ROOT_CONFIG_FILENAME, targetRoot, copiedPaths);
-    copyTemplateAsset("docs", targetRoot, copiedPaths);
     copyTemplateAsset("projects", targetRoot, copiedPaths);
     copyTemplateAsset(path.join(".vscode", "tasks.json"), targetRoot, copiedPaths);
     copyTemplateAsset(path.join(".vscode", "extensions.json"), targetRoot, copiedPaths, { optional: true });
@@ -483,8 +496,9 @@ async function initWorkspace(options) {
     logLine("");
     logLine("Next steps:");
     logLine("  npm install");
-    logLine("  npm run list-projects");
-    logLine("  npm run validate -- --project plague-demo");
+    logLine("  stego list-projects");
+    logLine("  stego validate --project fiction-example");
+    logLine("  stego build --project fiction-example");
 }
 async function promptYesNo(question, defaultYes) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -589,9 +603,6 @@ function rewriteTemplateProjectPackageScripts(targetRoot) {
         const scripts = isPlainObject(projectPackage.scripts)
             ? { ...projectPackage.scripts }
             : {};
-        if (typeof projectPackage.name === "string" && projectPackage.name.startsWith("writing-project-")) {
-            projectPackage.name = projectPackage.name.replace(/^writing-project-/, "stego-project-");
-        }
         scripts.validate = "npx --no-install stego validate";
         scripts.build = "npx --no-install stego build";
         scripts["check-stage"] = "npx --no-install stego check-stage";
@@ -686,6 +697,7 @@ function writeInitRootPackageJson(targetRoot) {
         scripts: {
             "list-projects": "stego list-projects",
             "new-project": "stego new-project",
+            lint: "stego lint",
             validate: "stego validate",
             build: "stego build",
             "check-stage": "stego check-stage",
@@ -700,7 +712,7 @@ function writeInitRootPackageJson(targetRoot) {
     fs.writeFileSync(path.join(targetRoot, "package.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
 }
 function printUsage() {
-    console.log(`Stego CLI\n\nCommands:\n  init [--force]\n  list-projects [--root <path>]\n  new-project --project <project-id> [--title <title>] [--root <path>]\n  validate --project <project-id> [--file <project-relative-manuscript-path>] [--root <path>]\n  build --project <project-id> [--root <path>]\n  check-stage --project <project-id> --stage <draft|revise|line-edit|proof|final> [--file <project-relative-manuscript-path>] [--root <path>]\n  export --project <project-id> --format <md|docx|pdf|epub> [--output <path>] [--root <path>]\n`);
+    console.log(`Stego CLI\n\nCommands:\n  init [--force]\n  list-projects [--root <path>]\n  new-project --project <project-id> [--title <title>] [--root <path>]\n  validate --project <project-id> [--file <project-relative-manuscript-path>] [--root <path>]\n  build --project <project-id> [--root <path>]\n  check-stage --project <project-id> --stage <draft|revise|line-edit|proof|final> [--file <project-relative-manuscript-path>] [--root <path>]\n  lint --project <project-id> [--manuscript|--spine] [--root <path>]\n  export --project <project-id> --format <md|docx|pdf|epub> [--output <path>] [--root <path>]\n`);
 }
 function listProjects() {
     const ids = getProjectIds();
@@ -731,6 +743,7 @@ async function createProject(projectIdOption, titleOption) {
     const notesDir = path.join(projectRoot, config.notesDir);
     fs.mkdirSync(notesDir, { recursive: true });
     fs.mkdirSync(path.join(projectRoot, config.distDir), { recursive: true });
+    const manuscriptDir = path.join(projectRoot, config.chapterDir);
     const projectJson = {
         id: projectId,
         title: titleOption?.trim() || toDisplayTitle(projectId),
@@ -761,6 +774,7 @@ async function createProject(projectIdOption, titleOption) {
         name: `stego-project-${projectId}`,
         private: true,
         scripts: {
+            lint: "npx --no-install stego lint",
             validate: "npx --no-install stego validate",
             build: "npx --no-install stego build",
             "check-stage": "npx --no-install stego check-stage",
@@ -769,6 +783,17 @@ async function createProject(projectIdOption, titleOption) {
     };
     const projectPackagePath = path.join(projectRoot, "package.json");
     fs.writeFileSync(projectPackagePath, `${JSON.stringify(projectPackage, null, 2)}\n`, "utf8");
+    const starterManuscriptPath = path.join(manuscriptDir, "100-hello-world.md");
+    fs.writeFileSync(starterManuscriptPath, `---
+status: draft
+chapter: 1
+chapter_title: Hello World
+---
+
+# Hello World
+
+Start writing here.
+`, "utf8");
     const charactersNotesPath = path.join(spineDir, "characters.md");
     fs.writeFileSync(charactersNotesPath, "# Characters\n\n", "utf8");
     const projectExtensionsPath = path.join(projectRoot, ".vscode", "extensions.json");
@@ -781,6 +806,7 @@ async function createProject(projectIdOption, titleOption) {
     logLine(`Created project: ${path.relative(repoRoot, projectRoot)}`);
     logLine(`- ${path.relative(repoRoot, projectJsonPath)}`);
     logLine(`- ${path.relative(repoRoot, projectPackagePath)}`);
+    logLine(`- ${path.relative(repoRoot, starterManuscriptPath)}`);
     logLine(`- ${path.relative(repoRoot, charactersNotesPath)}`);
     logLine(`- ${path.relative(repoRoot, projectExtensionsPath)}`);
     if (projectSettingsPath) {
@@ -1604,10 +1630,10 @@ function runStageCheck(project, runtimeConfig, stage, onlyFile) {
     const chapterPaths = report.chapters.map((chapter) => chapter.path);
     const spineWords = collectSpineWordsForSpellcheck(report.spineState.ids);
     if (policy.enforceMarkdownlint) {
-        issues.push(...runMarkdownlint(project, chapterPaths, true));
+        issues.push(...runMarkdownlint(project, chapterPaths, true, "manuscript"));
     }
     else {
-        issues.push(...runMarkdownlint(project, chapterPaths, false));
+        issues.push(...runMarkdownlint(project, chapterPaths, false, "manuscript"));
     }
     if (policy.enforceCSpell) {
         issues.push(...runCSpell(chapterPaths, true, spineWords));
@@ -1617,20 +1643,133 @@ function runStageCheck(project, runtimeConfig, stage, onlyFile) {
     }
     return { chapters: report.chapters, issues };
 }
-function runMarkdownlint(project, files, required) {
+function resolveLintSelection(options) {
+    const manuscript = readBooleanOption(options, "manuscript");
+    const spine = readBooleanOption(options, "spine");
+    if (!manuscript && !spine) {
+        return { manuscript: true, spine: true };
+    }
+    return { manuscript, spine };
+}
+function formatLintSelection(selection) {
+    if (selection.manuscript && selection.spine) {
+        return "manuscript + spine";
+    }
+    if (selection.manuscript) {
+        return "manuscript";
+    }
+    if (selection.spine) {
+        return "spine";
+    }
+    return "none";
+}
+function runProjectLint(project, selection) {
+    const issues = [];
+    let fileCount = 0;
+    if (selection.manuscript) {
+        const manuscriptFiles = collectTopLevelMarkdownFiles(project.manuscriptDir);
+        if (manuscriptFiles.length === 0) {
+            issues.push(makeIssue("error", "lint", `No manuscript markdown files found in ${project.manuscriptDir}`));
+        }
+        else {
+            fileCount += manuscriptFiles.length;
+            issues.push(...runMarkdownlint(project, manuscriptFiles, true, "manuscript"));
+        }
+    }
+    if (selection.spine) {
+        const spineLintState = collectSpineLintMarkdownFiles(project);
+        issues.push(...spineLintState.issues);
+        if (spineLintState.files.length > 0) {
+            fileCount += spineLintState.files.length;
+            issues.push(...runMarkdownlint(project, spineLintState.files, true, "default"));
+        }
+    }
+    if (fileCount === 0 && issues.length === 0) {
+        issues.push(makeIssue("error", "lint", `No markdown files found for lint scope '${formatLintSelection(selection)}' in project '${project.id}'.`));
+    }
+    return { issues, fileCount };
+}
+function collectSpineLintMarkdownFiles(project) {
+    const issues = [];
+    const files = new Set();
+    addMarkdownFilesFromDirectory(files, project.spineDir, true);
+    if (!fs.existsSync(project.spineDir)) {
+        issues.push(makeIssue("warning", "lint", `Missing spine directory: ${project.spineDir}`));
+    }
+    addMarkdownFilesFromDirectory(files, project.notesDir, true);
+    if (!fs.existsSync(project.notesDir)) {
+        issues.push(makeIssue("warning", "lint", `Missing notes directory: ${project.notesDir}`));
+    }
+    for (const file of collectTopLevelMarkdownFiles(project.root)) {
+        files.add(file);
+    }
+    const sortedFiles = Array.from(files).sort();
+    if (sortedFiles.length === 0) {
+        issues.push(makeIssue("error", "lint", `No spine/notes markdown files found in ${project.spineDir}, ${project.notesDir}, or project root.`));
+    }
+    return { files: sortedFiles, issues };
+}
+function collectTopLevelMarkdownFiles(directory) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory()) {
+        return [];
+    }
+    return fs
+        .readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
+        .map((entry) => path.join(directory, entry.name))
+        .sort();
+}
+function addMarkdownFilesFromDirectory(target, directory, recursive) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory()) {
+        return;
+    }
+    const stack = [directory];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        const entries = fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isFile() && entry.name.endsWith(".md")) {
+                target.add(fullPath);
+                continue;
+            }
+            if (recursive && entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+        }
+    }
+}
+function runMarkdownlint(project, files, required, profile = "default") {
+    if (files.length === 0) {
+        return [];
+    }
     const markdownlintCommand = resolveCommand("markdownlint");
     if (!markdownlintCommand) {
         if (required) {
             return [
-                makeIssue("error", "tooling", "markdownlint is required for this stage but not installed. Run 'npm i' in the repo root.")
+                makeIssue("error", "tooling", "markdownlint is required for this command but not installed. Run 'npm i' in the repo root.")
             ];
         }
         return [];
     }
-    const projectConfigPath = path.join(project.root, ".markdownlint.json");
-    const markdownlintConfigPath = fs.existsSync(projectConfigPath)
-        ? projectConfigPath
-        : path.join(repoRoot, ".markdownlint.json");
+    const manuscriptProjectConfigPath = path.join(project.root, ".markdownlint.manuscript.json");
+    const manuscriptRepoConfigPath = path.join(repoRoot, ".markdownlint.manuscript.json");
+    const defaultProjectConfigPath = path.join(project.root, ".markdownlint.json");
+    const defaultRepoConfigPath = path.join(repoRoot, ".markdownlint.json");
+    const markdownlintConfigPath = profile === "manuscript"
+        ? (fs.existsSync(manuscriptProjectConfigPath)
+            ? manuscriptProjectConfigPath
+            : fs.existsSync(manuscriptRepoConfigPath)
+                ? manuscriptRepoConfigPath
+                : fs.existsSync(defaultProjectConfigPath)
+                    ? defaultProjectConfigPath
+                    : defaultRepoConfigPath)
+        : (fs.existsSync(defaultProjectConfigPath)
+            ? defaultProjectConfigPath
+            : defaultRepoConfigPath);
     const prepared = prepareFilesWithoutComments(files);
     try {
         const result = spawnSync(markdownlintCommand, ["--config", markdownlintConfigPath, ...prepared.files], {

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "stego-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "description": "Installable CLI for the Stego writing monorepo workflow.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/matt-gold/stego.git"
+    "url": "https://github.com/matt-gold/stego-cli.git"
   },
   "bugs": {
-    "url": "https://github.com/matt-gold/stego/issues"
+    "url": "https://github.com/matt-gold/stego-cli/issues"
   },
-  "homepage": "https://github.com/matt-gold/stego#readme",
+  "homepage": "https://github.com/matt-gold/stego-cli#readme",
   "bin": {
     "stego": "dist/stego-cli.js"
   },
@@ -20,14 +20,15 @@
   },
   "files": [
     "dist/**",
-    "docs/**",
     "projects/**",
+    "!projects/local-only/**",
     "!projects/*/dist/*.md",
     "!projects/*/dist/exports/**",
     ".vscode/tasks.json",
     ".vscode/extensions.json",
     ".gitignore",
     ".markdownlint.json",
+    ".markdownlint.manuscript.json",
     ".cspell.json",
     "stego.config.json",
     "README.md"
@@ -41,6 +42,7 @@
     "release:version": "changeset version",
     "list-projects": "node --experimental-strip-types tools/stego-cli.ts list-projects",
     "new-project": "node --experimental-strip-types tools/stego-cli.ts new-project",
+    "lint": "node --experimental-strip-types tools/stego-cli.ts lint",
     "validate": "node --experimental-strip-types tools/stego-cli.ts validate",
     "build": "node --experimental-strip-types tools/stego-cli.ts build",
     "check-stage": "node --experimental-strip-types tools/stego-cli.ts check-stage",

package/projects/fiction-example/.markdownlint.json

@@ -0,0 +1,5 @@
+{
+  "default": true,
+  "MD013": false,
+  "MD033": false
+}

package/projects/fiction-example/.markdownlint.manuscript.json

@@ -0,0 +1,8 @@
+{
+  "default": true,
+  "MD013": false,
+  "MD033": false,
+  "MD026": false,
+  "MD036": false,
+  "MD041": false
+}