@creativeintelligence/abbie 0.1.0

package/dist/lib/docs/lint.js

@@ -0,0 +1,249 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative } from "node:path";
+const DEFAULT_IGNORE_DIR_NAMES = [
+    ".git",
+    ".next",
+    ".turbo",
+    ".cache",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".tmp-tests",
+];
+function resolveWorkspaceRoot(workspaceRoot) {
+    if (workspaceRoot)
+        return workspaceRoot;
+    return join(homedir(), "Developer");
+}
+function normalizeSymlinkTarget(target) {
+    // readlink can return "AGENTS.md" or "./AGENTS.md" depending on how it was created
+    return target.replace(/^[.][/]/, "");
+}
+function normalizeForHash(content) {
+    return content
+        .replace(/\r\n/g, "\n")
+        .replace(/[ \t]+$/gm, "")
+        .trim();
+}
+function wordCount(content) {
+    const words = content.trim().split(/\s+/).filter(Boolean);
+    return words.length;
+}
+function hasAnyHeading(content) {
+    return /^#{1,6}\s+\S/m.test(content);
+}
+function hasH1(content) {
+    return /^#\s+\S/m.test(content);
+}
+function isXmlishAgentsDoc(content) {
+    const trimmed = content.trimStart();
+    const firstLine = trimmed.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine.startsWith("<"))
+        return false;
+    if (hasAnyHeading(content))
+        return false;
+    const tagLikeCount = (content.match(/<\/?[A-Za-z][^>]*>/g) ?? []).length;
+    return tagLikeCount >= 3;
+}
+function* walkForAgentsMd(rootDirs, ignoreDirNames) {
+    const stack = [...rootDirs];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // Include AGENTS.md even if it's a symlink so we can validate direction.
+            if (entry.name === "AGENTS.md" && (entry.isFile() || entry.isSymbolicLink())) {
+                yield join(dir, entry.name);
+                continue;
+            }
+            // Avoid following symlinked directories (potential cycles).
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                if (ignoreDirNames.has(entry.name))
+                    continue;
+                stack.push(join(dir, entry.name));
+            }
+        }
+    }
+}
+export function lintAgentsDocs(options = {}) {
+    const workspaceRoot = resolveWorkspaceRoot(options.workspaceRoot);
+    const include = options.include ?? ["apps", "packages", "utils"];
+    const ignoreDirNames = new Set([...DEFAULT_IGNORE_DIR_NAMES, ...(options.ignoreDirNames ?? [])]);
+    const includedRoots = include.map((dir) => join(workspaceRoot, dir)).filter(existsSync);
+    const issues = [];
+    const hashes = new Map();
+    let agentsFiles = 0;
+    const warnShortWordsUnder = options.warnShortWordsUnder ?? 100;
+    const warnLongWordsOver = options.warnLongWordsOver ?? 2000;
+    for (const agentsPath of walkForAgentsMd(includedRoots, ignoreDirNames)) {
+        agentsFiles++;
+        const dir = dirname(agentsPath);
+        const claudePath = join(dir, "CLAUDE.md");
+        // ---------------------------------------------------------------------
+        // Symlink checks
+        // ---------------------------------------------------------------------
+        let agentsIsSymlink = false;
+        let agentsTarget;
+        try {
+            agentsIsSymlink = lstatSync(agentsPath).isSymbolicLink();
+            if (agentsIsSymlink)
+                agentsTarget = readlinkSync(agentsPath);
+        }
+        catch {
+            // ignore
+        }
+        if (agentsIsSymlink) {
+            const normalizedTarget = agentsTarget ? normalizeSymlinkTarget(agentsTarget) : undefined;
+            if (normalizedTarget === "CLAUDE.md") {
+                issues.push({
+                    type: "agents-inverted-symlink",
+                    severity: "error",
+                    path: agentsPath,
+                    detail: "Invalid direction: AGENTS.md → CLAUDE.md (should be canonical file)",
+                });
+            }
+            else {
+                issues.push({
+                    type: "agents-is-symlink",
+                    severity: "warn",
+                    path: agentsPath,
+                    detail: `AGENTS.md is a symlink (target: ${agentsTarget ?? "?"})`,
+                });
+            }
+        }
+        if (!existsSync(claudePath)) {
+            issues.push({
+                type: "missing-claude",
+                severity: "error",
+                path: agentsPath,
+                detail: "Missing CLAUDE.md (should be symlink → AGENTS.md)",
+            });
+        }
+        else {
+            let claudeIsSymlink = false;
+            let claudeTarget;
+            try {
+                claudeIsSymlink = lstatSync(claudePath).isSymbolicLink();
+                if (claudeIsSymlink)
+                    claudeTarget = readlinkSync(claudePath);
+            }
+            catch {
+                // ignore
+            }
+            if (!claudeIsSymlink) {
+                issues.push({
+                    type: "claude-not-symlink",
+                    severity: "warn",
+                    path: claudePath,
+                    detail: "CLAUDE.md is not a symlink (expected CLAUDE.md → AGENTS.md)",
+                });
+            }
+            else if (normalizeSymlinkTarget(claudeTarget ?? "") !== "AGENTS.md") {
+                issues.push({
+                    type: "claude-wrong-target",
+                    severity: "error",
+                    path: claudePath,
+                    detail: `CLAUDE.md points to ${claudeTarget ?? "?"} (expected AGENTS.md)`,
+                });
+            }
+        }
+        // ---------------------------------------------------------------------
+        // Content checks
+        // ---------------------------------------------------------------------
+        let content = "";
+        try {
+            content = readFileSync(agentsPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!hasAnyHeading(content)) {
+            issues.push({
+                type: "no-headings",
+                severity: "error",
+                path: agentsPath,
+                detail: "No Markdown headings found",
+            });
+        }
+        if (!hasH1(content)) {
+            issues.push({
+                type: "missing-h1",
+                severity: "error",
+                path: agentsPath,
+                detail: "Missing H1 title (`# ...`)",
+            });
+        }
+        if (isXmlishAgentsDoc(content)) {
+            issues.push({
+                type: "xmlish-agents",
+                severity: "error",
+                path: agentsPath,
+                detail: "Appears to be XML-ish (non-Markdown) AGENTS.md",
+            });
+        }
+        const words = wordCount(content);
+        if (words > 0 && words < warnShortWordsUnder) {
+            issues.push({
+                type: "short-doc",
+                severity: "warn",
+                path: agentsPath,
+                detail: `Very short doc (${words} words)`,
+            });
+        }
+        else if (words > warnLongWordsOver) {
+            issues.push({
+                type: "long-doc",
+                severity: "warn",
+                path: agentsPath,
+                detail: `Very long doc (${words} words)`,
+            });
+        }
+        // ---------------------------------------------------------------------
+        // Duplicate detection
+        // ---------------------------------------------------------------------
+        const normalized = normalizeForHash(content);
+        const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+        const group = hashes.get(hash);
+        if (group) {
+            group.paths.push(agentsPath);
+        }
+        else {
+            hashes.set(hash, { hash, paths: [agentsPath] });
+        }
+    }
+    const duplicateGroups = Array.from(hashes.values())
+        .filter((g) => g.paths.length > 1)
+        .map((g) => ({
+        hash: g.hash,
+        count: g.paths.length,
+        paths: [...g.paths].sort((a, b) => a.localeCompare(b)),
+    }))
+        .sort((a, b) => b.count - a.count || a.hash.localeCompare(b.hash));
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warn").length;
+    // By default, duplicates do not fail the run. They’re a drift report.
+    const ok = errors === 0;
+    return {
+        ok,
+        workspaceRoot,
+        includedRoots: includedRoots.map((p) => relative(workspaceRoot, p) || p),
+        agentsFiles,
+        errors,
+        warnings,
+        issues: issues.sort((a, b) => a.path.localeCompare(b.path)),
+        duplicateGroups,
+    };
+}

package/dist/lib/docs/lint.test.d.ts

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

package/dist/lib/docs/lint.test.js

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'bun:test';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { lintAgentsDocs } from './lint';
+function createTempDir(prefix) {
+    const root = join(process.cwd(), '.tmp-tests');
+    mkdirSync(root, { recursive: true });
+    const dir = join(root, `${prefix}-${randomUUID()}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function cleanupTemp(dir) {
+    const marker = `${sep}.tmp-tests${sep}`;
+    if (!dir.includes(marker))
+        return;
+    rmSync(dir, { recursive: true, force: true });
+}
+function writeAgentsDoc(dir, content) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'AGENTS.md'), content);
+    try {
+        symlinkSync('AGENTS.md', join(dir, 'CLAUDE.md'));
+    }
+    catch {
+        writeFileSync(join(dir, 'CLAUDE.md'), content);
+    }
+}
+describe('lintAgentsDocs', () => {
+    test('scans apps/packages/utils but not forks', () => {
+        const workspaceRoot = createTempDir('docs-lint');
+        try {
+            // Good doc under apps
+            writeAgentsDoc(join(workspaceRoot, 'apps', 'good', 'repo'), '# Good\n\n## Notes\n\nHello.');
+            // Bad doc under forks (should not be scanned)
+            mkdirSync(join(workspaceRoot, 'forks', 'bad'), { recursive: true });
+            writeFileSync(join(workspaceRoot, 'forks', 'bad', 'AGENTS.md'), '## Bad');
+            const result = lintAgentsDocs({
+                workspaceRoot,
+                warnShortWordsUnder: 0,
+                warnLongWordsOver: Number.MAX_SAFE_INTEGER,
+            });
+            expect(result.errors).toBe(0);
+            expect(result.agentsFiles).toBe(1);
+        }
+        finally {
+            cleanupTemp(workspaceRoot);
+        }
+    });
+    test('flags missing H1', () => {
+        const workspaceRoot = createTempDir('docs-lint');
+        try {
+            writeAgentsDoc(join(workspaceRoot, 'apps', 'missing-h1'), '## Only H2\n\nText.');
+            const result = lintAgentsDocs({
+                workspaceRoot,
+                warnShortWordsUnder: 0,
+                warnLongWordsOver: Number.MAX_SAFE_INTEGER,
+            });
+            expect(result.issues.some((i) => i.type === 'missing-h1')).toBe(true);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanupTemp(workspaceRoot);
+        }
+    });
+    test('flags XML-ish AGENTS.md', () => {
+        const workspaceRoot = createTempDir('docs-lint');
+        try {
+            writeAgentsDoc(join(workspaceRoot, 'utils', 'xmlish'), '<INSTRUCTIONS>\n  <foo>bar</foo>\n</INSTRUCTIONS>\n');
+            const result = lintAgentsDocs({
+                workspaceRoot,
+                warnShortWordsUnder: 0,
+                warnLongWordsOver: Number.MAX_SAFE_INTEGER,
+            });
+            expect(result.issues.some((i) => i.type === 'xmlish-agents')).toBe(true);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanupTemp(workspaceRoot);
+        }
+    });
+    test('reports duplicate clusters without failing', () => {
+        const workspaceRoot = createTempDir('docs-lint');
+        try {
+            const content = '# Template\n\n## Notes\n\nSame everywhere.';
+            writeAgentsDoc(join(workspaceRoot, 'apps', 'a'), content);
+            writeAgentsDoc(join(workspaceRoot, 'packages', 'b'), content);
+            const result = lintAgentsDocs({
+                workspaceRoot,
+                warnShortWordsUnder: 0,
+                warnLongWordsOver: Number.MAX_SAFE_INTEGER,
+            });
+            expect(result.ok).toBe(true);
+            expect(result.duplicateGroups.length).toBe(1);
+            expect(result.duplicateGroups[0]?.count).toBe(2);
+        }
+        finally {
+            cleanupTemp(workspaceRoot);
+        }
+    });
+    test('flags inverted symlink direction (AGENTS.md → CLAUDE.md)', () => {
+        const workspaceRoot = createTempDir('docs-lint');
+        try {
+            const dir = join(workspaceRoot, 'apps', 'inverted');
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, 'CLAUDE.md'), '# Inverted\n');
+            symlinkSync('CLAUDE.md', join(dir, 'AGENTS.md'));
+            const result = lintAgentsDocs({
+                workspaceRoot,
+                warnShortWordsUnder: 0,
+                warnLongWordsOver: Number.MAX_SAFE_INTEGER,
+            });
+            expect(result.issues.some((i) => i.type === 'agents-inverted-symlink')).toBe(true);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanupTemp(workspaceRoot);
+        }
+    });
+});

package/dist/lib/docs/sync.d.ts

@@ -0,0 +1,22 @@
+export type AgentsDocsSyncOptions = {
+    workspaceRoot?: string;
+    include?: string[];
+    dryRun?: boolean;
+    ignoreDirNames?: string[];
+};
+export type AgentsDocsSyncResult = {
+    ok: boolean;
+    workspaceRoot: string;
+    includedRoots: string[];
+    scanned: number;
+    updated: number;
+    skipped: number;
+    dryRun: boolean;
+    touchedPaths: string[];
+    skippedPaths: Array<{
+        path: string;
+        reason: string;
+    }>;
+};
+export declare function syncAgentsDocs(options?: AgentsDocsSyncOptions): AgentsDocsSyncResult;
+//# sourceMappingURL=sync.d.ts.map

package/dist/lib/docs/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/sync.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvD,CAAC;AA+FF,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,oBAAoB,CAmExF"}

package/dist/lib/docs/sync.js

@@ -0,0 +1,153 @@
+import { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+const DEFAULT_INCLUDE = ["apps", "packages", "utils"];
+const DEFAULT_IGNORE_DIR_NAMES = [
+    ".git",
+    ".next",
+    ".turbo",
+    ".cache",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".tmp-tests",
+    ".build",
+    "checkouts",
+    "vendor",
+    "Pods",
+    "DerivedData",
+    "target",
+];
+const SPAWN_PROTOCOL_MARKER = "## Agent Spawn Protocol (Recommended)";
+const SPAWN_PROTOCOL_BLOCK = `${SPAWN_PROTOCOL_MARKER}
+
+When spawning sub-agents, prefer skill-aware orchestration for better routing and reuse:
+
+1. Choose a relevant skill when possible (for example: \`use convex-god skill\`).
+2. Build or compose prompt context with \`prompts build\`.
+3. Spawn via tracked sessions: \`abbie session start --await --json -q\`.
+4. If no skill applies, continue without blocking and log rationale in the session summary.
+
+Canonical pattern:
+
+\`\`\`bash
+PROMPT=$(prompts build /agent --json --quiet | jq -r '.content')
+printf "%s\\n\\n%s" "$PROMPT" "use convex-god skill" | \\
+  abbie session start -a codex -p <project> -s convex-god --await --json -q
+\`\`\`
+`;
+function resolveWorkspaceRoot(workspaceRoot) {
+    if (workspaceRoot)
+        return workspaceRoot;
+    return join(homedir(), "Developer");
+}
+function hasAnyHeading(content) {
+    return /^#{1,6}\s+\S/m.test(content);
+}
+function isXmlishAgentsDoc(content) {
+    const trimmed = content.trimStart();
+    const firstLine = trimmed.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine.startsWith("<"))
+        return false;
+    if (hasAnyHeading(content))
+        return false;
+    const tagLikeCount = (content.match(/<\/?[A-Za-z][^>]*>/g) ?? []).length;
+    return tagLikeCount >= 3;
+}
+function* walkForAgentsMd(rootDirs, ignoreDirNames) {
+    const stack = [...rootDirs];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.name === "AGENTS.md" && (entry.isFile() || entry.isSymbolicLink())) {
+                yield fullPath;
+                continue;
+            }
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                if (ignoreDirNames.has(entry.name))
+                    continue;
+                stack.push(fullPath);
+            }
+        }
+    }
+}
+function appendSpawnProtocolBlock(content) {
+    const trimmed = content.trimEnd();
+    if (trimmed.length === 0)
+        return `${SPAWN_PROTOCOL_BLOCK}\n`;
+    return `${trimmed}\n\n${SPAWN_PROTOCOL_BLOCK}\n`;
+}
+export function syncAgentsDocs(options = {}) {
+    const workspaceRoot = resolveWorkspaceRoot(options.workspaceRoot);
+    const include = options.include ?? [...DEFAULT_INCLUDE];
+    const dryRun = options.dryRun ?? false;
+    const ignoreDirNames = new Set([...DEFAULT_IGNORE_DIR_NAMES, ...(options.ignoreDirNames ?? [])]);
+    const includedRoots = include.map((dir) => join(workspaceRoot, dir)).filter(existsSync);
+    const touchedPaths = [];
+    const skippedPaths = [];
+    let scanned = 0;
+    for (const agentsPath of walkForAgentsMd(includedRoots, ignoreDirNames)) {
+        scanned++;
+        try {
+            if (lstatSync(agentsPath).isSymbolicLink()) {
+                skippedPaths.push({ path: agentsPath, reason: "AGENTS.md is symlink" });
+                continue;
+            }
+        }
+        catch {
+            skippedPaths.push({ path: agentsPath, reason: "lstat failed" });
+            continue;
+        }
+        let content = "";
+        try {
+            content = readFileSync(agentsPath, "utf-8");
+        }
+        catch {
+            skippedPaths.push({ path: agentsPath, reason: "read failed" });
+            continue;
+        }
+        if (isXmlishAgentsDoc(content)) {
+            skippedPaths.push({ path: agentsPath, reason: "xml-ish doc" });
+            continue;
+        }
+        if (content.includes(SPAWN_PROTOCOL_MARKER)) {
+            skippedPaths.push({ path: agentsPath, reason: "already has spawn protocol" });
+            continue;
+        }
+        const next = appendSpawnProtocolBlock(content);
+        if (!dryRun) {
+            try {
+                writeFileSync(agentsPath, next, "utf-8");
+            }
+            catch {
+                skippedPaths.push({ path: agentsPath, reason: "write failed" });
+                continue;
+            }
+        }
+        touchedPaths.push(agentsPath);
+    }
+    return {
+        ok: true,
+        workspaceRoot,
+        includedRoots: includedRoots.map((p) => relative(workspaceRoot, p) || p),
+        scanned,
+        updated: touchedPaths.length,
+        skipped: skippedPaths.length,
+        dryRun,
+        touchedPaths: touchedPaths.sort((a, b) => a.localeCompare(b)),
+        skippedPaths: skippedPaths.sort((a, b) => a.path.localeCompare(b.path)),
+    };
+}

package/dist/lib/doctor/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Doctor - Environment validation for abbie CLI
+ *
+ * Checks:
+ * - ~/.abbie directories existence
+ * - Runtime detection (node/bun)
+ * - Agent binaries (claude, codex, copilot, gemini)
+ * - Optional tools (slack, messages, linear) - warn not fail
+ * - Template system (v2)
+ * - Per-repo contracts (v2)
+ */
+import { type RepoCheckResult, summarizeRepoChecks } from "./repos.js";
+export type CheckStatus = "ok" | "missing" | "warn";
+export interface Check {
+    name: string;
+    status: CheckStatus;
+    detail: string;
+}
+export interface Fix {
+    if: string;
+    hint: string;
+}
+export interface DoctorResult {
+    ok: boolean;
+    checks: Check[];
+    fixes: Fix[];
+    templateChecks?: Check[];
+    repoResults?: RepoCheckResult[];
+    summary?: {
+        environment: {
+            ok: number;
+            warn: number;
+            missing: number;
+        };
+        templates?: {
+            ok: number;
+            warn: number;
+            missing: number;
+        };
+        repos?: ReturnType<typeof summarizeRepoChecks>;
+    };
+    exitCode?: number;
+}
+declare const REQUIRED_DIRS: readonly ["plans", "active-sessions", "prompts", "events", "resources"];
+declare function getAgentsRoot(): string;
+export declare function checkDirectories(): Check[];
+export declare function fixDirectories(): string[];
+export declare function checkRuntime(): Check;
+declare const REQUIRED_BINARIES: readonly ["claude", "codex", "copilot", "gemini"];
+declare const OPTIONAL_BINARIES: readonly ["slack", "messages", "linear"];
+export declare function checkBinaries(): Check[];
+declare const OPTIONAL_ENV_VARS: ReadonlyArray<{
+    name: string;
+    description: string;
+}>;
+export declare function checkEnvVars(): Check[];
+export declare function checkSymlinks(): Check[];
+export declare function generateFixes(checks: Check[]): Fix[];
+export interface DoctorOptions {
+    fix?: boolean;
+    includeTemplates?: boolean;
+    includeRepos?: boolean;
+    reposPath?: string;
+}
+export declare function checkConfigSync(): Check[];
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorResult>;
+export { REQUIRED_DIRS, REQUIRED_BINARIES, OPTIONAL_BINARIES, OPTIONAL_ENV_VARS, getAgentsRoot };
+export * from "./repos.js";
+export * from "./templates.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/doctor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,EAAc,KAAK,eAAe,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AASnF,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,GAAG,EAAE,CAAC;IAEb,cAAc,CAAC,EAAE,KAAK,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,eAAe,EAAE,CAAC;IAChC,OAAO,CAAC,EAAE;QACR,WAAW,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3D,SAAS,CAAC,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAC1D,KAAK,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;KAChD,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAMD,QAAA,MAAM,aAAa,yEAA0E,CAAC;AAE9F,iBAAS,aAAa,IAAI,MAAM,CAE/B;AAED,wBAAgB,gBAAgB,IAAI,KAAK,EAAE,CAsC1C;AAED,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAoBzC;AAMD,wBAAgB,YAAY,IAAI,KAAK,CAWpC;AA+BD,QAAA,MAAM,iBAAiB,mDAAoD,CAAC;AAE5E,QAAA,MAAM,iBAAiB,0CAA2C,CAAC;AAEnE,wBAAgB,aAAa,IAAI,KAAK,EAAE,CAwCvC;AAQD,QAAA,MAAM,iBAAiB,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAO3E,CAAC;AAEF,wBAAgB,YAAY,IAAI,KAAK,EAAE,CAqBtC;AA4DD,wBAAgB,aAAa,IAAI,KAAK,EAAE,CAsCvC;AAgBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,EAAE,CAoDpD;AAMD,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,wBAAgB,eAAe,IAAI,KAAK,EAAE,CAyGzC;AAED,wBAAsB,SAAS,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,CA4FlF;AAMD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,CAAC;AAEjG,cAAc,YAAY,CAAC;AAE3B,cAAc,gBAAgB,CAAC"}