@soleri/core 9.0.4 → 9.3.0

package/src/runtime/facades/vault-facade.ts

@@ -1,22 +1,31 @@
 /**
  * Vault facade — knowledge management ops.
- * search, CRUD, import/export, intake, archival.
+ * search, CRUD, capture, sharing scope.
+ * Archival and lifecycle ops are in archive-facade.ts.
+ * Sync ops (git, obsidian, packs) are in sync-facade.ts.
+ * Review ops are in review-facade.ts.
+ *
+ * Backward-compat stubs are appended at the end for ops that moved
+ * to new facades, so existing agents/CLAUDE.md files keep working.
  */
 
 import { z } from 'zod';
 import type { OpDefinition } from '../../facades/types.js';
 import type { IntelligenceEntry } from '../../intelligence/types.js';
-import type { VaultTier } from '../../vault/vault-types.js';
 import type { AgentRuntime } from '../types.js';
 import { createVaultExtraOps } from '../vault-extra-ops.js';
 import { createCaptureOps } from '../capture-ops.js';
-import { createIntakeOps } from '../intake-ops.js';
 import { createVaultSharingOps } from '../vault-sharing-ops.js';
+import { createArchiveOps } from '../archive-ops.js';
+import { createSyncOps } from '../sync-ops.js';
+import { createReviewOps } from '../review-ops.js';
 import { createVaultLinkingOps } from '../vault-linking-ops.js';
-import { ObsidianSync } from '../../vault/obsidian-sync.js';
+import { createBranchingOps } from '../branching-ops.js';
+import { createTierOps } from '../tier-ops.js';
+import { deprecationWarning } from '../deprecation.js';
 
 export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, intakePipeline, textIngester, vaultManager } = runtime;
+  const { vault, brain } = runtime;
 
   return [
     // ─── Search / Vault (inline from core-ops.ts) ───────────────
@@ -83,16 +92,37 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         tags: z.array(z.string()).optional(),
         limit: z.number().optional(),
         offset: z.number().optional(),
+        verbose: z.boolean().optional().describe('Return full entry objects instead of summaries'),
       }),
       handler: async (params) => {
-        return vault.list({
+        const verbose = params.verbose === true;
+        const entries = vault.list({
           domain: params.domain as string | undefined,
           type: params.type as string | undefined,
           severity: params.severity as string | undefined,
           tags: params.tags as string[] | undefined,
-          limit: (params.limit as number) ?? 50,
+          limit: (params.limit as number) ?? 20,
           offset: (params.offset as number) ?? 0,
         });
+        if (verbose) {
+          return entries;
+        }
+        // Return lightweight summaries to reduce response size
+        return (
+          entries as Array<{
+            id: string;
+            title: string;
+            type: string;
+            domain: string;
+            tags?: string[];
+          }>
+        ).map((e) => ({
+          id: e.id,
+          title: e.title,
+          type: e.type,
+          domain: e.domain,
+          tags: e.tags ?? [],
+        }));
       },
     },
     {
@@ -242,267 +272,38 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
-    // ─── Multi-vault ops ────────────────────────────────────────
-    {
-      name: 'vault_connect',
-      description:
-        'Connect an additional vault tier (project or team). Opens a separate SQLite database.',
-      auth: 'admin',
-      schema: z.object({
-        tier: z.enum(['project', 'team']).describe('Vault tier to connect'),
-        path: z.string().describe('Path to the SQLite database file'),
-      }),
-      handler: async (params) => {
-        const tier = params.tier as VaultTier;
-        const path = params.path as string;
-        vaultManager.open(tier, path);
-        return { connected: true, tier, path };
-      },
-    },
-    {
-      name: 'vault_disconnect',
-      description: 'Disconnect a vault tier. Cannot disconnect the agent tier.',
-      auth: 'admin',
-      schema: z.object({
-        tier: z.enum(['project', 'team']).describe('Vault tier to disconnect'),
-      }),
-      handler: async (params) => {
-        const tier = params.tier as VaultTier;
-        const removed = vaultManager.disconnect(tier);
-        return { disconnected: removed, tier };
-      },
-    },
-    {
-      name: 'vault_tiers',
-      description: 'List all vault tiers with connection status and entry counts.',
-      auth: 'read',
-      handler: async () => {
-        return { tiers: vaultManager.listTiers() };
-      },
-    },
-    {
-      name: 'vault_search_all',
-      description:
-        'Search across all connected vault tiers with priority-weighted cascading. Agent tier results ranked highest.',
-      auth: 'read',
-      schema: z.object({
-        query: z.string(),
-        limit: z.number().optional(),
-      }),
-      handler: async (params) => {
-        const results = vaultManager.search(params.query as string, (params.limit as number) ?? 20);
-        return { results, count: results.length };
-      },
-    },
-
-    // ─── Named vault connections ────────────────────────────────
-    {
-      name: 'vault_connect_source',
-      description:
-        'Connect a named vault source (e.g., shared team knowledge base) with a configurable search priority.',
-      auth: 'admin',
-      schema: z.object({
-        name: z.string().describe('Unique name for this vault connection'),
-        path: z.string().describe('Path to the SQLite database file'),
-        priority: z
-          .number()
-          .min(0)
-          .max(2)
-          .optional()
-          .describe('Search priority weight (default: 0.5)'),
-      }),
-      handler: async (params) => {
-        const name = params.name as string;
-        const path = params.path as string;
-        const priority = (params.priority as number) ?? 0.5;
-        vaultManager.connect(name, path, priority);
-        return { connected: true, name, path, priority };
-      },
-    },
-    {
-      name: 'vault_disconnect_source',
-      description: 'Disconnect a named vault source.',
-      auth: 'admin',
-      schema: z.object({
-        name: z.string().describe('Name of the vault connection to remove'),
-      }),
-      handler: async (params) => {
-        const name = params.name as string;
-        const removed = vaultManager.disconnectNamed(name);
-        return { disconnected: removed, name };
-      },
-    },
-    {
-      name: 'vault_list_sources',
-      description: 'List all dynamically connected vault sources with their priorities.',
-      auth: 'read',
-      handler: async () => {
-        return { sources: vaultManager.listConnected() };
-      },
-    },
-
-    // ─── Branching ─────────────────────────────────────────────
-    {
-      name: 'vault_branch',
-      description:
-        'Create a named vault branch for experimentation. Changes can be reviewed and merged later.',
-      auth: 'write',
-      schema: z.object({
-        name: z.string().describe('Unique branch name'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          vaultBranching.branch(params.name as string);
-          return { created: true, name: params.name };
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_branch_add',
-      description: 'Add an operation (add/modify/remove) to a vault branch.',
-      auth: 'write',
-      schema: z.object({
-        branchName: z.string().describe('Branch to add the operation to'),
-        entryId: z.string().describe('Entry ID'),
-        action: z.enum(['add', 'modify', 'remove']).describe('Operation type'),
-        entryData: z
-          .record(z.unknown())
-          .optional()
-          .describe('Full entry data (required for add/modify)'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          vaultBranching.addOperation(
-            params.branchName as string,
-            params.entryId as string,
-            params.action as 'add' | 'modify' | 'remove',
-            params.entryData as IntelligenceEntry | undefined,
-          );
-          return {
-            added: true,
-            branchName: params.branchName,
-            entryId: params.entryId,
-            action: params.action,
-          };
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_branch_list',
-      description: 'List all vault branches with entry counts and merge status.',
-      auth: 'read',
-      handler: async () => {
-        const { vaultBranching } = runtime;
-        return { branches: vaultBranching.listBranches() };
-      },
-    },
-    {
-      name: 'vault_merge_branch',
-      description: 'Merge a branch into the main vault. Branch entries win on conflict.',
-      auth: 'admin',
-      schema: z.object({
-        branchName: z.string().describe('Branch to merge'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          return vaultBranching.merge(params.branchName as string);
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_delete_branch',
-      description: 'Delete a vault branch and all its operations.',
-      auth: 'admin',
-      schema: z.object({
-        branchName: z.string().describe('Branch to delete'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        const deleted = vaultBranching.deleteBranch(params.branchName as string);
-        return { deleted, branchName: params.branchName };
-      },
-    },
-
-    // ─── Obsidian Sync ──────────────────────────────────────────
-    {
-      name: 'obsidian_export',
-      description:
-        'Export vault entries to Obsidian-compatible markdown files with YAML frontmatter. Creates domain subdirectories.',
-      auth: 'read',
-      schema: z.object({
-        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
-        types: z.array(z.string()).optional().describe('Filter by entry types'),
-        domains: z.array(z.string()).optional().describe('Filter by domains'),
-        dryRun: z.boolean().optional().describe('Preview without writing files'),
-      }),
-      handler: async (params) => {
-        const sync = new ObsidianSync({ vault });
-        return sync.export(params.obsidianDir as string, {
-          types: params.types as string[] | undefined,
-          domains: params.domains as string[] | undefined,
-          dryRun: params.dryRun as boolean | undefined,
-        });
-      },
-    },
-    {
-      name: 'obsidian_import',
-      description:
-        'Import Obsidian markdown files with YAML frontmatter into the vault. Parses title, type, domain, tags from frontmatter.',
-      auth: 'write',
-      schema: z.object({
-        obsidianDir: z.string().describe('Path to Obsidian vault directory to import from'),
-        defaultType: z
-          .string()
-          .optional()
-          .describe('Default type for entries without frontmatter type'),
-        defaultDomain: z.string().optional().describe('Default domain for entries without one'),
-        dryRun: z.boolean().optional().describe('Preview without modifying vault'),
-      }),
-      handler: async (params) => {
-        const sync = new ObsidianSync({ vault });
-        return sync.import(params.obsidianDir as string, {
-          defaultType: params.defaultType as string | undefined,
-          defaultDomain: params.defaultDomain as string | undefined,
-          dryRun: params.dryRun as boolean | undefined,
-        });
-      },
-    },
-    {
-      name: 'obsidian_sync',
-      description:
-        'Bidirectional sync between vault and Obsidian directory. Modes: push (vault→Obsidian), pull (Obsidian→vault), bidirectional.',
-      auth: 'write',
-      schema: z.object({
-        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
-        mode: z
-          .enum(['push', 'pull', 'bidirectional'])
-          .optional()
-          .describe('Sync mode. Default: bidirectional'),
-        dryRun: z.boolean().optional().describe('Preview without making changes'),
-      }),
-      handler: async (params) => {
-        const sync = new ObsidianSync({ vault });
-        return sync.sync(params.obsidianDir as string, {
-          mode: params.mode as 'push' | 'pull' | 'bidirectional' | undefined,
-          dryRun: params.dryRun as boolean | undefined,
-        });
-      },
-    },
-
     // ─── Satellite ops ───────────────────────────────────────────
     ...createVaultExtraOps(runtime),
     ...createCaptureOps(runtime),
-    ...createIntakeOps(intakePipeline, textIngester),
     ...createVaultSharingOps(runtime),
-    ...createVaultLinkingOps(runtime),
+
+    // ─── Backward-compat stubs for ops that moved to new facades ─
+    ...deprecateOps(createArchiveOps(runtime), 'archive'),
+    ...deprecateOps(createSyncOps(runtime), 'sync'),
+    ...deprecateOps(createReviewOps(runtime), 'review'),
+    ...deprecateOps(createVaultLinkingOps(runtime), 'links'),
+    ...deprecateOps(createBranchingOps(runtime), 'branching'),
+    ...deprecateOps(createTierOps(runtime), 'tier'),
   ];
 }
+
+// ─── Deprecation wrapper ────────────────────────────────────────────
+
+/**
+ * Wrap an array of ops with deprecation warnings.
+ * Each op's handler logs a one-time warning before forwarding to the real handler.
+ */
+export function deprecateOps(ops: OpDefinition[], newFacade: string): OpDefinition[] {
+  return ops.map((op) => ({
+    ...op,
+    handler: async (params: Record<string, unknown>) => {
+      deprecationWarning({
+        name: op.name,
+        since: '0.5.0',
+        replacement: `${newFacade}.${op.name}`,
+        message: `Op "${op.name}" has moved to the ${newFacade} facade. Update your calls.`,
+      });
+      return op.handler(params);
+    },
+  }));
+}

package/src/runtime/feature-flags.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Colocated unit tests for feature-flags.ts — filesystem + env var behavior.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { FeatureFlags } from './feature-flags.js';
+import { join } from 'node:path';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+
+describe('FeatureFlags', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'soleri-ff-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    for (const key of Object.keys(process.env)) {
+      if (key.startsWith('SOLERI_FLAG_')) delete process.env[key];
+    }
+  });
+
+  describe('defaults', () => {
+    it('has auth-enforcement off by default', () => {
+      expect(new FeatureFlags().isEnabled('auth-enforcement')).toBe(false);
+    });
+
+    it('has hot-reload on by default', () => {
+      expect(new FeatureFlags().isEnabled('hot-reload')).toBe(true);
+    });
+
+    it('has cognee-sync on by default', () => {
+      expect(new FeatureFlags().isEnabled('cognee-sync')).toBe(true);
+    });
+
+    it('has agency-mode off by default', () => {
+      expect(new FeatureFlags().isEnabled('agency-mode')).toBe(false);
+    });
+
+    it('returns false for unknown flags', () => {
+      expect(new FeatureFlags().isEnabled('does-not-exist')).toBe(false);
+    });
+  });
+
+  describe('file persistence', () => {
+    it('persists and loads flags from file', () => {
+      const path = join(tempDir, 'flags.json');
+      const f1 = new FeatureFlags(path);
+      f1.set('auth-enforcement', true);
+
+      const f2 = new FeatureFlags(path);
+      expect(f2.isEnabled('auth-enforcement')).toBe(true);
+    });
+
+    it('creates parent directories if needed', () => {
+      const path = join(tempDir, 'nested', 'deep', 'flags.json');
+      const flags = new FeatureFlags(path);
+      flags.set('hot-reload', false);
+      const data = JSON.parse(readFileSync(path, 'utf-8'));
+      expect(data['hot-reload']).toBe(false);
+    });
+
+    it('handles corrupt JSON gracefully', () => {
+      const path = join(tempDir, 'bad.json');
+      writeFileSync(path, '{{{invalid');
+      const flags = new FeatureFlags(path);
+      // Falls back to defaults
+      expect(flags.isEnabled('hot-reload')).toBe(true);
+    });
+
+    it('ignores non-boolean values in file', () => {
+      const path = join(tempDir, 'mixed.json');
+      writeFileSync(path, JSON.stringify({ 'hot-reload': 'yes', telemetry: false }));
+      const flags = new FeatureFlags(path);
+      // 'yes' is not boolean, so default (true) stays
+      expect(flags.isEnabled('hot-reload')).toBe(true);
+      expect(flags.isEnabled('telemetry')).toBe(false);
+    });
+
+    it('works in-memory when no file path given', () => {
+      const flags = new FeatureFlags();
+      flags.set('custom-flag', true);
+      expect(flags.isEnabled('custom-flag')).toBe(true);
+    });
+  });
+
+  describe('env var overrides', () => {
+    it('SOLERI_FLAG_TELEMETRY=false overrides default', () => {
+      process.env.SOLERI_FLAG_TELEMETRY = 'false';
+      expect(new FeatureFlags().isEnabled('telemetry')).toBe(false);
+    });
+
+    it('supports =1 as truthy', () => {
+      process.env.SOLERI_FLAG_AGENCY_MODE = '1';
+      expect(new FeatureFlags().isEnabled('agency-mode')).toBe(true);
+    });
+
+    it('env overrides file values', () => {
+      const path = join(tempDir, 'flags.json');
+      writeFileSync(path, JSON.stringify({ telemetry: true }));
+      process.env.SOLERI_FLAG_TELEMETRY = 'false';
+      expect(new FeatureFlags(path).isEnabled('telemetry')).toBe(false);
+    });
+
+    it('supports custom flag names via env', () => {
+      process.env.SOLERI_FLAG_MY_EXPERIMENT = 'true';
+      expect(new FeatureFlags().isEnabled('my-experiment')).toBe(true);
+    });
+  });
+
+  describe('getAll', () => {
+    it('includes all built-in flags', () => {
+      const all = new FeatureFlags().getAll();
+      expect(Object.keys(all)).toContain('auth-enforcement');
+      expect(Object.keys(all)).toContain('hot-reload');
+      expect(Object.keys(all)).toContain('telemetry');
+      expect(Object.keys(all)).toContain('cognee-sync');
+    });
+
+    it('reports source as env when env var set', () => {
+      process.env.SOLERI_FLAG_TELEMETRY = 'true';
+      const all = new FeatureFlags().getAll();
+      expect(all['telemetry'].source).toBe('env');
+    });
+
+    it('reports source as default for built-in without env', () => {
+      const all = new FeatureFlags().getAll();
+      expect(all['hot-reload'].source).toBe('default');
+    });
+
+    it('reports source as runtime for custom flags', () => {
+      const flags = new FeatureFlags();
+      flags.set('my-flag', true);
+      expect(flags.getAll()['my-flag'].source).toBe('runtime');
+      expect(flags.getAll()['my-flag'].description).toBe('Custom flag');
+    });
+  });
+});

package/src/runtime/github-integration.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseRemoteUrl,
+  extractIssueNumber,
+  detectGitHubRemote,
+  getIssueDetails,
+  closeIssueWithComment,
+} from './github-integration.js';
+
+describe('parseRemoteUrl', () => {
+  it('parses HTTPS remote with .git suffix', () => {
+    const result = parseRemoteUrl('https://github.com/acme/widget.git');
+    expect(result).toEqual({ owner: 'acme', repo: 'widget' });
+  });
+
+  it('parses HTTPS remote without .git suffix', () => {
+    const result = parseRemoteUrl('https://github.com/acme/widget');
+    expect(result).toEqual({ owner: 'acme', repo: 'widget' });
+  });
+
+  it('parses SSH remote with .git suffix', () => {
+    const result = parseRemoteUrl('git@github.com:acme/widget.git');
+    expect(result).toEqual({ owner: 'acme', repo: 'widget' });
+  });
+
+  it('parses SSH remote without .git suffix', () => {
+    const result = parseRemoteUrl('git@github.com:acme/widget');
+    expect(result).toEqual({ owner: 'acme', repo: 'widget' });
+  });
+
+  it('returns null for non-GitHub URLs', () => {
+    expect(parseRemoteUrl('https://gitlab.com/acme/widget.git')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(parseRemoteUrl('')).toBeNull();
+  });
+
+  it('returns null for random text', () => {
+    expect(parseRemoteUrl('not-a-url-at-all')).toBeNull();
+  });
+});
+
+describe('extractIssueNumber', () => {
+  it('extracts issue number from #NNN', () => {
+    expect(extractIssueNumber('fixes #42')).toBe(42);
+  });
+
+  it('extracts first match when multiple present', () => {
+    expect(extractIssueNumber('#10 and #20')).toBe(10);
+  });
+
+  it('returns null when no issue number', () => {
+    expect(extractIssueNumber('no issues here')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(extractIssueNumber('')).toBeNull();
+  });
+
+  it('handles issue in sentence context', () => {
+    expect(extractIssueNumber('closes #789 in this PR')).toBe(789);
+  });
+});
+
+describe('detectGitHubRemote', () => {
+  it('returns null when git command fails', async () => {
+    // Pass a path that is not a git repo
+    const result = await detectGitHubRemote('/tmp/definitely-not-a-repo-' + Date.now());
+    expect(result).toBeNull();
+  });
+});
+
+describe('getIssueDetails', () => {
+  it('returns null when gh CLI is not available or fails', async () => {
+    // gh issue view on a non-existent repo will fail
+    const result = await getIssueDetails('nonexistent-owner-xyz', 'nonexistent-repo-xyz', 99999);
+    expect(result).toBeNull();
+  });
+});
+
+describe('closeIssueWithComment', () => {
+  it('does not throw when gh CLI is not available', async () => {
+    // Should degrade gracefully
+    await expect(
+      closeIssueWithComment('nonexistent-owner-xyz', 'nonexistent-repo-xyz', 99999, 'test'),
+    ).resolves.toBeUndefined();
+  });
+});