@williamthorsen/kb 0.0.0 → 0.3.0

package/dist/esm/cli/commands/create.js

@@ -0,0 +1,111 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { create } from "../../create/create.js";
+import { runSetDefault } from "./set-default.js";
+export const CREATE_HELP = `Usage: kb create [options]
+
+Scaffold a new knowledge base in the current directory and register it in the user-global kb.yaml registry.
+
+When the registry has no default knowledge base, the new store becomes the default.
+If other knowledge bases are already registered, you are prompted to choose one (or set it later with "kb set-default").
+
+Creates:
+  .kb/config.yaml        check configuration (commented; defaults apply)
+  .kb/tag-aliases.yaml   tag-alias map (empty)
+  content/, content/events/
+
+Options:
+  --name <name>   Registry name for the store. Defaults to the directory name.
+  --no-register   Scaffold without writing the kb.yaml registry entry.
+  -h, --help      Show this help.
+
+Exit codes:
+  0  store created
+  2  usage error, an existing .kb/ in the directory, or an already-registered name
+`;
+export async function runCreate(input) {
+    let options;
+    try {
+        options = parseCreateArgs(input.argv);
+    }
+    catch (error) {
+        return buildUsageError(error);
+    }
+    if (options.help) {
+        return { exitCode: 0, stdout: CREATE_HELP, stderr: '' };
+    }
+    const registryPath = join(input.home ?? homedir(), '.agents', 'kb.yaml');
+    const base = { targetDir: input.cwd, ...(options.name !== null && { name: options.name }) };
+    const outcome = options.noRegister
+        ? await create({ ...base, register: false })
+        : await create({ ...base, register: true, registryPath });
+    if (!outcome.ok) {
+        return { exitCode: 2, stdout: '', stderr: `kb create: ${outcome.message}\n` };
+    }
+    const summary = formatCreated(outcome.created, registryPath);
+    if (outcome.created.defaultKb !== 'needs-selection') {
+        return { exitCode: 0, stdout: summary, stderr: '' };
+    }
+    if (input.selectKb === undefined) {
+        return { exitCode: 0, stdout: summary + UNSET_DEFAULT_HINT, stderr: '' };
+    }
+    const selection = await runSetDefault({
+        argv: [],
+        ...(input.home !== undefined && { home: input.home }),
+        selectKb: input.selectKb,
+    });
+    return { exitCode: 0, stdout: summary + selection.stdout, stderr: selection.stderr };
+}
+export function parseCreateArgs(argv) {
+    let name = null;
+    let noRegister = false;
+    let help = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
+        if (arg === '--no-register') {
+            noRegister = true;
+            continue;
+        }
+        if (arg === '--name') {
+            const next = argv[index + 1] ?? null;
+            if (next === null || next.startsWith('--')) {
+                throw new Error('--name requires a value');
+            }
+            name = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--name=')) {
+            const value = arg.slice('--name='.length);
+            if (value === '') {
+                throw new Error('--name requires a value');
+            }
+            name = value;
+            continue;
+        }
+        throw new Error(`unknown flag: ${arg}`);
+    }
+    return { name, noRegister, help };
+}
+const UNSET_DEFAULT_HINT = 'Multiple knowledge bases are registered and no default is set. Run `kb set-default` to choose one.\n';
+function buildUsageError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 2, stdout: '', stderr: `kb create: ${message}\n${CREATE_HELP}` };
+}
+function formatCreated(created, registryPath) {
+    const lines = [`Created knowledge base "${created.name}" at ${created.storePath}`];
+    for (const path of created.created) {
+        lines.push(`  ${path}`);
+    }
+    lines.push(created.registered ? `Registered in ${registryPath}` : 'Not registered (--no-register).');
+    if (created.defaultKb === 'set') {
+        lines.push('Set as the default knowledge base.');
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/esm/cli/commands/set-default.d.ts

@@ -0,0 +1,15 @@
+import type { SelectKbPrompt } from '../select-kb-prompt.js';
+import type { CommandOutput } from './check.js';
+export declare const SET_DEFAULT_HELP = "Usage: kb set-default [name] [options]\n\nSet, clear, or interactively choose the user-global default knowledge base \u2014\nthe top-level default_kb pointer in ~/.agents/kb.yaml.\n\n  kb set-default <name>   Set default_kb to the named registered KB.\n  kb set-default --none   Clear default_kb.\n  kb set-default          List the registered KBs and prompt for a choice\n                          (including a \"(none)\" option to clear).\n\nOptions:\n  --none        Clear the default knowledge base.\n  -h, --help    Show this help.\n\nExit codes:\n  0  default set or cleared, or the selection was cancelled\n  2  usage error, an unregistered name, no registered KBs, or no name supplied\n     when stdin is not interactive\n";
+export declare function runSetDefault(input: {
+    argv: readonly string[];
+    home?: string;
+    selectKb?: SelectKbPrompt;
+}): Promise<CommandOutput>;
+interface SetDefaultOptions {
+    name: string | null;
+    none: boolean;
+    help: boolean;
+}
+export declare function parseSetDefaultArgs(argv: readonly string[]): SetDefaultOptions;
+export {};

package/dist/esm/cli/commands/set-default.js

@@ -0,0 +1,123 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { tryLoadKbRegistry } from "../../discovery/load-registry.js";
+import { clearDefaultKb, setDefaultKb } from "../../discovery/set-default-kb.js";
+export const SET_DEFAULT_HELP = `Usage: kb set-default [name] [options]
+
+Set, clear, or interactively choose the user-global default knowledge base —
+the top-level default_kb pointer in ~/.agents/kb.yaml.
+
+  kb set-default <name>   Set default_kb to the named registered KB.
+  kb set-default --none   Clear default_kb.
+  kb set-default          List the registered KBs and prompt for a choice
+                          (including a "(none)" option to clear).
+
+Options:
+  --none        Clear the default knowledge base.
+  -h, --help    Show this help.
+
+Exit codes:
+  0  default set or cleared, or the selection was cancelled
+  2  usage error, an unregistered name, no registered KBs, or no name supplied
+     when stdin is not interactive
+`;
+export async function runSetDefault(input) {
+    let options;
+    try {
+        options = parseSetDefaultArgs(input.argv);
+    }
+    catch (error) {
+        return buildUsageError(error);
+    }
+    if (options.help) {
+        return { exitCode: 0, stdout: SET_DEFAULT_HELP, stderr: '' };
+    }
+    const home = input.home ?? homedir();
+    const registryPath = join(home, '.agents', 'kb.yaml');
+    const { config, error } = await tryLoadKbRegistry({ home });
+    if (error !== undefined) {
+        return { exitCode: 2, stdout: '', stderr: `kb set-default: ${error}\n` };
+    }
+    const entries = config.entries;
+    if (options.none) {
+        await clearDefaultKb({ registryPath });
+        return { exitCode: 0, stdout: 'The default knowledge base has been cleared.\n', stderr: '' };
+    }
+    if (options.name !== null) {
+        if (entries.length === 0) {
+            return { exitCode: 2, stdout: '', stderr: buildNoStoresMessage() };
+        }
+        if (entries.every((entry) => entry.name !== options.name)) {
+            return { exitCode: 2, stdout: '', stderr: buildNotRegisteredMessage(options.name, entries) };
+        }
+        await setDefaultKb({ registryPath, name: options.name });
+        return { exitCode: 0, stdout: buildSetConfirmation(options.name), stderr: '' };
+    }
+    if (input.selectKb === undefined) {
+        return {
+            exitCode: 2,
+            stdout: '',
+            stderr: `kb set-default: a knowledge base name is required when stdin is not interactive\n${SET_DEFAULT_HELP}`,
+        };
+    }
+    if (entries.length === 0) {
+        return { exitCode: 2, stdout: '', stderr: buildNoStoresMessage() };
+    }
+    const choice = await input.selectKb({
+        entries,
+        ...(config.defaultKb !== undefined && { currentDefaultName: config.defaultKb.name }),
+    });
+    if (choice.kind === 'cancel') {
+        return { exitCode: 0, stdout: 'No changes made.\n', stderr: '' };
+    }
+    if (choice.kind === 'none') {
+        await clearDefaultKb({ registryPath });
+        return { exitCode: 0, stdout: 'The default knowledge base has been cleared.\n', stderr: '' };
+    }
+    const chosen = entries[choice.index];
+    if (chosen === undefined) {
+        return { exitCode: 2, stdout: '', stderr: 'kb set-default: invalid selection\n' };
+    }
+    await setDefaultKb({ registryPath, name: chosen.name });
+    return { exitCode: 0, stdout: buildSetConfirmation(chosen.name), stderr: '' };
+}
+export function parseSetDefaultArgs(argv) {
+    let name = null;
+    let none = false;
+    let help = false;
+    for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
+        if (arg === '--none') {
+            none = true;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw new Error(`unknown flag: ${arg}`);
+        }
+        if (name !== null) {
+            throw new Error('set-default accepts at most one knowledge base name');
+        }
+        name = arg;
+    }
+    if (name !== null && none) {
+        throw new Error('a name cannot be combined with --none');
+    }
+    return { name, none, help };
+}
+function buildNoStoresMessage() {
+    return 'kb set-default: no knowledge bases registered; run `kb create` first\n';
+}
+function buildNotRegisteredMessage(name, entries) {
+    const names = entries.map((entry) => entry.name).join(', ');
+    return `kb set-default: "${name}" is not a registered knowledge base (registered: ${names})\n`;
+}
+function buildSetConfirmation(name) {
+    return `Default knowledge base has been set to "${name}".\n`;
+}
+function buildUsageError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 2, stdout: '', stderr: `kb set-default: ${message}\n${SET_DEFAULT_HELP}` };
+}

package/dist/esm/cli/format.d.ts

@@ -0,0 +1,24 @@
+import type { Finding } from '../types.js';
+export interface StoreRef {
+    name: string | null;
+    path: string;
+}
+export interface CheckSummary {
+    notes: number;
+    total: number;
+    errors: number;
+    warnings: number;
+}
+export type CheckScope = 'vault' | 'patterns' | 'vs';
+export declare function formatHuman(input: {
+    summary: CheckSummary;
+    findings: readonly Finding[];
+    targets: readonly string[];
+    scope: CheckScope;
+}): string;
+export declare function formatJson(input: {
+    store: StoreRef;
+    summary: CheckSummary;
+    findings: readonly Finding[];
+}): string;
+export declare function summarize(findings: readonly Finding[], noteCount: number): CheckSummary;

package/dist/esm/cli/format.js

@@ -0,0 +1,55 @@
+export function formatHuman(input) {
+    const { summary, findings, targets, scope } = input;
+    if (summary.notes === 0) {
+        return `${zeroMatchLine(scope, targets)}\n`;
+    }
+    if (findings.length === 0) {
+        return `✓ no findings (${summary.notes} notes checked)\n`;
+    }
+    const lines = [];
+    for (const [path, group] of groupByPath(findings)) {
+        lines.push(path);
+        for (const finding of group) {
+            const location = finding.line === undefined ? '' : ` (line ${finding.line})`;
+            lines.push(`  ${finding.severity} ${finding.rule}${location}: ${finding.message}`);
+        }
+    }
+    lines.push('', `${summary.total} findings (${summary.errors} errors, ${summary.warnings} warnings) in ${summary.notes} notes`);
+    return `${lines.join('\n')}\n`;
+}
+export function formatJson(input) {
+    return `${JSON.stringify({ store: input.store, summary: input.summary, findings: input.findings }, null, 2)}\n`;
+}
+export function summarize(findings, noteCount) {
+    let errors = 0;
+    let warnings = 0;
+    for (const finding of findings) {
+        if (finding.severity === 'error')
+            errors += 1;
+        else
+            warnings += 1;
+    }
+    return { notes: noteCount, total: findings.length, errors, warnings };
+}
+function groupByPath(findings) {
+    const groups = new Map();
+    for (const finding of findings) {
+        let group = groups.get(finding.path);
+        if (group === undefined) {
+            group = [];
+            groups.set(finding.path, group);
+        }
+        group.push(finding);
+    }
+    return groups;
+}
+function zeroMatchLine(scope, targets) {
+    switch (scope) {
+        case 'patterns':
+            return 'no notes matched the given paths (0 checked)';
+        case 'vs':
+            return 'no changed notes to check (0 checked)';
+        case 'vault':
+            return `no notes matched ${targets.join(', ')} (0 checked)`;
+    }
+}

package/dist/esm/cli/index.d.ts

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

package/dist/esm/cli/index.js

@@ -0,0 +1,25 @@
+import process from 'node:process';
+import { run } from "./run.js";
+import { readlineSelectKbPrompt } from "./select-kb-prompt.js";
+async function main() {
+    let output;
+    try {
+        const selectKb = process.stdin.isTTY ? readlineSelectKbPrompt : undefined;
+        output = await run({
+            argv: process.argv.slice(2),
+            cwd: process.cwd(),
+            ...(selectKb !== undefined && { selectKb }),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`kb: unexpected error: ${message}\n`);
+        process.exit(2);
+    }
+    if (output.stdout !== '')
+        process.stdout.write(output.stdout);
+    if (output.stderr !== '')
+        process.stderr.write(output.stderr);
+    process.exit(output.exitCode);
+}
+await main();

package/dist/esm/cli/run.d.ts

@@ -0,0 +1,9 @@
+import { type CommandOutput } from './commands/check.js';
+import type { SelectKbPrompt } from './select-kb-prompt.js';
+export declare const HELP = "Usage: kb <command> [options]\n\nCommands:\n  check        Validate a knowledge base, optionally scoped to selected notes.\n  create       Scaffold a new knowledge base and register it in the kb.yaml registry.\n  set-default  Set, clear, or choose the default knowledge base.\n\nRun \"kb <command> --help\" for command options.\n";
+export declare function run(input: {
+    argv: readonly string[];
+    cwd: string;
+    home?: string;
+    selectKb?: SelectKbPrompt;
+}): Promise<CommandOutput>;

package/dist/esm/cli/run.js

@@ -0,0 +1,37 @@
+import { runCheck } from "./commands/check.js";
+import { runCreate } from "./commands/create.js";
+import { runSetDefault } from "./commands/set-default.js";
+export const HELP = `Usage: kb <command> [options]
+
+Commands:
+  check        Validate a knowledge base, optionally scoped to selected notes.
+  create       Scaffold a new knowledge base and register it in the kb.yaml registry.
+  set-default  Set, clear, or choose the default knowledge base.
+
+Run "kb <command> --help" for command options.
+`;
+export async function run(input) {
+    const [command, ...rest] = input.argv;
+    if (command === undefined || command === '--help' || command === '-h') {
+        return { exitCode: 0, stdout: HELP, stderr: '' };
+    }
+    if (command === 'check') {
+        return runCheck({ argv: rest, cwd: input.cwd, ...(input.home !== undefined && { home: input.home }) });
+    }
+    if (command === 'create') {
+        return runCreate({
+            argv: rest,
+            cwd: input.cwd,
+            ...(input.home !== undefined && { home: input.home }),
+            ...(input.selectKb !== undefined && { selectKb: input.selectKb }),
+        });
+    }
+    if (command === 'set-default') {
+        return runSetDefault({
+            argv: rest,
+            ...(input.home !== undefined && { home: input.home }),
+            ...(input.selectKb !== undefined && { selectKb: input.selectKb }),
+        });
+    }
+    return { exitCode: 2, stdout: '', stderr: `kb: unknown command "${command}"\n${HELP}` };
+}

package/dist/esm/cli/select-kb-prompt.d.ts

@@ -0,0 +1,16 @@
+import type { KbRegistryEntry } from '../types.js';
+export type SelectKbChoice = {
+    kind: 'kb';
+    index: number;
+} | {
+    kind: 'none';
+} | {
+    kind: 'cancel';
+};
+export type SelectKbPrompt = (input: {
+    entries: readonly KbRegistryEntry[];
+    currentDefaultName?: string;
+}) => Promise<SelectKbChoice>;
+export declare function formatKbSelection(entries: readonly KbRegistryEntry[], currentDefaultName?: string): string;
+export declare function parseSelection(answer: string, kbCount: number): SelectKbChoice | null;
+export declare const readlineSelectKbPrompt: SelectKbPrompt;

package/dist/esm/cli/select-kb-prompt.js

@@ -0,0 +1,44 @@
+import process from 'node:process';
+import { createInterface } from 'node:readline';
+export function formatKbSelection(entries, currentDefaultName) {
+    const lines = ['Select the default knowledge base:'];
+    for (const [index, entry] of entries.entries()) {
+        const suffix = entry.name === currentDefaultName ? '  (current default)' : '';
+        lines.push(`  ${String(index + 1)}) ${entry.name}${suffix}`);
+    }
+    const noneSuffix = currentDefaultName === undefined ? '  (current)' : '';
+    lines.push(`  ${String(entries.length + 1)}) (none) — no default${noneSuffix}`);
+    return `${lines.join('\n')}\n`;
+}
+export function parseSelection(answer, kbCount) {
+    if (answer === '')
+        return { kind: 'cancel' };
+    const choice = Number(answer);
+    if (!Number.isInteger(choice))
+        return null;
+    if (choice >= 1 && choice <= kbCount)
+        return { kind: 'kb', index: choice - 1 };
+    if (choice === kbCount + 1)
+        return { kind: 'none' };
+    return null;
+}
+export const readlineSelectKbPrompt = async ({ entries, currentDefaultName }) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        process.stdout.write(formatKbSelection(entries, currentDefaultName));
+        const prompt = `Enter a number [1-${String(entries.length + 1)}], or press Enter to cancel: `;
+        let choice = parseSelection((await ask(rl, prompt)).trim(), entries.length);
+        while (choice === null) {
+            choice = parseSelection((await ask(rl, prompt)).trim(), entries.length);
+        }
+        return choice;
+    }
+    finally {
+        rl.close();
+    }
+};
+function ask(rl, query) {
+    return new Promise((resolve) => {
+        rl.question(query, resolve);
+    });
+}

package/dist/esm/cli/targeting/resolve-changed-paths.d.ts

@@ -0,0 +1,11 @@
+export type ChangedPathsResult = {
+    ok: true;
+    paths: string[];
+} | {
+    ok: false;
+    message: string;
+};
+export declare function resolveChangedPaths(input: {
+    storeRoot: string;
+    ref: string;
+}): ChangedPathsResult;

package/dist/esm/cli/targeting/resolve-changed-paths.js

@@ -0,0 +1,53 @@
+import { execFileSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { isRecord } from "../../type-guards.js";
+export function resolveChangedPaths(input) {
+    const { storeRoot, ref } = input;
+    const mergeBase = tryGit(storeRoot, ['merge-base', ref, 'HEAD']);
+    if (!mergeBase.ok) {
+        return { ok: false, message: `could not resolve ref "${ref}": ${mergeBase.message}` };
+    }
+    const toplevel = tryGit(storeRoot, ['rev-parse', '--show-toplevel']);
+    if (!toplevel.ok) {
+        return { ok: false, message: toplevel.message };
+    }
+    const diff = tryGit(storeRoot, [
+        'diff',
+        '--name-only',
+        '-z',
+        '--diff-filter=AMR',
+        '--find-renames',
+        mergeBase.stdout.trim(),
+        '--',
+        '.',
+    ]);
+    if (!diff.ok) {
+        return { ok: false, message: diff.message };
+    }
+    const realStoreRoot = realpathSync(storeRoot);
+    const repoRoot = toplevel.stdout.trim();
+    const paths = diff.stdout
+        .split('\0')
+        .filter((entry) => entry !== '')
+        .map((entry) => relative(realStoreRoot, join(repoRoot, entry)).split(sep).join('/'));
+    return { ok: true, paths };
+}
+function extractGitErrorMessage(error) {
+    if (isRecord(error) && typeof error.stderr === 'string' && error.stderr.trim() !== '') {
+        return error.stderr.trim();
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+function tryGit(storeRoot, args) {
+    try {
+        const stdout = execFileSync('git', ['-C', storeRoot, ...args], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return { ok: true, stdout };
+    }
+    catch (error) {
+        return { ok: false, message: extractGitErrorMessage(error) };
+    }
+}

package/dist/esm/cli/targeting/select-notes.d.ts

@@ -0,0 +1,10 @@
+import type { EnumeratedNote } from '../../check/enumerate.js';
+export interface SelectionResult {
+    selected: EnumeratedNote[];
+    unmatched: string[];
+}
+export declare function selectNotes(input: {
+    notes: readonly EnumeratedNote[];
+    patterns: readonly string[];
+    storeRoot: string;
+}): Promise<SelectionResult>;

package/dist/esm/cli/targeting/select-notes.js

@@ -0,0 +1,60 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import picomatch from 'picomatch';
+import { leadingLiteralPrefix } from "../../check/glob-segments.js";
+import { isEnoent } from "../../type-guards.js";
+export async function selectNotes(input) {
+    const { notes, storeRoot } = input;
+    const relativePaths = new Set(notes.map((entry) => entry.relativePath));
+    const selectedPaths = new Set();
+    const unmatched = [];
+    for (const rawPattern of input.patterns) {
+        const pattern = normalizePattern(rawPattern);
+        if (relativePaths.has(pattern)) {
+            selectedPaths.add(pattern);
+            continue;
+        }
+        const direct = matchPaths(notes, pattern);
+        if (direct.length > 0) {
+            for (const path of direct)
+                selectedPaths.add(path);
+            continue;
+        }
+        const resolved = await resolveEmptyPattern({ notes, pattern, storeRoot, selectedPaths });
+        if (!resolved)
+            unmatched.push(rawPattern);
+    }
+    const selected = notes.filter((entry) => selectedPaths.has(entry.relativePath));
+    return { selected, unmatched };
+}
+function matchPaths(notes, pattern) {
+    const isMatch = picomatch(pattern, { dot: false });
+    return notes.filter((entry) => isMatch(entry.relativePath)).map((entry) => entry.relativePath);
+}
+function normalizePattern(pattern) {
+    return pattern.replace(/^\.\//, '').replace(/\/$/, '');
+}
+async function resolveEmptyPattern(input) {
+    const { notes, pattern, storeRoot, selectedPaths } = input;
+    if (leadingLiteralPrefix(pattern) === pattern) {
+        const target = await tryStat(join(storeRoot, pattern));
+        if (target?.isDirectory()) {
+            for (const path of matchPaths(notes, `${pattern}/**`))
+                selectedPaths.add(path);
+            return true;
+        }
+        return target !== null;
+    }
+    const prefix = leadingLiteralPrefix(pattern);
+    return prefix !== '' && (await tryStat(join(storeRoot, prefix))) !== null;
+}
+async function tryStat(path) {
+    try {
+        return await stat(path);
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return null;
+        throw error;
+    }
+}

package/dist/esm/config/config-schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const configFileShape: z.ZodObject<{
+    targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export interface KbConfig {
+    targets: readonly string[];
+    exclude: readonly string[];
+}
+export declare const defaultKbConfig: KbConfig;

package/dist/esm/config/config-schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { CONTENT_DIR } from "../layout/index.js";
+export const configFileShape = z.object({
+    targets: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+});
+export const defaultKbConfig = {
+    targets: [`${CONTENT_DIR}/**/*.md`],
+    exclude: ['**/node_modules/**'],
+};

package/dist/esm/config/index.d.ts

@@ -0,0 +1,4 @@
+export { configFileShape, defaultKbConfig, type KbConfig } from './config-schema.js';
+export { isKbLoaderError, KbLoaderError } from './kb-loader-error.js';
+export { loadKbConfig } from './load-config.js';
+export { createNoteScopeMatcher, type NoteScopeMatcher } from './note-scope.js';

package/dist/esm/config/index.js

@@ -0,0 +1,4 @@
+export { configFileShape, defaultKbConfig } from "./config-schema.js";
+export { isKbLoaderError, KbLoaderError } from "./kb-loader-error.js";
+export { loadKbConfig } from "./load-config.js";
+export { createNoteScopeMatcher } from "./note-scope.js";

package/dist/esm/config/kb-loader-error.d.ts

@@ -0,0 +1,5 @@
+export declare class KbLoaderError extends Error {
+    readonly kind: "KbLoaderError";
+    constructor(message: string);
+}
+export declare function isKbLoaderError(error: unknown): error is KbLoaderError;

package/dist/esm/config/kb-loader-error.js

@@ -0,0 +1,14 @@
+export class KbLoaderError extends Error {
+    kind = 'KbLoaderError';
+    constructor(message) {
+        super(message);
+        this.name = 'KbLoaderError';
+    }
+}
+export function isKbLoaderError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    const candidate = error;
+    return candidate.kind === 'KbLoaderError';
+}