@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/skills/erp-kit-module-6-impl-review/SKILL.md

@@ -59,7 +59,14 @@ After ALL agents return:
 3. Merge all `inconsistencies[]` arrays into a single list
 4. Deduplicate: if two gaps share the same `source + target + check`, keep only one
 5. Calculate totals across all summaries
-6. Render the final report below
+6. **Classify severity** — for each non-pass gap and inconsistency, the router assigns a severity based on the finding's `check`, `status`, and `detail`:
+   - `critical`: missing implementation of documented feature, broken doc-code contract — blocks progress
+   - `major`: incomplete implementation, missing test case for documented business rule — should fix
+   - `nit`: minor naming difference, optional JSDoc, cosmetic issue — does NOT block the review
+7. **Determine verdict**:
+   - **APPROVED**: zero `critical` and zero `major` findings (nits only, or all pass)
+   - **NEEDS CHANGES**: one or more `critical` or `major` findings
+8. Render the final report below
 
 ## Report Format
 
@@ -171,13 +178,20 @@ Render the aggregated results as markdown:
 
 ### 10. Recommendations
 
-Numbered list of actionable fixes, grouped by priority:
+Numbered list of actionable fixes, grouped by severity:
 
-1. Add missing model fields/states (highest priority)
-2. Implement missing business rules
-3. Define missing error classes (re-run `erp-kit module generate code`)
-4. Add missing test cases
-5. Fix inconsistencies
+1. `critical` — missing model fields/states, broken doc-code contract (must fix)
+2. `major` — missing business rules, incomplete test coverage (should fix)
+3. `nit` — minor naming differences, optional JSDoc, cosmetic issues (informational only)
+
+### 11. Verdict
+
+**Verdict: APPROVED / NEEDS CHANGES**
+
+- If APPROVED with nits: "Review passed. The following nits are informational and do not block progress:" followed by the nit list.
+- If NEEDS CHANGES: "Review requires changes. Fix all critical and major issues, then re-run the review."
+
+Severity counts: `critical: N, major: N, nit: N`
 
 ## References
 

package/skills/erp-kit-module-6-impl-review/references/error-implementation-parity.md

@@ -72,7 +72,7 @@ For each error scenario documented in command docs:
 
 ## Common Gap Patterns
 
-- **Missing error class**: Error code in doc but no generated class (re-run `erp-kit module generate code`)
+- **Missing error class**: Error code in doc but no generated class (re-run `erp-kit module generate code -p <path>`)
 - **Error not returned**: Generated class exists but command code doesn't return it
 - **Error not imported**: Command uses inline error instead of generated class
 - **Missing error test**: Error is returned in code but no test asserts it

package/skills/erp-kit-module-6-impl-review/references/errors.md

@@ -7,4 +7,4 @@ Errors are **generated** from command/query documentation into `lib/errors.gener
 - Every error code in `docs/commands/*.md` has a corresponding class in `lib/errors.generated.ts`
 - Command implementations import errors from `../lib/errors.generated`
 - Generated error codes are prefixed with the module name (e.g., doc code `UNIT_NOT_FOUND` becomes `PRIMITIVES_UNIT_NOT_FOUND`)
-- If errors are missing, re-run `erp-kit module generate code`
+- If errors are missing, re-run `erp-kit module generate code -p <path>`

package/skills/erp-kit-module-6-impl-review/references/impl-parity-report-format.md

@@ -50,3 +50,18 @@ Cross-cutting issues found during the check that don't fit a single gap entry (e
 ### summary
 
 Aggregate counts. `total_checks = passed + failed + skipped`.
+
+## Router-Level Severity and Verdict
+
+The router (SKILL.md Step 3) assigns severity to each non-pass finding after collecting all agent results. Agents do NOT assign severity — they only report `status` and `detail`.
+
+The router classifies each finding as:
+
+- `critical`: blocks progress — missing implementation of documented feature, broken contract between doc and code
+- `major`: should fix — incomplete implementation, missing test case for documented business rule
+- `nit`: nice to have — minor naming difference, optional JSDoc improvement, cosmetic code style issue
+
+Verdict rule:
+
+- `APPROVED`: zero `critical` and zero `major` findings (nits only, or all pass)
+- `NEEDS_CHANGES`: one or more `critical` or `major` findings

package/skills/erp-kit-module-shared/SKILL.md

@@ -7,6 +7,10 @@ description: Shared references for erp-kit module skills. Not invoked directly
 
 Canonical reference files shared across module skills. Individual skills reference these instead of maintaining their own copies.
 
+## Design Philosophy
+
+Modules are intentionally simple. Each module is a thin layer of domain logic over the database — avoid introducing unnecessary abstractions, deep inheritance hierarchies, or complex patterns. Over-engineering is actively harmful: it makes modules harder to understand, test, and maintain. When in doubt, choose the straightforward approach. A few lines of duplicated code is better than a premature abstraction.
+
 ## References
 
 - [Module structure](references/structure.md)

package/skills/erp-kit-module-shared/references/errors.md

@@ -5,7 +5,7 @@ Errors are **generated** from command/query documentation. Do not write `lib/err
 ## How it works
 
 1. Write error scenarios in `docs/commands/*.md` as `CODE: Description` pairs
-2. Run `erp-kit module generate code` to produce `lib/errors.generated.ts`
+2. Run `erp-kit module generate code -p <path>` to produce `lib/errors.generated.ts`
 3. Import generated errors in your command implementations
 
 ## Naming convention (in docs)

package/skills/erp-kit-module-shared/references/queries.md

@@ -2,7 +2,7 @@
 
 ## Generated Query Shells
 
-Run `erp-kit module generate code` to generate query shells from `docs/queries/*.md`. Each generated shell wraps your `run` function with `defineQuery`.
+Run `erp-kit module generate code -p <path>` to generate query shells from `docs/queries/*.md`. Each generated shell wraps your `run` function with `defineQuery`.
 
 ### Generated shell example
 

package/skills/erp-kit-module-shared/references/structure.md

@@ -1,6 +1,6 @@
 # Module Directory Structure
 
-This structure is automatically scaffolded by `erp-kit module scaffold module <name>`.
+This structure is automatically scaffolded by `erp-kit module init <name> <dir>`.
 
 ```
 {module}/

package/skills/erp-kit-update/SKILL.md

@@ -19,8 +19,8 @@ Ask the user:
 
 1. **What changed?** (free-text description of the change)
 2. **Where?** Determine domain from the target:
-   - `examples/<app>/` → **App workflow** (skills matching `erp-kit-app-*`)
-   - `modules/<module>/` → **Module workflow** (skills matching `erp-kit-module-*`)
+   - App directory (e.g., `{APP_ROOT}/{APP_NAME}/`) → **App workflow** (skills matching `erp-kit-app-*`)
+   - Module directory (e.g., `{MODULE_ROOT}/{MODULE_NAME}/`) → **Module workflow** (skills matching `erp-kit-module-*`)
 
 If the user names a specific app or module, confirm the path. If ambiguous, check both directories.
 

package/src/commands/app/index.ts

@@ -1,14 +1,18 @@
+import path from "node:path";
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
 import { runCheck } from "../check";
 import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
-import { runScaffold, APP_TYPES, type ScaffoldType } from "../scaffold";
+import { runGenerateDoc, APP_DOC_TYPES, type DocType } from "../generate-doc";
+import { runGenerateAppCode } from "../../generator/generate-app-code";
+import { runInitAppWithReadme } from "../init-module";
+import { executeCommand, success, silentFailure } from "../lib/command-result";
 
 const cwd = process.cwd();
 
-const rootArgs = z.object({
-  root: arg(z.string(), {
-    alias: "r",
+const pathArgs = z.object({
+  path: arg(z.string(), {
+    alias: "p",
     description: "Path to app-compose directory",
   }),
 });
@@ -16,50 +20,89 @@ const rootArgs = z.object({
 const checkCommand = defineCommand({
   name: "check",
   description: "Validate app docs against schemas",
-  args: rootArgs,
-  run: async (args) => {
-    const exitCode = await runCheck({ appRoot: args.root }, cwd);
-    process.exit(exitCode);
+  args: pathArgs,
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runCheck({ appRoot: args.path }, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 
 const syncCheckCommand = defineCommand({
   name: "sync-check",
   description: "Validate source <-> doc correspondence",
-  args: rootArgs,
-  run: async (args) => {
-    const result = await runSyncCheck({ appRoot: args.root }, cwd);
-    console.log(formatSyncCheckReport(result));
-    process.exit(result.exitCode);
+  args: pathArgs,
+  run: (args) => {
+    return executeCommand(async () => {
+      const result = await runSyncCheck({ appRoot: args.path }, cwd);
+      console.log(formatSyncCheckReport(result));
+      return result.exitCode === 0 ? success() : silentFailure(result.exitCode);
+    });
   },
 });
 
-const scaffoldCommand = defineCommand({
-  name: "scaffold",
-  description: "Generate app doc from schema template",
-  args: rootArgs.extend({
-    type: arg(z.enum(APP_TYPES as unknown as [string, ...string[]]), {
+const initCommand = defineCommand({
+  name: "init",
+  description: "Bootstrap a new app with directory structure and README",
+  args: z.object({
+    name: arg(z.string(), {
       positional: true,
-      description: `Scaffold type (${APP_TYPES.join(", ")})`,
+      description: "App name",
     }),
-    parent: arg(z.string(), {
+    dir: arg(z.string(), {
       positional: true,
-      description: "App name",
+      description: "Parent directory where the app will be created",
+    }),
+  }),
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runInitAppWithReadme(args.name, args.dir, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+const docCommand = defineCommand({
+  name: "doc",
+  description: "Create a documentation file from a schema template",
+  args: pathArgs.extend({
+    type: arg(z.enum(APP_DOC_TYPES as unknown as [string, ...string[]]), {
+      positional: true,
+      description: `Doc type (${APP_DOC_TYPES.join(", ")})`,
     }),
     name: arg(z.string().optional(), {
       positional: true,
       description: "Item name (required for most types)",
     }),
   }),
-  run: async (args) => {
-    const exitCode = await runScaffold(
-      args.type as ScaffoldType,
-      args.parent,
-      args.name,
-      args.root,
-      cwd,
-    );
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runGenerateDoc(args.type as DocType, args.name, args.path, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+const codeCommand = defineCommand({
+  name: "code",
+  description: "Generate boilerplate source files from docs",
+  args: pathArgs,
+  run: (args) => {
+    return executeCommand(() => {
+      const appPath = path.resolve(cwd, args.path);
+      const exitCode = runGenerateAppCode(appPath);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+const generateCommand = defineCommand({
+  name: "generate",
+  description: "Generate docs and code for an app",
+  subCommands: {
+    doc: docCommand,
+    code: codeCommand,
   },
 });
 
@@ -69,6 +112,7 @@ export const appCommand = defineCommand({
   subCommands: {
     check: checkCommand,
     "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
+    init: initCommand,
+    generate: generateCommand,
   },
 });

package/src/commands/check.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { buildCheckTargets } from "./check";
+import { buildCheckTargets } from "./lib/discovery";
 
 describe("buildCheckTargets", () => {
   it("generates module targets when modulesRoot is set", () => {

package/src/commands/check.ts

@@ -1,41 +1,8 @@
 import { runMdschema } from "../mdschema";
 import { ALL_SCHEMAS } from "../schemas";
-export interface CheckTarget {
-  glob: string;
-  schemaKey: string;
-}
-
-export function buildCheckTargets(config: {
-  modulesRoot?: string;
-  appRoot?: string;
-}): CheckTarget[] {
-  const targets: CheckTarget[] = [];
-
-  if (config.modulesRoot) {
-    const m = config.modulesRoot;
-    targets.push(
-      { glob: `${m}/[a-zA-Z]*/docs/features/*.md`, schemaKey: "feature" },
-      { glob: `${m}/[a-zA-Z]*/docs/commands/*.md`, schemaKey: "command" },
-      { glob: `${m}/[a-zA-Z]*/docs/models/*.md`, schemaKey: "model" },
-      { glob: `${m}/[a-zA-Z]*/docs/queries/*.md`, schemaKey: "query" },
-      { glob: `${m}/[a-zA-Z]*/README.md`, schemaKey: "module" },
-    );
-  }
+import { buildCheckTargets } from "./lib/discovery";
 
-  if (config.appRoot) {
-    const a = config.appRoot;
-    targets.push(
-      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "app" },
-      { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
-      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
-      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },
-      { glob: `${a}/[a-zA-Z]*/docs/screen/*.md`, schemaKey: "screen" },
-      { glob: `${a}/[a-zA-Z]*/docs/resolver/*.md`, schemaKey: "resolver" },
-    );
-  }
-
-  return targets;
-}
+export type { CheckTarget } from "./lib/discovery";
 
 export async function runCheck(
   config: { modulesRoot?: string; appRoot?: string },

package/src/commands/doc/index.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+import { executeCommand, success, silentFailure } from "../lib/command-result";
+import { runDocModules } from "./modules";
+import { runDocModule } from "./module";
+import { runDocSearch } from "./search";
+
+const formatArg = arg(z.enum(["text", "json"]).default("text"), {
+  alias: "f",
+  description: "Output format (text or json)",
+});
+
+const modulesCommand = defineCommand({
+  name: "modules",
+  description: "List all modules with capabilities overview",
+  args: z.object({
+    format: formatArg,
+  }),
+  run: (args) => {
+    return executeCommand(() => {
+      const exitCode = runDocModules(args.format);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+const moduleCommand = defineCommand({
+  name: "module",
+  description: "Show documentation for a specific module",
+  args: z.object({
+    name: arg(z.string(), {
+      positional: true,
+      description: "Module name",
+    }),
+    type: arg(z.string().optional(), {
+      positional: true,
+      description: "Doc type (command, query, model, feature)",
+    }),
+    docName: arg(z.string().optional(), {
+      positional: true,
+      description: "Doc name",
+    }),
+    format: formatArg,
+  }),
+  run: (args) => {
+    return executeCommand(() => {
+      const exitCode = runDocModule(args.name, args.type, args.docName, args.format);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+const searchCommand = defineCommand({
+  name: "search",
+  description: "Search across all module documentation",
+  args: z.object({
+    query: arg(z.string(), {
+      positional: true,
+      description: "Search query",
+    }),
+    type: arg(z.string().optional(), {
+      alias: "t",
+      description: "Filter by doc type (command, query, model, feature, readme)",
+    }),
+    format: formatArg,
+  }),
+  run: (args) => {
+    return executeCommand(() => {
+      const exitCode = runDocSearch(args.query, args.type, args.format);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
+export const docCommand = defineCommand({
+  name: "doc",
+  description: "Browse module documentation",
+  subCommands: {
+    modules: modulesCommand,
+    module: moduleCommand,
+    search: searchCommand,
+  },
+});

package/src/commands/doc/module.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { runDocModule } from "./module";
+
+describe("runDocModule", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("outputs README and available docs for a known module", () => {
+    const logs: string[] = [];
+    vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization");
+    expect(exitCode).toBe(0);
+
+    const output = logs.join("\n");
+    expect(output).toContain("## Overview");
+    expect(output).toContain("## Available Documentation");
+    expect(output).toContain("CreateCompany");
+    expect(output).toContain("GetCompany");
+    expect(output).toContain("Company");
+  });
+
+  it("outputs raw doc content for a specific command", () => {
+    const logs: string[] = [];
+    vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization", "command", "CreateCompany");
+    expect(exitCode).toBe(0);
+
+    const output = logs.join("\n");
+    expect(output).toContain("# CreateCompany");
+    expect(output).toContain("## Overview");
+    expect(output).toContain("## Business Rules");
+    expect(output).toContain("## Error Scenarios");
+  });
+
+  it("returns error for unknown module", () => {
+    const errors: string[] = [];
+    vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+      errors.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("nonexistent");
+    expect(exitCode).toBe(1);
+
+    const output = errors.join("\n");
+    expect(output).toContain("Module not found: nonexistent");
+    expect(output).toContain("Available modules:");
+  });
+
+  it("returns error for unknown doc type", () => {
+    const errors: string[] = [];
+    vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+      errors.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization", "invalid", "Foo");
+    expect(exitCode).toBe(1);
+
+    const output = errors.join("\n");
+    expect(output).toContain("Unknown doc type: invalid");
+    expect(output).toContain("Available types:");
+  });
+
+  it("outputs valid JSON for module detail with --format json", () => {
+    const logs: string[] = [];
+    vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization", undefined, undefined, "json");
+    expect(exitCode).toBe(0);
+
+    const parsed = JSON.parse(logs.join("\n")) as Record<string, unknown>;
+    expect(parsed).toHaveProperty("module", "organization");
+    expect(parsed).toHaveProperty("readme");
+    expect(parsed).toHaveProperty("docs");
+    expect(typeof parsed.readme).toBe("string");
+    const docs = parsed.docs as Record<string, string[]>;
+    expect(docs.command.length).toBeGreaterThan(0);
+  });
+
+  it("outputs valid JSON for specific command with --format json", () => {
+    const logs: string[] = [];
+    vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization", "command", "CreateCompany", "json");
+    expect(exitCode).toBe(0);
+
+    const parsed = JSON.parse(logs.join("\n")) as Record<string, unknown>;
+    expect(parsed).toHaveProperty("module", "organization");
+    expect(parsed).toHaveProperty("type", "command");
+    expect(parsed).toHaveProperty("name", "CreateCompany");
+    expect(parsed).toHaveProperty("content");
+    expect(typeof parsed.content).toBe("string");
+    expect(parsed.content as string).toContain("# CreateCompany");
+  });
+
+  it("returns error for unknown doc name", () => {
+    const errors: string[] = [];
+    vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+      errors.push(args.map(String).join(" "));
+    });
+
+    const exitCode = runDocModule("organization", "command", "Nonexistent");
+    expect(exitCode).toBe(1);
+
+    const output = errors.join("\n");
+    expect(output).toContain("Doc not found: organization/command/Nonexistent");
+    expect(output).toContain("Available commands:");
+  });
+});

package/src/commands/doc/module.ts

@@ -0,0 +1,114 @@
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { PACKAGE_ROOT } from "../../util";
+import { MODULE_PATHS } from "../lib/paths";
+
+const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
+const EXCLUDED_DIRS = new Set(["shared", "testing"]);
+
+const DOC_TYPE_MAP: Record<string, string> = {
+  command: MODULE_PATHS.docs.commands,
+  query: MODULE_PATHS.docs.queries,
+  model: MODULE_PATHS.docs.models,
+  feature: MODULE_PATHS.docs.features,
+};
+
+function listDocNames(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md"))
+    .map((f) => f.replace(/\.md$/, ""))
+    .sort();
+}
+
+function formatDocList(type: string, names: string[]): string {
+  if (names.length === 0) return "";
+  return `${type}: ${names.join(", ")}`;
+}
+
+export function runDocModule(
+  moduleName: string,
+  docType?: string,
+  docName?: string,
+  format = "text",
+): number {
+  if (!existsSync(MODULES_DIR) || EXCLUDED_DIRS.has(moduleName)) {
+    console.error(`Module not found: ${moduleName}`);
+    return 1;
+  }
+
+  const modDir = join(MODULES_DIR, moduleName);
+  if (!existsSync(modDir)) {
+    console.error(`Module not found: ${moduleName}`);
+    const available = readdirSync(MODULES_DIR, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name))
+      .map((d) => d.name)
+      .sort();
+    console.error(`Available modules: ${available.join(", ")}`);
+    return 1;
+  }
+
+  // Level 3: specific doc
+  if (docType && docName) {
+    const docSubdir = DOC_TYPE_MAP[docType];
+    if (!docSubdir) {
+      console.error(`Unknown doc type: ${docType}`);
+      console.error(`Available types: ${Object.keys(DOC_TYPE_MAP).join(", ")}`);
+      return 1;
+    }
+
+    const docPath = join(modDir, docSubdir, `${docName}.md`);
+    if (!existsSync(docPath)) {
+      console.error(`Doc not found: ${moduleName}/${docType}/${docName}`);
+      const available = listDocNames(join(modDir, docSubdir));
+      if (available.length > 0) {
+        console.error(`Available ${docType}s: ${available.join(", ")}`);
+      } else {
+        console.error(`No ${docType} docs found for ${moduleName}`);
+      }
+      return 1;
+    }
+
+    const content = readFileSync(docPath, "utf-8");
+    if (format === "json") {
+      console.log(
+        JSON.stringify({ module: moduleName, type: docType, name: docName, content }, null, 2),
+      );
+    } else {
+      console.log(content);
+    }
+    return 0;
+  }
+
+  // Level 2: full module detail
+  const readmePath = join(modDir, "README.md");
+  const readme = existsSync(readmePath) ? readFileSync(readmePath, "utf-8") : "";
+
+  const docs: Record<string, string[]> = {};
+  for (const [type, subdir] of Object.entries(DOC_TYPE_MAP)) {
+    const names = listDocNames(join(modDir, subdir));
+    if (names.length > 0) docs[type] = names;
+  }
+
+  if (format === "json") {
+    console.log(JSON.stringify({ module: moduleName, readme, docs }, null, 2));
+  } else {
+    if (readme) {
+      console.log(readme);
+    } else {
+      console.log(`# ${moduleName}\n\nNo README found.\n`);
+    }
+
+    const sections: string[] = [];
+    for (const [type, names] of Object.entries(docs)) {
+      sections.push(formatDocList(type, names));
+    }
+
+    if (sections.length > 0) {
+      console.log("\n## Available Documentation\n");
+      console.log(sections.join("\n"));
+    }
+  }
+
+  return 0;
+}