monomind 1.17.1 → 1.18.0

package/packages/@monomind/cli/dist/src/commands/scan.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Scan Command
+ *
+ * Re-scans the working directory for content-type capabilities and
+ * persists an updated fingerprint to .monomind/.
+ */
+import type { Command } from '../types.js';
+export declare const scanCommand: Command;
+export default scanCommand;
+//# sourceMappingURL=scan.d.ts.map

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

@@ -0,0 +1,31 @@
+import { scanDirectory, saveFingerprint } from '../capabilities/scanner.js';
+import path from 'path';
+export const scanCommand = {
+    name: 'scan',
+    description: 'Scan directory and update capability fingerprint',
+    action: async (ctx) => {
+        try {
+            const scan = await scanDirectory(ctx.cwd);
+            const monomindDir = path.join(ctx.cwd, '.monomind');
+            await saveFingerprint(scan, monomindDir);
+            console.log(`\nScanned ${scan.totalFiles} files in ${scan.root}`);
+            console.log(`Git: ${scan.git ? 'yes' : 'no'}`);
+            console.log(`\nCapabilities detected:`);
+            for (const [name, score] of Object.entries(scan.capabilities)) {
+                if (score.confidence > 0.1) {
+                    console.log(`  ✓ ${name} (${(score.confidence * 100).toFixed(0)}% confidence, ${score.files} files)`);
+                }
+            }
+            const inactive = Object.entries(scan.capabilities).filter(([, s]) => s.confidence <= 0.1);
+            if (inactive.length > 0) {
+                console.log(`\nNot detected: ${inactive.map(([n]) => n).join(', ')}`);
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, message: error instanceof Error ? error.message : String(error) };
+        }
+    },
+};
+export default scanCommand;
+//# sourceMappingURL=scan.js.map

package/packages/@monomind/cli/dist/src/commands/search-universal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Universal Search Command
+ *
+ * Queries all activated capabilities via CapabilityManager.search() and
+ * renders merged, score-ranked results grouped by content type.
+ */
+import type { Command } from '../types.js';
+import type { SearchResult, CapabilityName } from '../capabilities/types.js';
+export declare function groupByType(results: SearchResult[]): Partial<Record<CapabilityName, SearchResult[]>>;
+export declare function formatSearchResults(results: SearchResult[]): string;
+export declare const searchUniversalCommand: Command;
+export default searchUniversalCommand;
+//# sourceMappingURL=search-universal.d.ts.map

package/packages/@monomind/cli/dist/src/commands/search-universal.js

@@ -0,0 +1,97 @@
+import { CapabilityManager } from '../capabilities/manager.js';
+import { loadFingerprint, listFiles } from '../capabilities/scanner.js';
+import { codeCapability } from '../capabilities/cap-code.js';
+import { documentsCapability } from '../capabilities/cap-documents.js';
+import { mediaCapability } from '../capabilities/cap-media.js';
+import { dataCapability } from '../capabilities/cap-data.js';
+import { graphCapability } from '../capabilities/cap-graph.js';
+import { timelineCapability } from '../capabilities/cap-timeline.js';
+import path from 'path';
+const TYPE_ICONS = {
+    documents: '📄',
+    media: '📷',
+    data: '📊',
+    code: '💻',
+    graph: '🔗',
+    timeline: '📅',
+};
+const TYPE_LABELS = {
+    documents: 'Documents',
+    media: 'Photos & Media',
+    data: 'Data Files',
+    code: 'Code',
+    graph: 'Related Files',
+    timeline: 'Timeline',
+};
+export function groupByType(results) {
+    const grouped = {};
+    for (const r of results) {
+        if (!grouped[r.type])
+            grouped[r.type] = [];
+        grouped[r.type].push(r);
+    }
+    return grouped;
+}
+export function formatSearchResults(results) {
+    if (results.length === 0)
+        return 'No results found.';
+    const grouped = groupByType(results);
+    const lines = [];
+    for (const [type, items] of Object.entries(grouped)) {
+        const icon = TYPE_ICONS[type] ?? '📁';
+        const label = TYPE_LABELS[type] ?? type;
+        lines.push(`\n${label}:`);
+        for (const item of items) {
+            lines.push(`  ${icon} ${item.path} — ${item.snippet}`);
+        }
+    }
+    return lines.join('\n');
+}
+export const searchUniversalCommand = {
+    name: 'search',
+    description: 'Search across all content types',
+    options: [
+        { name: 'limit', description: 'Max results', type: 'number' },
+        { name: 'type', description: 'Filter by type (documents, media, data, code)', type: 'string' },
+    ],
+    action: async (ctx) => {
+        const query = ctx.args.join(' ');
+        if (!query) {
+            return { success: false, message: 'Usage: monomind search <query>' };
+        }
+        const monomindDir = path.join(ctx.cwd, '.monomind');
+        const fingerprint = await loadFingerprint(monomindDir);
+        if (!fingerprint) {
+            console.log('No directory scan found. Run `monomind init` or `monomind scan` first.');
+            return { success: true };
+        }
+        const mgr = new CapabilityManager();
+        mgr.register(codeCapability);
+        mgr.register(documentsCapability);
+        mgr.register(mediaCapability);
+        mgr.register(dataCapability);
+        mgr.register(graphCapability);
+        mgr.register(timelineCapability);
+        try {
+            await mgr.activateFromScan(fingerprint, ctx.cwd, false);
+            const files = listFiles(ctx.cwd);
+            for (const module of mgr.getActive()) {
+                await module.index(files);
+            }
+        }
+        catch (err) {
+            return { success: false, message: `Failed to load capabilities: ${err instanceof Error ? err.message : String(err)}` };
+        }
+        const limit = ctx.flags.limit ?? 20;
+        const results = await mgr.search(query, limit);
+        const typeFilter = ctx.flags.type;
+        const filteredResults = typeFilter
+            ? results.filter((r) => r.type === typeFilter)
+            : results;
+        const output = formatSearchResults(filteredResults);
+        console.log(output);
+        return { success: true };
+    },
+};
+export default searchUniversalCommand;
+//# sourceMappingURL=search-universal.js.map

package/packages/@monomind/cli/dist/src/index.js

@@ -439,50 +439,21 @@ export class CLI {
         // Extra paths are read from MONOMIND_EXTRA_AGENT_PATHS env var (colon-separated)
         // or fall back to the known local path when available.
         try {
-            const { buildUnifiedRegistry } = await import('./agents/registry-builder.js');
+            const { buildUnifiedRegistry, computeAgentRoots } = await import('./agents/registry-builder.js');
             const { mkdirSync } = await import('fs');
             const { join } = await import('path');
-            const devAgentsRoot = join(process.cwd(), '.claude', 'agents');
-            const extraPaths = process.env.MONOMIND_EXTRA_AGENT_PATHS
-                ? process.env.MONOMIND_EXTRA_AGENT_PATHS.split(':').filter(Boolean)
-                : [];
-            // Fallback: well-known sibling path relative to project root (no hardcoded dev paths)
-            const { existsSync } = await import('fs');
-            const siblingExtraPath = join(process.cwd(), '..', 'agency-agents');
-            if (extraPaths.length === 0 && existsSync(siblingExtraPath)) {
-                extraPaths.push(siblingExtraPath);
-            }
-            // extras-first so they win deduplication; dev agents fill in the rest
-            const roots = [...extraPaths, devAgentsRoot];
+            const roots = computeAgentRoots(process.cwd());
             const outDir = join(process.cwd(), '.monomind');
             mkdirSync(outDir, { recursive: true });
             buildUnifiedRegistry(roots, join(outDir, 'registry.json'));
         }
         catch { /* optional — registry build failures must never block startup */ }
-        // Task 04: CapabilityMetadata — validate agent registry at startup
-        try {
-            const { readFileSync, existsSync, statSync: statSyncReg } = await import('fs');
-            const { join: pathJoin } = await import('path');
-            const registryPath = pathJoin(process.cwd(), '.monomind', 'registry.json');
-            const MAX_REGISTRY_BYTES = 10 * 1024 * 1024; // 10 MB
-            if (existsSync(registryPath) && statSyncReg(registryPath).size <= MAX_REGISTRY_BYTES) {
-                const registry = JSON.parse(readFileSync(registryPath, 'utf-8'));
-                const entries = registry.agents ?? [];
-                const issues = [];
-                for (const agent of entries) {
-                    if (!agent.slug)
-                        issues.push(`Agent missing 'slug'`);
-                    if (!agent.name)
-                        issues.push(`Agent ${String(agent.slug ?? '?')} missing 'name'`);
-                    if (!agent.description)
-                        issues.push(`Agent ${String(agent.slug ?? '?')} missing 'description'`);
-                }
-                if (issues.length > 0) {
-                    console.warn(`[CapabilityMetadata] ${issues.length} agent metadata issue(s) in registry — run 'monomind doctor' to review`);
-                }
-            }
-        }
-        catch { /* optional */ }
+        // Task 04: CapabilityMetadata validation moved to `monomind doctor -c registry`
+        // (see doctor-project-checks.ts:checkAgentRegistry). Printing this from a
+        // fire-and-forget startup task raced process exit — short-lived commands
+        // could skip the warning even when the underlying issue was present. Doctor
+        // runs it synchronously within its own check pass instead, so it's always
+        // visible and itemized when you actually look for it.
         // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
         // its consumers — `monomind route` and `monomind agent --task` (see
         // commands/route.ts and commands/agent.ts). It is intentionally NOT

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -297,6 +297,33 @@ export async function executeInit(options) {
         }
         // Create directory structure
         await createDirectories(targetDir, options, result);
+        // Scan directory and save fingerprint (non-fatal if failed)
+        let capMgr = null;
+        try {
+            const { scanDirectory, saveFingerprint, CapabilityManager, codeCapability, documentsCapability, mediaCapability, timelineCapability, graphCapability, dataCapability } = await import('../capabilities/index.js');
+            const scan = await scanDirectory(targetDir);
+            const monomindDir = path.join(targetDir, '.monomind');
+            await saveFingerprint(scan, monomindDir);
+            // Activate capabilities
+            capMgr = new CapabilityManager();
+            capMgr.register(codeCapability);
+            capMgr.register(documentsCapability);
+            capMgr.register(mediaCapability);
+            capMgr.register(timelineCapability);
+            capMgr.register(graphCapability);
+            capMgr.register(dataCapability);
+            await capMgr.activateFromScan(scan, targetDir);
+            // Print capability-aware messaging (always show active capabilities,
+            // regardless of whether 'code' is also active, so mixed projects get feedback)
+            console.log('\nActivating capabilities:');
+            for (const cap of capMgr.getActive()) {
+                console.log(`  ✓ ${cap.name}`);
+            }
+        }
+        catch (scanError) {
+            // Scanner/fingerprint/activation failed — non-fatal, continue without capabilities
+            result.skipped.push(`directory scan: ${scanError instanceof Error ? scanError.message : String(scanError)}`);
+        }
         // Generate and write settings.json
         if (options.components.settings) {
             await writeSettings(targetDir, options, result);
@@ -341,10 +368,13 @@ export async function executeInit(options) {
         writeSharedInstructions(targetDir, options.force, result);
         // Count enabled hooks
         result.summary.hooksEnabled = countEnabledHooks(options);
-        // Build knowledge graph in background (non-blocking)
-        if (options.components.graphify) {
+        // Build knowledge graph in background (non-blocking) — code-project only
+        if (options.components.graphify && (capMgr === null || capMgr.isActive('code'))) {
             await initKnowledgeGraph(targetDir, result);
         }
+        else if (options.components.graphify) {
+            result.skipped.push('knowledge graph: not a code project (skipping monograph indexing)');
+        }
         // Start daemon with background workers (non-blocking)
         await startDaemonBackground(targetDir, result);
         // Run doctor auto-fix (non-blocking, best-effort)