@soleri/core 9.0.4 → 9.2.0

package/src/runtime/vault-sharing-ops.ts

@@ -1,27 +1,20 @@
 /**
- * Vault Sharing Ops — knowledge scoping, export, sync, and review ops.
+ * Vault Sharing Ops — knowledge scoping operations.
  *
  * Covers:
  * - #105: Knowledge scoping (detect_scope, set_scope, scope-aware filtering)
- * - #104: Vault export to shareable packs
- * - #67: Vault push/pull git sync with conflict resolution
- * - #65: Team review workflows (submit/approve/reject)
+ *
+ * Git/Obsidian/pack sync ops → sync-ops.ts (sync facade)
+ * Review workflow ops → review-ops.ts (review facade)
  */
 
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import { detectScope, type ScopeInput } from '../vault/scope-detector.js';
-import { GitVaultSync, type GitVaultSyncConfig } from '../vault/git-vault-sync.js';
-import type {
-  IntelligenceEntry,
-  IntelligenceBundle,
-  IntelligenceBundleLink,
-} from '../intelligence/types.js';
-import { LinkManager } from '../vault/linking.js';
 
 export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, knowledgeReview } = runtime;
+  const { vault } = runtime;
 
   return [
     // ─── Scoping (#105) ───────────────────────────────────────────
@@ -110,322 +103,5 @@ export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
         return { entries, count: entries.length, tier };
       },
     },
-
-    // ─── Export to Pack (#104) ─────────────────────────────────────
-    {
-      name: 'vault_export_pack',
-      description:
-        'Export vault entries as a shareable intelligence pack. Filters by tier, domain, or tags. Returns IntelligenceBundle format.',
-      auth: 'read' as const,
-      schema: z.object({
-        name: z.string().optional().describe('Pack name (default: agent ID)'),
-        version: z.string().optional().describe('Pack version (default: 1.0.0)'),
-        tier: z.enum(['agent', 'project', 'team']).optional().describe('Filter by scope tier'),
-        domain: z.string().optional().describe('Filter by domain'),
-        tags: z.array(z.string()).optional().describe('Filter by tags (OR match)'),
-        excludeIds: z.array(z.string()).optional().describe('Entry IDs to exclude'),
-      }),
-      handler: async (params) => {
-        const tier = params.tier as string | undefined;
-        const domain = params.domain as string | undefined;
-        const tags = params.tags as string[] | undefined;
-        const excludeIds = new Set((params.excludeIds as string[] | undefined) ?? []);
-
-        // Get all matching entries
-        let entries = vault.list({ domain, tags, limit: 10000 });
-
-        // Filter by tier if specified
-        if (tier) {
-          entries = entries.filter((e) => e.tier === tier);
-        }
-
-        // Exclude specified IDs
-        if (excludeIds.size > 0) {
-          entries = entries.filter((e) => !excludeIds.has(e.id));
-        }
-
-        // Group by domain into bundles
-        const byDomain = new Map<string, IntelligenceEntry[]>();
-        for (const entry of entries) {
-          const d = entry.domain;
-          if (!byDomain.has(d)) byDomain.set(d, []);
-          byDomain.get(d)!.push(entry);
-        }
-
-        // Collect links for exported entries (Zettelkasten edge export)
-        const entryIds = new Set(entries.map((e) => e.id));
-        const linkManager = new LinkManager(vault.getProvider());
-        const allLinks = linkManager.getAllLinksForEntries([...entryIds]);
-        // Only include links where BOTH endpoints are in the export set
-        const exportLinks = allLinks.filter(
-          (l) => entryIds.has(l.sourceId) && entryIds.has(l.targetId),
-        );
-
-        // Build a domain→links map (group by source entry's domain)
-        const entryDomainMap = new Map(entries.map((e) => [e.id, e.domain]));
-        const linksByDomain = new Map<string, IntelligenceBundleLink[]>();
-        for (const link of exportLinks) {
-          const linkDomain = entryDomainMap.get(link.sourceId) ?? 'unknown';
-          if (!linksByDomain.has(linkDomain)) linksByDomain.set(linkDomain, []);
-          linksByDomain.get(linkDomain)!.push({
-            sourceId: link.sourceId,
-            targetId: link.targetId,
-            linkType: link.linkType,
-            note: link.note,
-          });
-        }
-
-        const version = (params.version as string) ?? '1.0.0';
-        const bundles: IntelligenceBundle[] = [];
-        for (const [d, domainEntries] of byDomain) {
-          bundles.push({
-            domain: d,
-            version,
-            entries: domainEntries,
-            links: linksByDomain.get(d) ?? [],
-          });
-        }
-
-        return {
-          name: (params.name as string) ?? runtime.config.agentId,
-          version,
-          bundles,
-          totalEntries: entries.length,
-          totalLinks: exportLinks.length,
-          domains: [...byDomain.keys()],
-        };
-      },
-    },
-    {
-      name: 'vault_import_pack',
-      description:
-        'Import an intelligence pack into the vault with content-hash dedup. Entries with duplicate content are skipped.',
-      auth: 'write' as const,
-      schema: z.object({
-        bundles: z
-          .array(
-            z.object({
-              domain: z.string(),
-              version: z.string(),
-              entries: z.array(z.record(z.unknown())),
-            }),
-          )
-          .describe('Array of IntelligenceBundle objects to import'),
-        tier: z
-          .enum(['agent', 'project', 'team'])
-          .optional()
-          .describe('Force all imported entries to this tier'),
-      }),
-      handler: async (params) => {
-        const bundles = params.bundles as Array<{
-          domain: string;
-          version: string;
-          entries: IntelligenceEntry[];
-          links?: IntelligenceBundleLink[];
-        }>;
-        const forceTier = params.tier as 'agent' | 'project' | 'team' | undefined;
-        let imported = 0;
-        let duplicates = 0;
-        let linksCreated = 0;
-        let linksSkipped = 0;
-
-        // Track ID remapping: bundle entry ID → actual vault entry ID
-        const idRemap = new Map<string, string>();
-        const linkManager = new LinkManager(vault.getProvider());
-
-        for (const bundle of bundles) {
-          const entries = bundle.entries.map((e) => ({
-            ...e,
-            tier: forceTier ?? e.tier ?? 'project',
-          }));
-          const results = vault.seedDedup(entries);
-          for (let i = 0; i < results.length; i++) {
-            const r = results[i];
-            const originalId = bundle.entries[i].id;
-            // For duplicates, map to the existing vault entry; for inserts, keep original ID
-            idRemap.set(originalId, r.existingId ?? r.id);
-            if (r.action === 'inserted') imported++;
-            else duplicates++;
-          }
-
-          // Import links if present
-          if (bundle.links && bundle.links.length > 0) {
-            for (const link of bundle.links) {
-              const sourceId = idRemap.get(link.sourceId);
-              const targetId = idRemap.get(link.targetId);
-              if (sourceId && targetId) {
-                linkManager.addLink(sourceId, targetId, link.linkType, link.note);
-                linksCreated++;
-              } else {
-                linksSkipped++;
-              }
-            }
-          }
-        }
-
-        return { imported, duplicates, linksCreated, linksSkipped, total: imported + duplicates };
-      },
-    },
-
-    // ─── Git Sync (#67) ───────────────────────────────────────────
-    {
-      name: 'vault_git_push',
-      description:
-        'Push all vault entries to a git-tracked directory. Each entry becomes a JSON file under domain subdirectories.',
-      auth: 'write' as const,
-      schema: z.object({
-        repoDir: z.string().describe('Path to git-tracked vault directory'),
-        authorName: z.string().optional().describe('Git author name'),
-        authorEmail: z.string().optional().describe('Git author email'),
-      }),
-      handler: async (params) => {
-        const config: GitVaultSyncConfig = {
-          repoDir: params.repoDir as string,
-          authorName: params.authorName as string | undefined,
-          authorEmail: params.authorEmail as string | undefined,
-        };
-        const sync = new GitVaultSync(config);
-        await sync.init();
-        const { entries } = vault.exportAll();
-        return sync.syncAll(entries);
-      },
-    },
-    {
-      name: 'vault_git_pull',
-      description:
-        'Pull entries from a git-tracked directory into the vault. Reads JSON files and imports with conflict resolution.',
-      auth: 'write' as const,
-      schema: z.object({
-        repoDir: z.string().describe('Path to git-tracked vault directory'),
-        onConflict: z
-          .enum(['git', 'vault'])
-          .optional()
-          .describe(
-            'Conflict resolution: "git" (default) overwrites vault, "vault" keeps existing',
-          ),
-      }),
-      handler: async (params) => {
-        const config: GitVaultSyncConfig = {
-          repoDir: params.repoDir as string,
-          autoCommit: false,
-        };
-        const sync = new GitVaultSync(config);
-        await sync.init();
-        return sync.pull(vault, {
-          onConflict: params.onConflict as 'git' | 'vault' | undefined,
-        });
-      },
-    },
-    {
-      name: 'vault_git_sync',
-      description:
-        'Bidirectional sync between vault and git directory. Pushes vault entries to git and pulls git-only entries into vault.',
-      auth: 'write' as const,
-      schema: z.object({
-        repoDir: z.string().describe('Path to git-tracked vault directory'),
-        onConflict: z
-          .enum(['git', 'vault'])
-          .optional()
-          .describe('Conflict resolution for entries that exist in both'),
-        authorName: z.string().optional(),
-        authorEmail: z.string().optional(),
-      }),
-      handler: async (params) => {
-        const config: GitVaultSyncConfig = {
-          repoDir: params.repoDir as string,
-          authorName: params.authorName as string | undefined,
-          authorEmail: params.authorEmail as string | undefined,
-        };
-        const sync = new GitVaultSync(config);
-        await sync.init();
-        return sync.sync(vault, {
-          onConflict: params.onConflict as 'git' | 'vault' | undefined,
-        });
-      },
-    },
-
-    // ─── Review Workflows (#65) ───────────────────────────────────
-    {
-      name: 'vault_submit_review',
-      description:
-        'Submit a vault entry for team review. Transitions entry from draft → pending_review.',
-      auth: 'write' as const,
-      schema: z.object({
-        entryId: z.string().describe('Entry ID to submit for review'),
-        submittedBy: z.string().optional().describe('Name/ID of the submitter'),
-      }),
-      handler: async (params) => {
-        try {
-          return knowledgeReview.submit({
-            entryId: params.entryId as string,
-            submittedBy: params.submittedBy as string | undefined,
-          });
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_approve',
-      description: 'Approve a pending vault entry. Transitions from pending_review → approved.',
-      auth: 'admin' as const,
-      schema: z.object({
-        entryId: z.string().describe('Entry ID to approve'),
-        reviewedBy: z.string().optional().describe('Name/ID of the reviewer'),
-        comment: z.string().optional().describe('Review comment'),
-      }),
-      handler: async (params) => {
-        try {
-          return knowledgeReview.approve({
-            entryId: params.entryId as string,
-            reviewedBy: params.reviewedBy as string | undefined,
-            comment: params.comment as string | undefined,
-          });
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_reject',
-      description: 'Reject a pending vault entry. Transitions from pending_review → rejected.',
-      auth: 'admin' as const,
-      schema: z.object({
-        entryId: z.string().describe('Entry ID to reject'),
-        reviewedBy: z.string().optional().describe('Name/ID of the reviewer'),
-        comment: z.string().optional().describe('Reason for rejection'),
-      }),
-      handler: async (params) => {
-        try {
-          return knowledgeReview.reject({
-            entryId: params.entryId as string,
-            reviewedBy: params.reviewedBy as string | undefined,
-            comment: params.comment as string | undefined,
-          });
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_pending_reviews',
-      description: 'List all vault entries pending team review.',
-      auth: 'read' as const,
-      schema: z.object({
-        limit: z.number().optional().describe('Max entries to return'),
-      }),
-      handler: async (params) => {
-        const pending = knowledgeReview.listPending((params.limit as number) ?? 50);
-        return { pending, count: pending.length };
-      },
-    },
-    {
-      name: 'vault_review_stats',
-      description: 'Get review workflow statistics — counts by status.',
-      auth: 'read' as const,
-      handler: async () => {
-        return knowledgeReview.stats();
-      },
-    },
   ];
 }

package/src/skills/sync-skills.ts

@@ -0,0 +1,108 @@
+/**
+ * Skill sync — discovers SKILL.md files in agent skills directories
+ * and copies them to ~/.claude/commands/ for Claude Code discovery.
+ *
+ * Injects agent branding so users know which agent owns the skill.
+ * Called automatically at engine startup and by admin_setup_global.
+ */
+
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  statSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export interface SkillEntry {
+  name: string;
+  sourcePath: string;
+}
+
+export interface SyncResult {
+  installed: string[];
+  updated: string[];
+  skipped: string[];
+  failed: string[];
+}
+
+/** Discover skill files (SKILL.md) in skills directories */
+export function discoverSkills(skillsDirs: string[]): SkillEntry[] {
+  const skills: SkillEntry[] = [];
+
+  for (const dir of skillsDirs) {
+    if (!existsSync(dir)) continue;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = join(dir, entry.name, 'SKILL.md');
+      if (existsSync(skillPath)) {
+        skills.push({ name: entry.name, sourcePath: skillPath });
+      }
+    }
+  }
+
+  return skills;
+}
+
+/** Inject agent branding after YAML frontmatter */
+function brandSkillContent(content: string, agentName: string): string {
+  // Find end of frontmatter (second ---)
+  const fmEnd = content.indexOf('---', content.indexOf('---') + 3);
+  if (fmEnd === -1) return content;
+
+  const afterFm = fmEnd + 3;
+  const before = content.slice(0, afterFm);
+  const after = content.slice(afterFm);
+
+  const brandLine = `\n\n> **${agentName}** skill\n`;
+  return before + brandLine + after;
+}
+
+/**
+ * Sync skills from agent directory to ~/.claude/commands/.
+ * - New skills are installed with agent branding
+ * - Changed skills are overwritten (compared by mtime)
+ * - Missing source skills leave target untouched (other agents may own them)
+ */
+export function syncSkillsToClaudeCode(
+  skillsDirs: string[],
+  agentName?: string,
+): SyncResult {
+  const commandsDir = join(homedir(), '.claude', 'commands');
+  const skills = discoverSkills(skillsDirs);
+  const result: SyncResult = { installed: [], updated: [], skipped: [], failed: [] };
+
+  if (skills.length === 0) return result;
+
+  mkdirSync(commandsDir, { recursive: true });
+
+  for (const skill of skills) {
+    const targetPath = join(commandsDir, `${skill.name}.md`);
+    try {
+      const sourceContent = readFileSync(skill.sourcePath, 'utf-8');
+      const branded = agentName ? brandSkillContent(sourceContent, agentName) : sourceContent;
+
+      if (!existsSync(targetPath)) {
+        writeFileSync(targetPath, branded);
+        result.installed.push(skill.name);
+      } else {
+        const sourceMtime = statSync(skill.sourcePath).mtimeMs;
+        const targetMtime = statSync(targetPath).mtimeMs;
+        if (sourceMtime > targetMtime) {
+          writeFileSync(targetPath, branded);
+          result.updated.push(skill.name);
+        } else {
+          result.skipped.push(skill.name);
+        }
+      }
+    } catch {
+      result.failed.push(skill.name);
+    }
+  }
+
+  return result;
+}

package/src/streams/normalize.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { normalize, collect } from './normalize.js';
+
+// ─── normalize ───────────────────────────────────────────────────────
+
+describe('normalize', () => {
+  it('yields a single value', async () => {
+    const result = await collect(normalize(42));
+    expect(result).toEqual([42]);
+  });
+
+  it('yields a flat array', async () => {
+    const result = await collect(normalize([1, 2, 3]));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('resolves a promise of a single value', async () => {
+    const result = await collect(normalize(Promise.resolve('hello')));
+    expect(result).toEqual(['hello']);
+  });
+
+  it('resolves a promise of an array', async () => {
+    const result = await collect(normalize(Promise.resolve([10, 20])));
+    expect(result).toEqual([10, 20]);
+  });
+
+  it('flattens an async iterable', async () => {
+    async function* gen(): AsyncIterable<number> {
+      yield 1;
+      yield 2;
+      yield 3;
+    }
+    const result = await collect(normalize(gen()));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('flattens nested sync iterables', async () => {
+    const nested = [[1, 2], [3], [4, 5]];
+    const result = await collect(normalize(nested));
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('treats strings as leaf values (not iterables)', async () => {
+    const result = await collect(normalize('hello'));
+    expect(result).toEqual(['hello']);
+  });
+
+  it('treats an array of strings as individual leaves', async () => {
+    const result = await collect(normalize(['a', 'b', 'c']));
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  it('handles mixed nested structure', async () => {
+    async function* gen(): AsyncIterable<number> {
+      yield 100;
+    }
+    const mixed = [1, [2, 3], Promise.resolve(4), gen()];
+    // normalize expects NestableInput<number>, but mixed iterables work
+    const result: number[] = [];
+    for await (const item of normalize<number>(mixed as never)) {
+      result.push(item);
+    }
+    expect(result).toEqual([1, 2, 3, 4, 100]);
+  });
+
+  it('handles empty array', async () => {
+    const result = await collect(normalize([]));
+    expect(result).toEqual([]);
+  });
+
+  it('handles deeply nested arrays', async () => {
+    const deep = [[[1]], [[2, 3]]];
+    const result = await collect(normalize(deep));
+    expect(result).toEqual([1, 2, 3]);
+  });
+});
+
+// ─── collect ─────────────────────────────────────────────────────────
+
+describe('collect', () => {
+  it('collects async iterable into array', async () => {
+    async function* gen(): AsyncIterable<string> {
+      yield 'a';
+      yield 'b';
+    }
+    expect(await collect(gen())).toEqual(['a', 'b']);
+  });
+
+  it('returns empty array for empty source', async () => {
+    async function* empty(): AsyncIterable<never> {
+      // nothing
+    }
+    expect(await collect(empty())).toEqual([]);
+  });
+});