@guiho/xdocs 0.1.0

package/library/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { XDocsCliOptions, XDocsConfig, XDocsRawConfig } from './types.js';
+/** Discover the xdocs.config.toml file. */
+export declare const discoverConfig: (cwd: string, explicitPath?: string) => Promise<{
+    path?: string;
+    raw?: XDocsRawConfig;
+}>;
+/** Load and normalize the xdocs configuration. */
+export declare const loadConfig: (options: XDocsCliOptions) => Promise<XDocsConfig>;
+/** Load config if it exists, otherwise return defaults. */
+export declare const loadConfigOrDefaults: (options: XDocsCliOptions) => Promise<XDocsConfig>;
+/** Normalize raw TOML config into validated XDocsConfig. */
+export declare const normalizeConfig: (raw: XDocsRawConfig, cwd: string, configPath?: string) => XDocsConfig;
+/** Create a default config object for a given cwd. */
+export declare const defaultConfig: (cwd: string) => XDocsConfig;
+/** Generate the default xdocs.config.toml content. */
+export declare const createDefaultConfigContent: (cwd: string) => string;
+/** Write the default xdocs.config.toml to disk. */
+export declare const writeDefaultConfig: (cwd: string, overwrite?: boolean) => Promise<string>;
+/** Resolve a path relative to cwd if not absolute. */
+export declare const resolvePath: (cwd: string, path: string) => string;
+//# sourceMappingURL=config.d.ts.map

package/library/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../source/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAe,eAAe,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAQ3F,2CAA2C;AAC3C,eAAO,MAAM,cAAc,GAAU,KAAK,MAAM,EAAE,eAAe,MAAM,KAAG,OAAO,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,cAAc,CAAA;CAAE,CAaxH,CAAA;AAED,kDAAkD;AAClD,eAAO,MAAM,UAAU,GAAU,SAAS,eAAe,KAAG,OAAO,CAAC,WAAW,CAS9E,CAAA;AAED,2DAA2D;AAC3D,eAAO,MAAM,oBAAoB,GAAU,SAAS,eAAe,KAAG,OAAO,CAAC,WAAW,CAOxF,CAAA;AAED,4DAA4D;AAC5D,eAAO,MAAM,eAAe,GAAI,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,aAAa,MAAM,KAAG,WA6BvF,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,KAAG,WAO1C,CAAA;AAEF,sDAAsD;AACtD,eAAO,MAAM,0BAA0B,GAAI,KAAK,MAAM,KAAG,MAiBxD,CAAA;AAED,mDAAmD;AACnD,eAAO,MAAM,kBAAkB,GAAU,KAAK,MAAM,EAAE,mBAAiB,KAAG,OAAO,CAAC,MAAM,CASvF,CAAA;AAuBD,sDAAsD;AACtD,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,MAAM,MAAM,WACP,CAAA"}

package/library/config.js

@@ -0,0 +1,126 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, isAbsolute, resolve } from 'node:path';
+import { parse as parseToml } from 'smol-toml';
+import { XDocsError } from './errors.js';
+const DEFAULT_EXTENSIONS = ['.docs.md', '.xdocs.md'];
+const DEFAULT_EXCLUDE = ['node_modules', '.git', 'dist', 'build', 'library', 'bin', 'bundle'];
+const DEFAULT_AI_MODE = 'prompt';
+const CONFIG_FILENAME = 'xdocs.config.toml';
+/** Discover the xdocs.config.toml file. */
+export const discoverConfig = async (cwd, explicitPath) => {
+    if (explicitPath) {
+        const configPath = resolvePath(cwd, explicitPath);
+        return { path: configPath, raw: await readConfigFile(configPath) };
+    }
+    const rootPath = resolve(cwd, CONFIG_FILENAME);
+    if (existsSync(rootPath))
+        return { path: rootPath, raw: await readConfigFile(rootPath) };
+    const nestedPath = resolve(cwd, 'config', CONFIG_FILENAME);
+    if (existsSync(nestedPath))
+        return { path: nestedPath, raw: await readConfigFile(nestedPath) };
+    return {};
+};
+/** Load and normalize the xdocs configuration. */
+export const loadConfig = async (options) => {
+    const cwd = resolve(options.cwd);
+    const discovered = await discoverConfig(cwd, options.config);
+    if (!discovered.raw) {
+        throw new XDocsError(`xdocs configuration not found. Run \`xdocs init\` to create one.`);
+    }
+    return normalizeConfig(discovered.raw, cwd, discovered.path);
+};
+/** Load config if it exists, otherwise return defaults. */
+export const loadConfigOrDefaults = async (options) => {
+    const cwd = resolve(options.cwd);
+    const discovered = await discoverConfig(cwd, options.config);
+    if (!discovered.raw)
+        return defaultConfig(cwd);
+    return normalizeConfig(discovered.raw, cwd, discovered.path);
+};
+/** Normalize raw TOML config into validated XDocsConfig. */
+export const normalizeConfig = (raw, cwd, configPath) => {
+    if (raw.schema !== undefined && raw.schema !== 1) {
+        throw new XDocsError('Unsupported configuration schema. Expected `schema = 1`.');
+    }
+    const aiMode = raw.ai?.mode;
+    if (aiMode !== undefined && aiMode !== 'prompt' && aiMode !== 'auto') {
+        throw new XDocsError(`Invalid ai.mode: "${aiMode}". Expected "prompt" or "auto".`);
+    }
+    const extensions = raw.extensions?.supported ?? DEFAULT_EXTENSIONS;
+    if (!Array.isArray(extensions) || extensions.some((ext) => typeof ext !== 'string')) {
+        throw new XDocsError('Invalid extensions.supported. Expected an array of strings.');
+    }
+    const exclude = raw.scan?.exclude ?? DEFAULT_EXCLUDE;
+    if (!Array.isArray(exclude) || exclude.some((dir) => typeof dir !== 'string')) {
+        throw new XDocsError('Invalid scan.exclude. Expected an array of strings.');
+    }
+    return {
+        schema: 1,
+        cwd,
+        configPath,
+        extensions: { supported: extensions },
+        ai: { mode: aiMode ?? DEFAULT_AI_MODE },
+        scan: { exclude },
+        project: { name: raw.project?.name ?? basename(cwd) },
+    };
+};
+/** Create a default config object for a given cwd. */
+export const defaultConfig = (cwd) => ({
+    schema: 1,
+    cwd,
+    extensions: { supported: DEFAULT_EXTENSIONS },
+    ai: { mode: DEFAULT_AI_MODE },
+    scan: { exclude: DEFAULT_EXCLUDE },
+    project: { name: basename(cwd) },
+});
+/** Generate the default xdocs.config.toml content. */
+export const createDefaultConfigContent = (cwd) => {
+    const name = basename(cwd);
+    return `schema = 1
+
+[extensions]
+supported = [".docs.md", ".xdocs.md"]
+
+[ai]
+mode = "prompt"
+
+[scan]
+exclude = ["node_modules", ".git", "dist", "build", "library", "bin", "bundle"]
+
+[project]
+name = "${name}"
+`;
+};
+/** Write the default xdocs.config.toml to disk. */
+export const writeDefaultConfig = async (cwd, overwrite = false) => {
+    const path = resolve(cwd, CONFIG_FILENAME);
+    if (existsSync(path) && !overwrite) {
+        throw new XDocsError(`Configuration already exists: ${path}`);
+    }
+    await writeFile(path, createDefaultConfigContent(cwd), 'utf8');
+    return path;
+};
+/** Read and parse a TOML config file. */
+const readConfigFile = async (path) => {
+    if (!existsSync(path))
+        throw new XDocsError(`Configuration file not found: ${path}`);
+    const content = await readFile(path, 'utf8');
+    let parsed;
+    try {
+        parsed = parseToml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new XDocsError(`Invalid TOML in configuration file: ${path}\n${message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new XDocsError(`Configuration file must contain a TOML object: ${path}`);
+    }
+    return parsed;
+};
+/** Resolve a path relative to cwd if not absolute. */
+export const resolvePath = (cwd, path) => isAbsolute(path) ? path : resolve(cwd, path);

package/library/discovery.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { XDocsConfig, XDocsFile, XDocsScanResult } from './types.js';
+/** Scan the project for xdocs files matching configured extensions. */
+export declare const scanProject: (config: XDocsConfig) => Promise<XDocsScanResult>;
+/** Check if a file path matches any of the configured xdocs extensions. */
+export declare const isXDocsFile: (filePath: string, extensions: string[]) => boolean;
+/** Scan a specific directory (not recursive) for xdocs files. */
+export declare const scanDirectory: (dirPath: string, config: XDocsConfig) => Promise<XDocsFile[]>;
+/** List all files in a directory (non-recursive). */
+export declare const listDirectoryFiles: (dirPath: string, config: XDocsConfig) => Promise<string[]>;
+//# sourceMappingURL=discovery.d.ts.map

package/library/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../source/discovery.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGzE,uEAAuE;AACvE,eAAO,MAAM,WAAW,GAAU,QAAQ,WAAW,KAAG,OAAO,CAAC,eAAe,CA2C9E,CAAA;AAED,2EAA2E;AAC3E,eAAO,MAAM,WAAW,GAAI,UAAU,MAAM,EAAE,YAAY,MAAM,EAAE,KAAG,OAOpE,CAAA;AAmCD,iEAAiE;AACjE,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,EAAE,QAAQ,WAAW,KAAG,OAAO,CAAC,SAAS,EAAE,CAqB7F,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,GAAU,SAAS,MAAM,EAAE,QAAQ,WAAW,KAAG,OAAO,CAAC,MAAM,EAAE,CAiB/F,CAAA"}

package/library/discovery.js

@@ -0,0 +1,118 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { parseXDocsFile } from './metadata.js';
+/** Scan the project for xdocs files matching configured extensions. */
+export const scanProject = async (config) => {
+    const xdocsFiles = [];
+    const allDirectories = [];
+    const coveredDirectories = new Set();
+    let totalFiles = 0;
+    await walkDirectory(config.cwd, config, async (filePath, dir) => {
+        totalFiles += 1;
+        if (isXDocsFile(filePath, config.extensions.supported)) {
+            const file = await parseXDocsFile(filePath, config.cwd);
+            xdocsFiles.push(file);
+            coveredDirectories.add(dir);
+        }
+    }, allDirectories);
+    // The root XDOCS.md is always recognized
+    const rootXDocs = join(config.cwd, 'XDOCS.md');
+    const rootAlreadyFound = xdocsFiles.some((f) => f.path === rootXDocs);
+    if (!rootAlreadyFound) {
+        try {
+            const rootStat = await stat(rootXDocs);
+            if (rootStat.isFile()) {
+                const file = await parseXDocsFile(rootXDocs, config.cwd);
+                xdocsFiles.push(file);
+                coveredDirectories.add(config.cwd);
+            }
+        }
+        catch {
+            // Root XDOCS.md does not exist, that's fine
+        }
+    }
+    const uncoveredPaths = allDirectories.filter((dir) => !coveredDirectories.has(dir));
+    return {
+        totalFiles,
+        totalDirectories: allDirectories.length,
+        coveredDirectories: coveredDirectories.size,
+        uncoveredDirectories: uncoveredPaths.length,
+        xdocsFiles,
+        uncoveredPaths,
+    };
+};
+/** Check if a file path matches any of the configured xdocs extensions. */
+export const isXDocsFile = (filePath, extensions) => {
+    const lower = filePath.toLowerCase();
+    // Root XDOCS.md is always recognized
+    if (lower.endsWith('/xdocs.md') || lower.endsWith('\\xdocs.md'))
+        return true;
+    return extensions.some((ext) => lower.endsWith(ext.toLowerCase()));
+};
+/** Recursively walk a directory, skipping excluded directories. */
+const walkDirectory = async (dir, config, onFile, allDirectories) => {
+    allDirectories.push(dir);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (isExcluded(entry.name, config.scan.exclude))
+                continue;
+            await walkDirectory(fullPath, config, onFile, allDirectories);
+        }
+        else if (entry.isFile()) {
+            await onFile(fullPath, dir);
+        }
+    }
+};
+/** Check if a directory name is in the exclude list. */
+const isExcluded = (name, exclude) => exclude.includes(name) || name.startsWith('.');
+/** Scan a specific directory (not recursive) for xdocs files. */
+export const scanDirectory = async (dirPath, config) => {
+    const files = [];
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const fullPath = join(dirPath, entry.name);
+        if (isXDocsFile(fullPath, config.extensions.supported)) {
+            const file = await parseXDocsFile(fullPath, config.cwd);
+            files.push(file);
+        }
+    }
+    return files;
+};
+/** List all files in a directory (non-recursive). */
+export const listDirectoryFiles = async (dirPath, config) => {
+    const result = [];
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return result;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (isExcluded(entry.name, config.scan.exclude))
+            continue;
+        result.push(relative(config.cwd, join(dirPath, entry.name)));
+    }
+    return result;
+};

package/library/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export declare class XDocsError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare const invariant: (condition: unknown, message: string) => asserts condition;
+//# sourceMappingURL=errors.d.ts.map

package/library/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../source/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAEb,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI;CAK1C;AAED,eAAO,MAAM,SAAS,GAAI,WAAW,OAAO,EAAE,SAAS,MAAM,KAAG,QAAQ,SAEvE,CAAA"}

package/library/errors.js

@@ -0,0 +1,15 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export class XDocsError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = 'XDocsError';
+        this.exitCode = exitCode;
+    }
+}
+export const invariant = (condition, message) => {
+    if (!condition)
+        throw new XDocsError(message);
+};

package/library/flags.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { XDocsParsedArgs } from './types.js';
+/**
+ * Parse raw CLI arguments into a structured object.
+ *
+ * Supports:
+ * - Commands as the first non-flag token: `xdocs scan`
+ * - Long flags with value: `--name=write` or `--name write`
+ * - Long boolean flags: `--verbose`
+ * - Short flags: `-h`, `-v`
+ * - List values as comma-separated: `--extensions=.docs.md,.xdocs.md`
+ * - Positional arguments after the command
+ */
+export declare const parseArgs: (rawArgs: string[]) => XDocsParsedArgs;
+/** Extract a string flag value or undefined. */
+export declare const stringFlag: (flags: Record<string, string | boolean | string[]>, key: string) => string | undefined;
+/** Extract a boolean flag value. */
+export declare const booleanFlag: (flags: Record<string, string | boolean | string[]>, key: string) => boolean;
+/** Extract a list flag value or undefined. */
+export declare const listFlag: (flags: Record<string, string | boolean | string[]>, key: string) => string[] | undefined;
+//# sourceMappingURL=flags.d.ts.map

package/library/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../source/flags.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAmBjD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,MAAM,EAAE,KAAG,eA4D7C,CAAA;AAUD,gDAAgD;AAChD,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,EAAE,KAAK,MAAM,KAAG,MAAM,GAAG,SAGrG,CAAA;AAED,oCAAoC;AACpC,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,EAAE,KAAK,MAAM,KAAG,OAE7F,CAAA;AAED,8CAA8C;AAC9C,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,EAAE,KAAK,MAAM,KAAG,MAAM,EAAE,GAAG,SAGrG,CAAA"}

package/library/flags.js

@@ -0,0 +1,96 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import { XDocsError } from './errors.js';
+const booleanFlags = new Set([
+    'help',
+    'version',
+    'verbose',
+]);
+const shortFlagMap = {
+    '-h': '--help',
+    '-v': '--version',
+};
+const listFlags = new Set([
+    'extensions',
+    'exclude',
+]);
+/**
+ * Parse raw CLI arguments into a structured object.
+ *
+ * Supports:
+ * - Commands as the first non-flag token: `xdocs scan`
+ * - Long flags with value: `--name=write` or `--name write`
+ * - Long boolean flags: `--verbose`
+ * - Short flags: `-h`, `-v`
+ * - List values as comma-separated: `--extensions=.docs.md,.xdocs.md`
+ * - Positional arguments after the command
+ */
+export const parseArgs = (rawArgs) => {
+    const args = expandShortFlags(rawArgs);
+    const flags = {};
+    const positionals = [];
+    let command;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === undefined)
+            continue;
+        if (token === '--') {
+            positionals.push(...args.slice(index + 1).filter((a) => a !== undefined));
+            break;
+        }
+        if (token.startsWith('--')) {
+            const withoutPrefix = token.slice(2);
+            const equalsIndex = withoutPrefix.indexOf('=');
+            const rawKey = equalsIndex >= 0 ? withoutPrefix.slice(0, equalsIndex) : withoutPrefix;
+            if (booleanFlags.has(rawKey)) {
+                flags[normalizeKey(rawKey)] = true;
+                continue;
+            }
+            const value = equalsIndex >= 0
+                ? withoutPrefix.slice(equalsIndex + 1)
+                : (args[index + 1] !== undefined && !args[index + 1]?.startsWith('-'))
+                    ? args[++index] ?? ''
+                    : '';
+            if (!value)
+                throw new XDocsError(`Missing value for --${rawKey}`);
+            const key = normalizeKey(rawKey);
+            if (listFlags.has(rawKey)) {
+                const values = value.split(',').filter(Boolean);
+                const current = flags[key];
+                flags[key] = [...(Array.isArray(current) ? current : []), ...values];
+                continue;
+            }
+            flags[key] = value;
+            continue;
+        }
+        if (token.startsWith('-') && token.length > 1) {
+            throw new XDocsError(`Unknown short flag: ${token}`);
+        }
+        if (command === undefined) {
+            command = token;
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    return { command, positionals, flags };
+};
+/** Convert kebab-case to camelCase. */
+const normalizeKey = (key) => key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+/** Expand short flags like -h to --help. */
+const expandShortFlags = (rawArgs) => rawArgs.map((token) => shortFlagMap[token] ?? token);
+/** Extract a string flag value or undefined. */
+export const stringFlag = (flags, key) => {
+    const value = flags[key];
+    return typeof value === 'string' ? value : undefined;
+};
+/** Extract a boolean flag value. */
+export const booleanFlag = (flags, key) => {
+    return flags[key] === true;
+};
+/** Extract a list flag value or undefined. */
+export const listFlag = (flags, key) => {
+    const value = flags[key];
+    return Array.isArray(value) ? value : undefined;
+};

package/library/guiho-xdocs-bin.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export {};
+//# sourceMappingURL=guiho-xdocs-bin.d.ts.map

package/library/guiho-xdocs-bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guiho-xdocs-bin.d.ts","sourceRoot":"","sources":["../source/guiho-xdocs-bin.ts"],"names":[],"mappings":";AACA;;GAEG"}

package/library/guiho-xdocs-bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import { runCliWithErrorHandling } from './guiho-xdocs.js';
+await runCliWithErrorHandling();

package/library/guiho-xdocs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { XDocsError, invariant } from './errors.js';
+export type { XDocsAiMode, XDocsCliOptions, XDocsCommand, XDocsConfig, XDocsFile, XDocsFormat, XDocsMetadata, XDocsParsedArgs, XDocsPrompt, XDocsPromptName, XDocsRawConfig, XDocsScanResult, XDocsTreeNode, XDocsTreeValidation, } from './types.js';
+export { parseArgs, stringFlag, booleanFlag, listFlag } from './flags.js';
+export { createDefaultConfigContent, defaultConfig, discoverConfig, loadConfig, loadConfigOrDefaults, normalizeConfig, resolvePath, writeDefaultConfig, } from './config.js';
+export { isXDocsFile, listDirectoryFiles, scanDirectory, scanProject } from './discovery.js';
+export { extractFrontmatter, parseXDocsFile, validateMetadata } from './metadata.js';
+export { buildTree, renderTree, renderTreeMarkdown, validateTree } from './tree.js';
+export { readPackageVersion, showCommandHelp, showHelp, showVersion } from './help.js';
+export { getPrompt, getPromptNames, prompts } from './prompts.js';
+export { runCli, runCliWithErrorHandling } from './cli.js';
+//# sourceMappingURL=guiho-xdocs.d.ts.map

package/library/guiho-xdocs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guiho-xdocs.d.ts","sourceRoot":"","sources":["../source/guiho-xdocs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGnD,YAAY,EACV,WAAW,EACX,eAAe,EACf,YAAY,EACZ,WAAW,EACX,SAAS,EACT,WAAW,EACX,aAAa,EACb,eAAe,EACf,WAAW,EACX,eAAe,EACf,cAAc,EACd,eAAe,EACf,aAAa,EACb,mBAAmB,GACpB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGzE,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,cAAc,EACd,UAAU,EACV,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,kBAAkB,GACnB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAG5F,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAGpF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAGnF,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAGtF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGjE,OAAO,EAAE,MAAM,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA"}

package/library/guiho-xdocs.js

@@ -0,0 +1,21 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+// Errors
+export { XDocsError, invariant } from './errors.js';
+// Flags
+export { parseArgs, stringFlag, booleanFlag, listFlag } from './flags.js';
+// Config
+export { createDefaultConfigContent, defaultConfig, discoverConfig, loadConfig, loadConfigOrDefaults, normalizeConfig, resolvePath, writeDefaultConfig, } from './config.js';
+// Discovery
+export { isXDocsFile, listDirectoryFiles, scanDirectory, scanProject } from './discovery.js';
+// Metadata
+export { extractFrontmatter, parseXDocsFile, validateMetadata } from './metadata.js';
+// Tree
+export { buildTree, renderTree, renderTreeMarkdown, validateTree } from './tree.js';
+// Help
+export { readPackageVersion, showCommandHelp, showHelp, showVersion } from './help.js';
+// Prompts
+export { getPrompt, getPromptNames, prompts } from './prompts.js';
+// CLI
+export { runCli, runCliWithErrorHandling } from './cli.js';

package/library/help.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+/** Read the package version from package.json. */
+export declare const readPackageVersion: () => string;
+/** Show the xdocs version string. */
+export declare const showVersion: () => string;
+/** Show the main help text. */
+export declare const showHelp: () => string;
+/** Show help for a specific command. */
+export declare const showCommandHelp: (command: string) => string;
+//# sourceMappingURL=help.d.ts.map

package/library/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../source/help.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,kDAAkD;AAClD,eAAO,MAAM,kBAAkB,QAAO,MAQrC,CAAA;AAED,qCAAqC;AACrC,eAAO,MAAM,WAAW,QAAO,MAAyC,CAAA;AAExE,+BAA+B;AAC/B,eAAO,MAAM,QAAQ,QAAO,MA6BpB,CAAA;AAER,wCAAwC;AACxC,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAIjD,CAAA"}