monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/commands/doc.js

@@ -1,268 +0,0 @@
-/**
- * CLI Document Command — Second Brain document management
- */
-import * as path from 'node:path';
-import { output } from '../output.js';
-import { getGlobalBrainDir } from '../memory/memory-bridge.js';
-const ingestCommand = {
-    name: 'ingest',
-    description: 'Ingest documents into the knowledge base',
-    options: [
-        // No `default` on scope: the auto-global routing below must be able to
-        // tell "user typed --scope shared" apart from "user typed nothing" — a
-        // parser-injected default makes them indistinguishable.
-        { name: 'scope', short: 's', description: 'Knowledge scope (default: shared; auto-routes to global for paths outside the project)', type: 'string' },
-        { name: 'global', short: 'g', description: 'Ingest into the personal cross-project global brain (~/.monomind/global-brain)', type: 'boolean' },
-    ],
-    examples: [
-        { command: 'monomind doc ingest ./docs', description: 'Ingest all docs in a directory' },
-        { command: 'monomind doc ingest ~/notes --global', description: 'Ingest into the global brain (auto-detected for paths outside the project)' },
-        { command: 'monomind doc ingest report.pdf', description: 'Ingest a single file' },
-    ],
-    action: async (ctx) => {
-        const target = ctx.args[0] || '.';
-        const { ingestDocument, ingestDirectory } = await import('../knowledge/document-pipeline.js');
-        const fs = await import('node:fs');
-        const resolved = path.resolve(target);
-        // Zero-decision routing: an explicit --global wins; otherwise paths OUTSIDE
-        // the current project belong to the personal brain (a project store keyed
-        // to this cwd would never see them again from another project).
-        let scope = String(ctx.flags.scope || 'shared');
-        if (ctx.flags.global === true) {
-            scope = 'global';
-        }
-        else if (!ctx.flags.scope) {
-            const relToCwd = path.relative(process.cwd(), resolved);
-            if (relToCwd.startsWith('..') || path.isAbsolute(relToCwd)) {
-                scope = 'global';
-                output.writeln(output.dim(`  ${target} is outside this project — ingesting into the global brain (use --scope shared to force project scope)`));
-            }
-        }
-        const spinner = output.createSpinner({ text: 'Indexing documents...' });
-        spinner.start();
-        try {
-            const stat = fs.statSync(resolved);
-            if (stat.isDirectory()) {
-                const result = await ingestDirectory(resolved, scope, {
-                    rootDir: ctx.cwd || process.cwd(),
-                    onProgress: (file, done, total) => {
-                        spinner.setText(`[${done + 1}/${total}] ${path.basename(file)}`);
-                    },
-                });
-                spinner.succeed(`Indexed ${result.totalChunks} chunks from ${result.filesProcessed} files (${result.filesSkipped} skipped)`);
-                if (result.errors.length) {
-                    output.writeln(output.dim(`  Errors: ${result.errors.length}`));
-                    for (const err of result.errors.slice(0, 5)) {
-                        output.writeln(output.dim(`    ${err}`));
-                    }
-                }
-                return { success: true, data: result };
-            }
-            else {
-                const result = await ingestDocument(resolved, scope);
-                if (result.skipped && !result.error) {
-                    spinner.succeed(`Already indexed: ${path.basename(resolved)} (${result.chunksIndexed} chunks)`);
-                }
-                else if (result.error) {
-                    spinner.fail(result.error);
-                    return { success: false };
-                }
-                else {
-                    spinner.succeed(`Indexed ${result.chunksIndexed} chunks from ${path.basename(resolved)}`);
-                }
-                return { success: true, data: result };
-            }
-        }
-        catch (err) {
-            spinner.fail(String(err));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-const searchDocCommand = {
-    name: 'search',
-    description: 'Semantic search over indexed documents',
-    options: [
-        { name: 'query', short: 'q', description: 'Search query', type: 'string', required: true },
-        { name: 'limit', short: 'l', description: 'Max results (default: 10)', type: 'number', default: 10 },
-        { name: 'scope', short: 's', description: 'Knowledge scope (default: shared)', type: 'string', default: 'shared' },
-        { name: 'min-score', description: 'Minimum similarity (default: 0.3)', type: 'number', default: 0.3 },
-        { name: 'store', description: 'Which store(s): project | global | all (default: all — project results win ties)', type: 'string', default: 'all' },
-        { name: 'surfaces', description: "Override routing: comma list of chunks,kg,rules,memory (default: rule-based router picks)", type: 'string' },
-    ],
-    examples: [
-        { command: 'monomind doc search -q "authentication flow"', description: 'Search project + global brain' },
-        { command: 'monomind doc search -q "pricing notes" --store global', description: 'Search only the personal global brain' },
-    ],
-    action: async (ctx) => {
-        const query = String(ctx.flags.query || ctx.args[0] || '');
-        if (!query) {
-            output.printError('Query required: monomind doc search -q "your query"');
-            return { success: false, exitCode: 1 };
-        }
-        const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
-        const { routeQuery, rrfFuse, recordRouteOverride } = await import('../memory/query-router.js');
-        const storeFlag = String(ctx.flags.store || 'all');
-        const limit = Number(ctx.flags.limit || 10);
-        // Same surface routing as the MCP knowledge_search tool and the warm
-        // /api/knowledge/search endpoint: the rule-based router picks which
-        // retrieval surfaces to spend queries on; --surfaces overrides it.
-        const route = routeQuery(query);
-        const VALID_SURFACES = ['chunks', 'kg', 'rules', 'memory'];
-        const rawSurfaces = String(ctx.flags.surfaces || '').split(',').map(s => s.trim()).filter(Boolean);
-        const requested = rawSurfaces.filter(s => VALID_SURFACES.includes(s));
-        const invalidSurfaces = rawSurfaces.filter(s => !VALID_SURFACES.includes(s));
-        if (invalidSurfaces.length) {
-            output.writeln(output.dim(`ignoring unknown surface(s): ${invalidSurfaces.join(',')} (valid: ${VALID_SURFACES.join(',')})`));
-        }
-        const surfaces = requested.length
-            ? requested
-            : (route.confident ? route.surfaces : ['chunks', ...route.surfaces.filter(s => s !== 'chunks')]);
-        const bridge = await import('../memory/memory-bridge.js');
-        const kg = await import('../memory/memory-kg.js');
-        const [excerpts, graph, rules, memories] = await Promise.all([
-            surfaces.includes('chunks')
-                ? searchKnowledge(query, {
-                    scope: String(ctx.flags.scope || 'shared'),
-                    limit,
-                    minScore: Number(ctx.flags['min-score'] || 0.3),
-                    store: storeFlag === 'project' || storeFlag === 'global' ? storeFlag : 'all',
-                })
-                : [],
-            surfaces.includes('kg') ? kg.kgSearch({ query, limit: 6 }).catch(() => null) : null,
-            surfaces.includes('rules') ? bridge.bridgeSearchEntries({ query, namespace: 'rules', limit: 3, threshold: 0.35 }).catch(() => null) : null,
-            surfaces.includes('memory') ? bridge.bridgeSearchEntries({ query, namespace: 'patterns', limit: 3 }).catch(() => null) : null,
-        ]);
-        // Confident non-chunk routing against an empty surface (e.g. a project
-        // with no KG yet) must not read as "no knowledge" — fall back to chunks.
-        let fellBack = false;
-        let chunkExcerpts = excerpts;
-        if (!requested.length && !chunkExcerpts.length && !(graph?.triplets?.length) && !(rules?.results?.length) && !(memories?.results?.length) && !surfaces.includes('chunks')) {
-            fellBack = true;
-            recordRouteOverride(surfaces[0], 'chunks');
-            chunkExcerpts = await searchKnowledge(query, {
-                scope: String(ctx.flags.scope || 'shared'),
-                limit,
-                minScore: Number(ctx.flags['min-score'] || 0.3),
-                store: storeFlag === 'project' || storeFlag === 'global' ? storeFlag : 'all',
-            });
-        }
-        const fused = rrfFuse([
-            chunkExcerpts.map(e => ({ id: e.id || `${e.filePath}#${e.chunkIndex}`, kind: 'excerpt', ...e })),
-            (graph?.triplets ?? []).map((t, i) => ({ id: `kg:${i}:${t.source}|${t.relation}|${t.target}`, kind: 'triplet', ...t })),
-            (rules?.results ?? []).map(r => ({ id: r.id, kind: 'rule', key: r.key, text: r.content, score: r.score, importance: 0.7 })),
-            (memories?.results ?? []).map(r => ({ id: r.id, kind: 'memory', key: r.key, text: r.content, score: r.score })),
-        ], limit);
-        if (!fused.length) {
-            output.writeln(output.dim('No results found.'));
-            return { success: true, data: [] };
-        }
-        output.writeln(output.bold(`${fused.length} results ${output.dim(`(surfaces: ${fellBack ? surfaces.join(',') + ' → chunks fallback' : surfaces.join(',')})`)}:`));
-        output.writeln();
-        for (let i = 0; i < fused.length; i++) {
-            const r = fused[i];
-            const n = output.highlight(`${i + 1}.`);
-            if (r.kind === 'triplet') {
-                const fact = r.fact && r.fact !== `${r.source} ${r.relation} ${r.target}` ? ` ${output.dim(`(${String(r.fact).slice(0, 160)})`)}` : '';
-                output.writeln(`${n} ${output.dim('[kg]')} ${r.source} —${r.relation}→ ${r.target}${fact}`);
-            }
-            else if (r.kind === 'rule' || r.kind === 'memory') {
-                output.writeln(`${n} ${output.dim(`[${r.kind}]`)} ${String(r.text || '').replace(/\s+/g, ' ').slice(0, 200)}`);
-            }
-            else {
-                const origin = r.scope === 'global' ? ` ${output.dim('[global]')}` : '';
-                const sim = typeof r.similarity === 'number' ? `(${r.similarity.toFixed(3)}) ` : '';
-                output.writeln(`${n} ${output.dim(sim)}${r.filePath || 'unknown'}${origin}`);
-                const text = String(r.text || '');
-                output.writeln(`   ${output.dim(text.length > 200 ? text.slice(0, 200) + '...' : text)}`);
-            }
-            output.writeln();
-        }
-        return { success: true, data: fused };
-    },
-};
-const listDocCommand = {
-    name: 'list',
-    description: 'List indexed documents',
-    options: [
-        { name: 'scope', short: 's', description: 'Knowledge scope', type: 'string' },
-        { name: 'global', short: 'g', description: 'List the personal cross-project global brain', type: 'boolean' },
-    ],
-    action: async (ctx) => {
-        const { listDocuments } = await import('../knowledge/document-pipeline.js');
-        const isGlobal = ctx.flags.global === true;
-        const scope = isGlobal ? 'global' : ctx.flags.scope ? String(ctx.flags.scope) : undefined;
-        const docs = listDocuments(isGlobal ? getGlobalBrainDir() : process.cwd(), scope);
-        if (!docs.length) {
-            output.writeln(output.dim('No documents indexed. Run: monomind doc ingest <path>'));
-            return { success: true, data: [] };
-        }
-        output.writeln(output.bold(`${docs.length} documents indexed:`));
-        output.writeln();
-        for (const doc of docs) {
-            const name = path.basename(doc.filePath);
-            const size = doc.size > 1024 * 1024
-                ? `${(doc.size / 1024 / 1024).toFixed(1)}MB`
-                : `${(doc.size / 1024).toFixed(0)}KB`;
-            const date = doc.indexedAt.slice(0, 10);
-            output.writeln(`  ${output.highlight(name)} ${output.dim(`${doc.chunkCount} chunks · ${size} · ${date} · ${doc.scope}`)}`);
-        }
-        return { success: true, data: docs };
-    },
-};
-const exportDocCommand = {
-    name: 'export',
-    description: 'Export knowledge base as OKF bundle (markdown + frontmatter)',
-    options: [
-        { name: 'output', short: 'o', description: 'Output directory', type: 'string', default: '.monomind/knowledge-export' },
-        { name: 'scope', short: 's', description: 'Knowledge scope (default: shared)', type: 'string', default: 'shared' },
-        { name: 'global', short: 'g', description: 'Export the personal cross-project global brain (portable between machines)', type: 'boolean' },
-    ],
-    action: async (ctx) => {
-        const { exportToOKF } = await import('../knowledge/document-pipeline.js');
-        const outDir = path.resolve(String(ctx.flags.output || '.monomind/knowledge-export'));
-        const isGlobal = ctx.flags.global === true;
-        const scope = isGlobal ? 'global' : String(ctx.flags.scope || 'shared');
-        const spinner = output.createSpinner({ text: 'Exporting to OKF...' });
-        spinner.start();
-        try {
-            const result = await exportToOKF(outDir, isGlobal ? getGlobalBrainDir() : process.cwd(), scope);
-            spinner.succeed(`Exported ${result.exported} documents to ${result.outputDir}`);
-            return { success: true, data: result };
-        }
-        catch (err) {
-            spinner.fail(String(err));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-export const docCommand = {
-    name: 'doc',
-    description: 'Second Brain — document knowledge management',
-    aliases: ['docs', 'knowledge'],
-    subcommands: [ingestCommand, searchDocCommand, listDocCommand, exportDocCommand],
-    options: [],
-    examples: [
-        { command: 'monomind doc ingest ./docs', description: 'Index documents' },
-        { command: 'monomind doc search -q "auth flow"', description: 'Semantic search' },
-        { command: 'monomind doc list', description: 'List indexed docs' },
-        { command: 'monomind doc export', description: 'Export as OKF bundle' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Second Brain — Document Knowledge Management'));
-        output.writeln();
-        output.writeln('Usage: monomind doc <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('ingest')}  - Ingest documents into the knowledge base`,
-            `${output.highlight('search')}  - Semantic search over indexed documents`,
-            `${output.highlight('list')}    - List indexed documents`,
-            `${output.highlight('export')}  - Export as OKF bundle (markdown + frontmatter)`,
-        ]);
-        return { success: true };
-    },
-};
-export default docCommand;
-//# sourceMappingURL=doc.js.map

package/packages/@monomind/cli/dist/src/commands/doctor-env-checks.d.ts

@@ -1,26 +0,0 @@
-/**
- * Doctor — system/environment health checks
- * Node, npm, git, disk, TypeScript, Claude CLI, version freshness
- */
-export declare const MAX_DOCTOR_PKG_BYTES: number;
-export declare const MAX_DOCTOR_CONFIG_BYTES: number;
-export declare const MAX_DOCTOR_GITIGNORE_BYTES: number;
-export declare const MAX_DOCTOR_PID_BYTES = 64;
-export declare const MAX_DOCTOR_HELPER_BYTES: number;
-export interface HealthCheck {
-    name: string;
-    status: 'pass' | 'warn' | 'fail';
-    message: string;
-    fix?: string;
-}
-export declare function runCommand(command: string, timeoutMs?: number): Promise<string>;
-export declare function checkNodeVersion(): Promise<HealthCheck>;
-export declare function checkNpmVersion(): Promise<HealthCheck>;
-export declare function checkGit(): Promise<HealthCheck>;
-export declare function checkGitRepo(): Promise<HealthCheck>;
-export declare function checkDiskSpace(): Promise<HealthCheck>;
-export declare function checkBuildTools(): Promise<HealthCheck>;
-export declare function checkVersionFreshness(): Promise<HealthCheck>;
-export declare function checkClaudeCode(): Promise<HealthCheck>;
-export declare function installClaudeCode(): Promise<boolean>;
-//# sourceMappingURL=doctor-env-checks.d.ts.map

package/packages/@monomind/cli/dist/src/commands/doctor-env-checks.js

@@ -1,194 +0,0 @@
-/**
- * Doctor — system/environment health checks
- * Node, npm, git, disk, TypeScript, Claude CLI, version freshness
- */
-import { existsSync, readFileSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { execSync, exec } from 'child_process';
-import { promisify } from 'util';
-import { output } from '../output.js';
-export const MAX_DOCTOR_PKG_BYTES = 1024 * 1024; // 1 MB
-export const MAX_DOCTOR_CONFIG_BYTES = 10 * 1024 * 1024; // 10 MB
-export const MAX_DOCTOR_GITIGNORE_BYTES = 512 * 1024; // 512 KB
-export const MAX_DOCTOR_PID_BYTES = 64; // 64 bytes
-export const MAX_DOCTOR_HELPER_BYTES = 2 * 1024 * 1024; // 2 MB
-const execAsync = promisify(exec);
-export async function runCommand(command, timeoutMs = 5000) {
-    const { stdout } = await execAsync(command, {
-        encoding: 'utf8',
-        timeout: timeoutMs,
-        shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
-        env: { ...process.env },
-        windowsHide: true,
-    });
-    return stdout.trim();
-}
-export async function checkNodeVersion() {
-    const requiredMajor = 20;
-    const version = process.version;
-    const major = parseInt(version.slice(1).split('.')[0], 10);
-    if (major >= requiredMajor) {
-        return { name: 'Node.js Version', status: 'pass', message: `${version} (>= ${requiredMajor} required)` };
-    }
-    else if (major >= 18) {
-        return { name: 'Node.js Version', status: 'warn', message: `${version} (>= ${requiredMajor} recommended)`, fix: 'nvm install 20 && nvm use 20' };
-    }
-    return { name: 'Node.js Version', status: 'fail', message: `${version} (>= ${requiredMajor} required)`, fix: 'nvm install 20 && nvm use 20' };
-}
-export async function checkNpmVersion() {
-    try {
-        const version = await runCommand('npm --version');
-        const major = parseInt(version.split('.')[0], 10);
-        if (major >= 9)
-            return { name: 'npm Version', status: 'pass', message: `v${version}` };
-        return { name: 'npm Version', status: 'warn', message: `v${version} (>= 9 recommended)`, fix: 'npm install -g npm@latest' };
-    }
-    catch {
-        return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
-    }
-}
-export async function checkGit() {
-    try {
-        const version = await runCommand('git --version');
-        return { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') };
-    }
-    catch {
-        return { name: 'Git', status: 'warn', message: 'Not installed', fix: 'Install git from https://git-scm.com' };
-    }
-}
-export async function checkGitRepo() {
-    try {
-        await runCommand('git rev-parse --git-dir');
-        return { name: 'Git Repository', status: 'pass', message: 'In a git repository' };
-    }
-    catch {
-        return { name: 'Git Repository', status: 'warn', message: 'Not a git repository', fix: 'git init' };
-    }
-}
-export async function checkDiskSpace() {
-    try {
-        if (process.platform === 'win32')
-            return { name: 'Disk Space', status: 'pass', message: 'Check skipped on Windows' };
-        const output_str = await runCommand('df -Ph . | tail -1');
-        const parts = output_str.split(/\s+/);
-        const available = parts[3];
-        const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
-        if (isNaN(usePercent))
-            return { name: 'Disk Space', status: 'warn', message: `${available || 'unknown'} available (unable to parse usage)` };
-        if (usePercent > 90)
-            return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
-        if (usePercent > 80)
-            return { name: 'Disk Space', status: 'warn', message: `${available} available (${usePercent}% used)` };
-        return { name: 'Disk Space', status: 'pass', message: `${available} available` };
-    }
-    catch {
-        return { name: 'Disk Space', status: 'warn', message: 'Unable to check' };
-    }
-}
-export async function checkBuildTools() {
-    // Only meaningful for Node/TS projects — a Go, Python, or Rust repo has no
-    // reason to install TypeScript, and warning about it there is just noise.
-    if (!existsSync(join(process.cwd(), 'package.json'))) {
-        return { name: 'TypeScript', status: 'pass', message: 'N/A — no package.json (not a Node.js project)' };
-    }
-    try {
-        const tscVersion = await runCommand('npx tsc --version', 10000);
-        if (!tscVersion || tscVersion.includes('not found')) {
-            return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
-        }
-        return { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') };
-    }
-    catch {
-        return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
-    }
-}
-export async function checkVersionFreshness() {
-    try {
-        let currentVersion = '0.0.0';
-        try {
-            const thisFile = fileURLToPath(import.meta.url);
-            let dir = dirname(thisFile);
-            for (;;) {
-                const candidate = join(dir, 'package.json');
-                try {
-                    if (existsSync(candidate) && statSync(candidate).size <= MAX_DOCTOR_PKG_BYTES) {
-                        const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                        if (pkg.version && typeof pkg.name === 'string' &&
-                            (pkg.name === '@monomind/cli' || pkg.name === 'monomind' || pkg.name === '@monoes/monomindcli')) {
-                            currentVersion = pkg.version;
-                            break;
-                        }
-                    }
-                }
-                catch { /* keep walking */ }
-                const parent = dirname(dir);
-                if (parent === dir)
-                    break;
-                dir = parent;
-            }
-        }
-        catch {
-            currentVersion = '0.0.0';
-        }
-        const isNpx = process.argv[1]?.includes('_npx') ||
-            process.env.npm_execpath?.includes('npx') ||
-            process.cwd().includes('_npx');
-        let latestVersion = currentVersion;
-        try {
-            latestVersion = (await runCommand('npm view monomind version', 5000)).trim();
-        }
-        catch {
-            return { name: 'Version Freshness', status: 'warn', message: `v${currentVersion} (cannot check registry)` };
-        }
-        const parseVer = (v) => {
-            const m = v.match(/^(\d+)\.(\d+)\.(\d+)(?:-[a-zA-Z]+\.(\d+))?/);
-            if (!m)
-                return { major: 0, minor: 0, patch: 0, pre: 0 };
-            return { major: +m[1], minor: +m[2], patch: +m[3], pre: +(m[4] ?? 0) };
-        };
-        const cur = parseVer(currentVersion);
-        const lat = parseVer(latestVersion);
-        const outdated = lat.major > cur.major || (lat.major === cur.major && lat.minor > cur.minor) ||
-            (lat.major === cur.major && lat.minor === cur.minor && lat.patch > cur.patch) ||
-            (lat.major === cur.major && lat.minor === cur.minor && lat.patch === cur.patch && lat.pre > cur.pre);
-        if (outdated) {
-            return {
-                name: 'Version Freshness',
-                status: 'warn',
-                message: `v${currentVersion} (latest: v${latestVersion})${isNpx ? ' [npx cache stale]' : ''}`,
-                fix: isNpx ? 'rm -rf ~/.npm/_npx/* && npx -y monomind@latest doctor' : 'npm update -g monomind',
-            };
-        }
-        return { name: 'Version Freshness', status: 'pass', message: `v${currentVersion} (up to date)` };
-    }
-    catch {
-        return { name: 'Version Freshness', status: 'warn', message: 'Unable to check version freshness' };
-    }
-}
-export async function checkClaudeCode() {
-    try {
-        const version = await runCommand('claude --version');
-        const m = version.match(/v?(\d+\.\d+\.\d+)/);
-        return { name: 'Claude Code CLI', status: 'pass', message: m ? `v${m[1]}` : version };
-    }
-    catch {
-        return { name: 'Claude Code CLI', status: 'warn', message: 'Not installed', fix: 'npm install -g @anthropic-ai/claude-code' };
-    }
-}
-export async function installClaudeCode() {
-    try {
-        output.writeln();
-        output.writeln(output.bold('Installing Claude Code CLI...'));
-        execSync('npm install -g @anthropic-ai/claude-code', { encoding: 'utf8', stdio: 'inherit' });
-        output.writeln(output.success('Claude Code CLI installed successfully!'));
-        return true;
-    }
-    catch (error) {
-        output.writeln(output.error('Failed to install Claude Code CLI'));
-        if (error instanceof Error)
-            output.writeln(output.dim(error.message));
-        return false;
-    }
-}
-//# sourceMappingURL=doctor-env-checks.js.map

package/packages/@monomind/cli/dist/src/commands/doctor-monoes-checks.d.ts

@@ -1,12 +0,0 @@
-/**
- * Doctor — monoes tool family checks (monotask, mono-agent, mono-clip)
- *
- * Opt-in component only (`monomind doctor -c monoes-tools`) — not part of the
- * always-on check set, since these are unrelated sibling tools on this machine,
- * not monomind dependencies. Catches known Homebrew tap-rename and Gatekeeper
- * issues discovered while installing them via /monoes:install.
- */
-import type { HealthCheck } from './doctor-env-checks.js';
-export declare function checkMonoesTools(): Promise<HealthCheck>;
-export declare function fixMonoesTools(): Promise<boolean>;
-//# sourceMappingURL=doctor-monoes-checks.d.ts.map

package/packages/@monomind/cli/dist/src/commands/doctor-monoes-checks.js

@@ -1,160 +0,0 @@
-/**
- * Doctor — monoes tool family checks (monotask, mono-agent, mono-clip)
- *
- * Opt-in component only (`monomind doctor -c monoes-tools`) — not part of the
- * always-on check set, since these are unrelated sibling tools on this machine,
- * not monomind dependencies. Catches known Homebrew tap-rename and Gatekeeper
- * issues discovered while installing them via /monoes:install.
- */
-import { existsSync } from 'fs';
-import { execSync } from 'child_process';
-import { output } from '../output.js';
-import { runCommand } from './doctor-env-checks.js';
-async function commandExists(cmd) {
-    try {
-        await runCommand(`command -v ${cmd}`);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function findMonoesIssues() {
-    const issues = [];
-    // 1. Tap rename ambiguity: nokhodian/tap was renamed to monoes/tap. Having both
-    //    tapped makes formula/cask lookups ambiguous ("found in multiple taps").
-    try {
-        const taps = await runCommand('brew tap');
-        const hasOld = /(^|\n)nokhodian\/tap(\n|$)/.test(taps);
-        const hasNew = /(^|\n)monoes\/tap(\n|$)/.test(taps);
-        if (hasOld && hasNew) {
-            // --force is safe here: brew refuses a plain untap because it sees formula/cask
-            // names matching this tap's checkout, even when they're actually installed from
-            // monoes/tap (same upstream repo, redirected). Verified against INSTALL_RECEIPT.json
-            // before relying on this — the receipts point at monoes/tap, not this one.
-            issues.push({
-                message: 'both nokhodian/tap and monoes/tap are tapped — formula/cask lookups are ambiguous',
-                fixCommand: 'brew untap --force nokhodian/tap',
-            });
-        }
-        else if (hasOld && !hasNew) {
-            issues.push({
-                message: 'nokhodian/tap is tapped but was renamed to monoes/tap',
-                fixCommand: 'brew untap --force nokhodian/tap && brew tap monoes/tap',
-            });
-        }
-    }
-    catch {
-        // brew not usable for tap listing — skip this sub-check
-    }
-    // 2. monotask formula installed but not linked as `monotask` on PATH. Homebrew
-    //    ships the raw binary as `monotaskcli` and skips auto-linking when the
-    //    same-named `monotask` cask is also installed.
-    try {
-        const cellarRoot = await runCommand('brew --cellar');
-        if (cellarRoot && existsSync(`${cellarRoot}/monotask`) && !(await commandExists('monotask'))) {
-            issues.push({
-                message: "monotask formula is installed but 'monotask' isn't on PATH (Homebrew installs it as 'monotaskcli' and skips linking when the same-named cask is present)",
-                fixCommand: 'ln -sf "$(brew --cellar)"/monotask/*/bin/monotaskcli "$(brew --prefix)/bin/monotask"',
-            });
-        }
-    }
-    catch {
-        // skip
-    }
-    // 3. MonoClip.app quarantined/unsigned — macOS can silently move it to Trash on
-    //    its first launch instead of showing the "damaged" dialog.
-    try {
-        if (existsSync('/Applications/MonoClip.app')) {
-            let quarantined = true;
-            try {
-                await runCommand('xattr -p com.apple.quarantine "/Applications/MonoClip.app"');
-            }
-            catch {
-                quarantined = false;
-            }
-            if (quarantined) {
-                issues.push({
-                    message: 'MonoClip.app is quarantined — macOS may silently move it to Trash on first launch',
-                    fixCommand: 'find /Applications/MonoClip.app -print0 | xargs -0 xattr -c && codesign --force --deep --sign - /Applications/MonoClip.app',
-                });
-            }
-        }
-    }
-    catch {
-        // skip
-    }
-    // 4. mono-agent (monoagentcli) — distributed as a raw GitHub release binary, not
-    //    through Homebrew, so it never gets picked up by `brew upgrade`. Check it
-    //    against the latest GitHub release directly.
-    try {
-        if (await commandExists('monoagentcli')) {
-            const versionOut = await runCommand('monoagentcli version');
-            const m = versionOut.match(/v?(\d+\.\d+\.\d+)/);
-            if (m) {
-                const current = m[1];
-                try {
-                    const releaseJson = await runCommand('curl -fsSL https://api.github.com/repos/monoes/mono-agent/releases/latest', 8000);
-                    const latestTag = (JSON.parse(releaseJson).tag_name || '').replace(/^v/, '');
-                    if (latestTag && latestTag !== current) {
-                        issues.push({
-                            message: `monoagentcli is v${current}, latest release is v${latestTag}`,
-                            fixCommand: 'ARCH=$(uname -m); [ "$ARCH" = "x86_64" ] && ARCH=amd64; ' +
-                                'curl -fsSL --max-time 30 "https://github.com/monoes/mono-agent/releases/latest/download/monoagentcli-darwin-${ARCH}" -o /tmp/monoagentcli && ' +
-                                'chmod +x /tmp/monoagentcli && sudo mv /tmp/monoagentcli /usr/local/bin/monoagentcli',
-                        });
-                    }
-                }
-                catch {
-                    // GitHub API unreachable/rate-limited — skip version-freshness sub-check
-                }
-            }
-        }
-    }
-    catch {
-        // skip
-    }
-    return issues;
-}
-export async function checkMonoesTools() {
-    if (process.platform !== 'darwin') {
-        return { name: 'monoes Tools', status: 'pass', message: 'Skipped (macOS-only — monotask/mono-agent/mono-clip are macOS tools)' };
-    }
-    const issues = await findMonoesIssues();
-    if (issues.length === 0) {
-        return { name: 'monoes Tools', status: 'pass', message: 'No known monotask/mono-agent/mono-clip install issues detected' };
-    }
-    return {
-        name: 'monoes Tools',
-        status: 'warn',
-        message: issues.map(i => i.message).join('; '),
-        fix: issues.map(i => i.fixCommand).join('  |  '),
-    };
-}
-export async function fixMonoesTools() {
-    output.writeln();
-    output.writeln(output.bold('Applying monoes tools fixes...'));
-    const issues = await findMonoesIssues();
-    if (issues.length === 0) {
-        output.writeln(output.dim('Nothing to fix.'));
-        return true;
-    }
-    let allOk = true;
-    for (const issue of issues) {
-        try {
-            // 2min timeout: generous enough for an interactive sudo password prompt
-            // (mono-agent's fix uses sudo mv), but still bounded — avoids hanging the
-            // whole `doctor --install` run on a stalled brew/curl network call.
-            execSync(issue.fixCommand, { encoding: 'utf8', stdio: 'inherit', shell: '/bin/bash', timeout: 120_000 });
-            output.writeln(output.success(`Fixed: ${issue.message}`));
-        }
-        catch (error) {
-            allOk = false;
-            output.writeln(output.warning(`Fix failed for: ${issue.message}`));
-            if (error instanceof Error)
-                output.writeln(output.dim(error.message));
-        }
-    }
-    return allOk;
-}
-//# sourceMappingURL=doctor-monoes-checks.js.map