@soleri/core 9.5.0 → 9.7.0

package/src/skills/trust-classifier.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { classifyTrust } from './trust-classifier.js';
+import { classifySkills, checkSkillCompatibility, ApprovalRequiredError } from './sync-skills.js';
+import type { SkillEntry } from './sync-skills.js';
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+let testDir: string;
+
+function setup(): string {
+  testDir = join(tmpdir(), `soleri-trust-test-${Date.now()}`);
+  mkdirSync(testDir, { recursive: true });
+  return testDir;
+}
+
+function createSkillDir(parentDir: string, name: string, files: Record<string, string>): string {
+  const dir = join(parentDir, name);
+  mkdirSync(dir, { recursive: true });
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = join(dir, filePath);
+    mkdirSync(join(fullPath, '..'), { recursive: true });
+    writeFileSync(fullPath, content);
+  }
+  return dir;
+}
+
+// =============================================================================
+// TrustClassifier
+// =============================================================================
+
+describe('TrustClassifier', () => {
+  beforeEach(() => setup());
+  afterEach(() => {
+    if (testDir) rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('classifies markdown-only directory', () => {
+    const dir = createSkillDir(testDir, 'md-skill', {
+      'SKILL.md': '---\nname: test\n---\n# Test Skill',
+      'reference.md': '# Reference doc',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('markdown_only');
+    expect(result.inventory).toHaveLength(2);
+    expect(result.inventory.find((i) => i.path === 'SKILL.md')?.kind).toBe('skill');
+    expect(result.inventory.find((i) => i.path === 'reference.md')?.kind).toBe('reference');
+  });
+
+  it('classifies directory with assets', () => {
+    const dir = createSkillDir(testDir, 'asset-skill', {
+      'SKILL.md': '# Skill',
+      'logo.png': 'fake-png-data',
+      'config.json': '{}',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('assets');
+    expect(result.inventory.find((i) => i.path === 'logo.png')?.kind).toBe('asset');
+    expect(result.inventory.find((i) => i.path === 'config.json')?.kind).toBe('asset');
+  });
+
+  it('classifies directory with scripts', () => {
+    const dir = createSkillDir(testDir, 'script-skill', {
+      'SKILL.md': '# Skill',
+      'setup.sh': '#!/bin/bash\necho hi',
+      'helper.ts': 'export const x = 1;',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('scripts');
+    expect(result.inventory.filter((i) => i.kind === 'script')).toHaveLength(2);
+  });
+
+  it('treats .d.ts files as reference, not scripts', () => {
+    const dir = createSkillDir(testDir, 'decl-skill', {
+      'SKILL.md': '# Skill',
+      'types.d.ts': 'export type Foo = string;',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('markdown_only');
+    expect(result.inventory.find((i) => i.path === 'types.d.ts')?.kind).toBe('reference');
+  });
+
+  it('returns markdown_only for empty directory', () => {
+    const dir = join(testDir, 'empty-skill');
+    mkdirSync(dir, { recursive: true });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('markdown_only');
+    expect(result.inventory).toHaveLength(0);
+  });
+
+  it('returns markdown_only for non-existent directory', () => {
+    const result = classifyTrust(join(testDir, 'nonexistent'));
+
+    expect(result.trust).toBe('markdown_only');
+    expect(result.inventory).toHaveLength(0);
+  });
+
+  it('handles nested directories', () => {
+    const dir = createSkillDir(testDir, 'nested-skill', {
+      'SKILL.md': '# Skill',
+      'sub/helper.js': 'module.exports = {};',
+      'sub/deep/readme.md': '# Deep',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.trust).toBe('scripts');
+    expect(result.inventory).toHaveLength(3);
+    expect(result.inventory.find((i) => i.path === 'sub/helper.js')?.kind).toBe('script');
+  });
+
+  it('skips hidden directories', () => {
+    const dir = createSkillDir(testDir, 'hidden-skill', {
+      'SKILL.md': '# Skill',
+      '.git/config': 'gitconfig',
+    });
+
+    const result = classifyTrust(dir);
+
+    expect(result.inventory.some((i) => i.path.includes('.git'))).toBe(false);
+  });
+});
+
+// =============================================================================
+// checkSkillCompatibility
+// =============================================================================
+
+describe('checkSkillCompatibility', () => {
+  it('returns unknown when no engine version specified', () => {
+    expect(checkSkillCompatibility(undefined, '9.6.0')).toBe('unknown');
+  });
+
+  it('returns unknown when no current version available', () => {
+    expect(checkSkillCompatibility('>=9.0.0', undefined)).toBe('unknown');
+  });
+
+  it('returns compatible for matching version', () => {
+    expect(checkSkillCompatibility('>=9.0.0', '9.6.0')).toBe('compatible');
+  });
+
+  it('returns invalid for incompatible version', () => {
+    expect(checkSkillCompatibility('>=10.0.0', '9.6.0')).toBe('invalid');
+  });
+
+  it('returns compatible for caret range', () => {
+    expect(checkSkillCompatibility('^9.0.0', '9.6.0')).toBe('compatible');
+  });
+
+  it('returns invalid for caret range with major mismatch', () => {
+    expect(checkSkillCompatibility('^10.0.0', '9.6.0')).toBe('invalid');
+  });
+});
+
+// =============================================================================
+// classifySkills (integration with approval gate)
+// =============================================================================
+
+describe('classifySkills', () => {
+  beforeEach(() => setup());
+  afterEach(() => {
+    if (testDir) rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('classifies markdown-only skills without error', () => {
+    createSkillDir(testDir, 'safe-skill', {
+      'SKILL.md': '---\nname: safe\n---\n# Safe Skill',
+    });
+
+    const skills: SkillEntry[] = [
+      { name: 'safe-skill', sourcePath: join(testDir, 'safe-skill', 'SKILL.md') },
+    ];
+
+    const result = classifySkills(skills);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].metadata?.trust).toBe('markdown_only');
+    expect(result[0].metadata?.compatibility).toBe('unknown');
+    expect(result[0].metadata?.source.type).toBe('local');
+  });
+
+  it('throws ApprovalRequiredError for scripts without approval', () => {
+    createSkillDir(testDir, 'risky-skill', {
+      'SKILL.md': '# Risky',
+      'run.sh': '#!/bin/bash\nrm -rf /',
+    });
+
+    const skills: SkillEntry[] = [
+      { name: 'risky-skill', sourcePath: join(testDir, 'risky-skill', 'SKILL.md') },
+    ];
+
+    expect(() => classifySkills(skills)).toThrow(ApprovalRequiredError);
+  });
+
+  it('allows scripts when explicitly approved', () => {
+    createSkillDir(testDir, 'approved-skill', {
+      'SKILL.md': '# Approved',
+      'setup.sh': '#!/bin/bash\necho ok',
+    });
+
+    const skills: SkillEntry[] = [
+      { name: 'approved-skill', sourcePath: join(testDir, 'approved-skill', 'SKILL.md') },
+    ];
+
+    const result = classifySkills(skills, {
+      approvedScripts: new Set(['approved-skill']),
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].metadata?.trust).toBe('scripts');
+  });
+
+  it('reads engine version from SKILL.md frontmatter', () => {
+    createSkillDir(testDir, 'versioned-skill', {
+      'SKILL.md': '---\nname: versioned\nengineVersion: ">=9.0.0"\n---\n# Versioned',
+    });
+
+    const skills: SkillEntry[] = [
+      { name: 'versioned-skill', sourcePath: join(testDir, 'versioned-skill', 'SKILL.md') },
+    ];
+
+    const result = classifySkills(skills, { currentEngineVersion: '9.6.0' });
+
+    expect(result[0].metadata?.engineVersion).toBe('>=9.0.0');
+    expect(result[0].metadata?.compatibility).toBe('compatible');
+  });
+
+  it('detects npm source type from node_modules path', () => {
+    const npmDir = join(testDir, 'node_modules', '@soleri', 'pack-test');
+    mkdirSync(npmDir, { recursive: true });
+    writeFileSync(join(npmDir, 'SKILL.md'), '---\nname: npm-skill\n---\n# NPM Skill');
+
+    const skills: SkillEntry[] = [{ name: 'npm-skill', sourcePath: join(npmDir, 'SKILL.md') }];
+
+    const result = classifySkills(skills);
+
+    expect(result[0].metadata?.source.type).toBe('npm');
+  });
+});

package/src/skills/trust-classifier.ts

@@ -0,0 +1,127 @@
+/**
+ * Trust Classifier — scans a skill directory and determines its trust level.
+ *
+ * Classification rules:
+ * - `.sh`, `.ts`, `.js` files (non-declaration) -> `scripts`
+ * - Non-`.md` files (images, JSON, etc.) -> `assets`
+ * - `.md` files only -> `markdown_only`
+ *
+ * Also builds a full inventory of all files with their classified kind.
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, extname, relative } from 'node:path';
+import type { TrustLevel, SkillInventoryItem } from '../packs/types.js';
+
+/** File extensions that indicate executable scripts */
+const SCRIPT_EXTENSIONS = new Set(['.sh', '.ts', '.js', '.mjs', '.cjs', '.py', '.rb', '.bash']);
+
+/** File extensions considered markdown/documentation */
+const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
+
+/** File extensions for TypeScript declaration files (not executable) */
+const DECLARATION_PATTERN = /\.d\.[mc]?ts$/;
+
+/**
+ * Classify a skill directory and return its trust level and inventory.
+ *
+ * @param dirPath - Absolute path to the skill directory
+ * @returns Trust level and full file inventory
+ */
+export function classifyTrust(dirPath: string): {
+  trust: TrustLevel;
+  inventory: SkillInventoryItem[];
+} {
+  if (!existsSync(dirPath)) {
+    return { trust: 'markdown_only', inventory: [] };
+  }
+
+  const inventory: SkillInventoryItem[] = [];
+  walkDir(dirPath, dirPath, inventory);
+
+  // Determine trust level from inventory
+  const hasScripts = inventory.some((item) => item.kind === 'script');
+  const hasAssets = inventory.some((item) => item.kind === 'asset');
+
+  let trust: TrustLevel;
+  if (hasScripts) {
+    trust = 'scripts';
+  } else if (hasAssets) {
+    trust = 'assets';
+  } else {
+    trust = 'markdown_only';
+  }
+
+  return { trust, inventory };
+}
+
+/**
+ * Namespace object for backward compatibility and namespaced access.
+ * Delegates to standalone `classifyTrust` function.
+ */
+export const TrustClassifier = {
+  classify(dirPath: string): Promise<{ trust: TrustLevel; inventory: SkillInventoryItem[] }> {
+    return Promise.resolve(classifyTrust(dirPath));
+  },
+};
+
+/** Recursively walk a directory and classify all files */
+function walkDir(rootDir: string, currentDir: string, inventory: SkillInventoryItem[]): void {
+  let names: string[];
+  try {
+    names = readdirSync(currentDir);
+  } catch {
+    return;
+  }
+
+  for (const name of names) {
+    const fullPath = join(currentDir, name);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      // Skip hidden directories and node_modules
+      if (name.startsWith('.') || name === 'node_modules') continue;
+      walkDir(rootDir, fullPath, inventory);
+      continue;
+    }
+
+    if (!stat.isFile()) continue;
+
+    const relPath = relative(rootDir, fullPath);
+    const ext = extname(name).toLowerCase();
+    const kind = classifyFile(name, ext);
+
+    inventory.push({ path: relPath, kind });
+  }
+}
+
+/** Classify a single file by its extension and name */
+function classifyFile(fileName: string, ext: string): SkillInventoryItem['kind'] {
+  // SKILL.md is the primary skill definition
+  if (fileName === 'SKILL.md' || fileName === 'skill.md') {
+    return 'skill';
+  }
+
+  // Declaration files are not executable
+  if (DECLARATION_PATTERN.test(fileName)) {
+    return 'reference';
+  }
+
+  // Script files
+  if (SCRIPT_EXTENSIONS.has(ext)) {
+    return 'script';
+  }
+
+  // Markdown files are references
+  if (MARKDOWN_EXTENSIONS.has(ext)) {
+    return 'reference';
+  }
+
+  // Everything else is an asset
+  return 'asset';
+}

package/src/subagent/concurrency-manager.ts

@@ -0,0 +1,89 @@
+/**
+ * Per-agent-type semaphore for controlling concurrent subagent runs.
+ *
+ * Pure promise-based — zero external deps. FIFO ordering guarantees
+ * the first waiter is the first to acquire a slot when one frees up.
+ */
+
+interface TypeState {
+  active: number;
+  waiters: Array<() => void>;
+}
+
+const DEFAULT_MAX_CONCURRENT = 3;
+
+export class ConcurrencyManager {
+  private state: Map<string, TypeState> = new Map();
+
+  /**
+   * Acquire a concurrency slot for the given adapter type.
+   * Resolves immediately if a slot is available, otherwise queues
+   * and resolves when a slot frees up (FIFO).
+   */
+  async acquire(type: string, maxConcurrent: number = DEFAULT_MAX_CONCURRENT): Promise<void> {
+    const entry = this.getOrCreate(type);
+
+    if (entry.active < maxConcurrent) {
+      entry.active++;
+      return;
+    }
+
+    // At capacity — park until a slot opens.
+    return new Promise<void>((resolve) => {
+      entry.waiters.push(() => {
+        entry.active++;
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Release a concurrency slot for the given adapter type.
+   * If waiters exist, the first one (FIFO) is unblocked.
+   * No-op if the type is not tracked.
+   */
+  release(type: string): void {
+    const entry = this.state.get(type);
+    if (!entry) return;
+
+    entry.active = Math.max(0, entry.active - 1);
+
+    if (entry.waiters.length > 0) {
+      const next = entry.waiters.shift()!;
+      next();
+    }
+  }
+
+  /** Return the number of active slots for a type (0 if untracked). */
+  getActive(type: string): number {
+    return this.state.get(type)?.active ?? 0;
+  }
+
+  /** Return the number of waiters queued for a type (0 if untracked). */
+  getWaiting(type: string): number {
+    return this.state.get(type)?.waiters.length ?? 0;
+  }
+
+  /** Clear all state, resolving any pending waiters immediately. */
+  reset(): void {
+    for (const entry of this.state.values()) {
+      for (const waiter of entry.waiters) {
+        waiter();
+      }
+      entry.waiters.length = 0;
+      entry.active = 0;
+    }
+    this.state.clear();
+  }
+
+  // ── internal ──────────────────────────────────────────────────────
+
+  private getOrCreate(type: string): TypeState {
+    let entry = this.state.get(type);
+    if (!entry) {
+      entry = { active: 0, waiters: [] };
+      this.state.set(type, entry);
+    }
+    return entry;
+  }
+}