@highway1/core 0.1.53 → 0.1.55

package/src/discovery/search-index.ts

@@ -1,247 +0,0 @@
-/**
- * Search Index for Agent Discovery
- *
- * Maintains a local index of discovered agents for fast semantic search
- */
-
-import lunr from 'lunr';
-import Fuse from 'fuse.js';
-import type { AgentCard } from './agent-card-types.js';
-import { createLogger } from '../utils/logger.js';
-
-const logger = createLogger('search-index');
-
-/**
- * Semantic Query Interface
- */
-export interface SemanticQuery {
-  text?: string;              // Natural language: "translate Japanese"
-  capability?: string;        // Structured: "translate"
-  filters?: {
-    language?: string;
-    minTrustScore?: number;
-    maxCost?: number;
-    tags?: string[];
-  };
-  limit?: number;
-}
-
-/**
- * Search Result with Score
- */
-export interface SearchResult {
-  card: AgentCard;
-  score: number;
-}
-
-/**
- * Search Index Implementation
- */
-export class SearchIndex {
-  private cards = new Map<string, AgentCard>();
-  private lunrIndex?: lunr.Index;
-  private fuse?: Fuse<AgentCard>;
-  private needsRebuild = false;
-
-  /**
-   * Add or update an Agent Card in the index
-   */
-  indexAgentCard(card: AgentCard): void {
-    this.cards.set(card.did, card);
-    this.needsRebuild = true;
-    logger.debug('Indexed Agent Card', { did: card.did, capabilities: card.capabilities.length });
-  }
-
-  /**
-   * Remove an Agent Card from the index
-   */
-  removeAgentCard(did: string): void {
-    this.cards.delete(did);
-    this.needsRebuild = true;
-    logger.debug('Removed Agent Card from index', { did });
-  }
-
-  /**
-   * Search for agents matching a query
-   */
-  search(query: SemanticQuery): SearchResult[] {
-    if (this.needsRebuild) {
-      this.rebuild();
-    }
-
-    let results: SearchResult[] = [];
-
-    // Text search using Lunr
-    if (query.text && this.lunrIndex) {
-      results = this.searchByText(query.text);
-    }
-    // Capability search using Fuse
-    else if (query.capability && this.fuse) {
-      results = this.searchByCapability(query.capability);
-    }
-    // No query - return all
-    else {
-      results = Array.from(this.cards.values()).map(card => ({
-        card,
-        score: 1.0,
-      }));
-    }
-
-    // Apply filters
-    if (query.filters) {
-      results = this.applyFilters(results, query.filters);
-    }
-
-    // Sort by score (descending)
-    results.sort((a, b) => b.score - a.score);
-
-    // Apply limit
-    if (query.limit) {
-      results = results.slice(0, query.limit);
-    }
-
-    logger.debug('Search completed', { query, results: results.length });
-    return results;
-  }
-
-  /**
-   * Get all indexed cards
-   */
-  getAllCards(): AgentCard[] {
-    return Array.from(this.cards.values());
-  }
-
-  /**
-   * Clear the index
-   */
-  clear(): void {
-    this.cards.clear();
-    this.lunrIndex = undefined;
-    this.fuse = undefined;
-    this.needsRebuild = false;
-    logger.info('Search index cleared');
-  }
-
-  /**
-   * Get index size
-   */
-  size(): number {
-    return this.cards.size;
-  }
-
-  /**
-   * Rebuild search indexes
-   */
-  private rebuild(): void {
-    logger.info('Rebuilding search indexes', { cards: this.cards.size });
-
-    const cards = Array.from(this.cards.values());
-
-    // Build Lunr index for full-text search
-    this.lunrIndex = lunr(function (this: lunr.Builder) {
-      this.ref('did');
-      this.field('name', { boost: 10 });
-      this.field('description', { boost: 5 });
-      this.field('capabilities');
-
-      for (const card of cards) {
-        this.add({
-          did: card.did,
-          name: card.name,
-          description: card.description,
-          capabilities: card.capabilities
-            .map((cap: any) => `${cap.name} ${cap.description}`)
-            .join(' '),
-        });
-      }
-    });
-
-    // Build Fuse index for fuzzy matching
-    this.fuse = new Fuse(Array.from(this.cards.values()), {
-      keys: [
-        { name: 'name', weight: 0.3 },
-        { name: 'description', weight: 0.2 },
-        { name: 'capabilities.name', weight: 0.3 },
-        { name: 'capabilities.description', weight: 0.2 },
-      ],
-      threshold: 0.4,
-      includeScore: true,
-    });
-
-    this.needsRebuild = false;
-    logger.info('Search indexes rebuilt');
-  }
-
-  /**
-   * Search by text using Lunr
-   */
-  private searchByText(text: string): SearchResult[] {
-    if (!this.lunrIndex) return [];
-
-    const lunrResults = this.lunrIndex.search(text);
-    return lunrResults.map(result => ({
-      card: this.cards.get(result.ref)!,
-      score: result.score,
-    }));
-  }
-
-  /**
-   * Search by capability using Fuse
-   */
-  private searchByCapability(capability: string): SearchResult[] {
-    if (!this.fuse) return [];
-
-    const fuseResults = this.fuse.search(capability);
-    return fuseResults.map(result => ({
-      card: result.item,
-      score: 1 - (result.score || 0), // Fuse score is distance, convert to similarity
-    }));
-  }
-
-  /**
-   * Apply filters to search results
-   */
-  private applyFilters(
-    results: SearchResult[],
-    filters: NonNullable<SemanticQuery['filters']>
-  ): SearchResult[] {
-    return results.filter(result => {
-      const { card } = result;
-
-      // Trust score filter
-      if (filters.minTrustScore !== undefined && card.trust) {
-        const overallTrust =
-          card.trust.interactionScore * 0.4 +
-          Math.min(card.trust.endorsements / 10, 1) * 0.2 +
-          card.trust.completionRate * 0.2 +
-          card.trust.uptime * 0.2;
-
-        if (overallTrust < filters.minTrustScore) {
-          return false;
-        }
-      }
-
-      // Language filter (check capability metadata)
-      if (filters.language) {
-        const hasLanguage = card.capabilities.some(
-          cap => {
-            const metadata = cap.metadata as Record<string, any> | undefined;
-            if (!metadata) return false;
-            return metadata.language === filters.language ||
-                   (Array.isArray(metadata.languages) && metadata.languages.includes(filters.language));
-          }
-        );
-        if (!hasLanguage) return false;
-      }
-
-      // Tags filter
-      if (filters.tags && filters.tags.length > 0) {
-        const cardTags = Array.isArray(card.metadata?.tags) ? (card.metadata.tags as string[]) : [];
-        const hasAllTags = filters.tags.every(tag => cardTags.includes(tag));
-        if (!hasAllTags) return false;
-      }
-
-      return true;
-    });
-  }
-}

package/src/discovery/semantic-search.ts

@@ -1,218 +0,0 @@
-/**
- * Semantic Search Engine
- *
- * Provides intelligent agent discovery through semantic search
- * with local-first strategy and network fallback
- */
-
-import type { AgentCard } from './agent-card-types.js';
-import { SearchIndex } from './search-index.js';
-import type { SemanticQuery, SearchResult } from './search-index.js';
-import { CapabilityMatcher } from './capability-matcher.js';
-import type { DHTOperations } from './dht.js';
-import { createLogger } from '../utils/logger.js';
-
-const logger = createLogger('semantic-search');
-
-/**
- * Semantic Search Engine
- */
-export class SemanticSearchEngine {
-  private index: SearchIndex;
-  private matcher: CapabilityMatcher;
-
-  constructor(private dht?: DHTOperations) {
-    this.index = new SearchIndex();
-    this.matcher = new CapabilityMatcher();
-  }
-
-  /**
-   * Main search interface
-   * Local-first with network fallback
-   */
-  async search(query: SemanticQuery): Promise<AgentCard[]> {
-    logger.info('Searching for agents', { query });
-
-    // 1. Search local index
-    const localResults = this.index.search(query);
-    logger.debug('Local search results', { count: localResults.length });
-
-    // 2. If insufficient results, query network
-    const limit = query.limit || 10;
-    if (localResults.length < limit && this.dht) {
-      logger.debug('Insufficient local results, querying network');
-      const networkResults = await this.searchNetwork(query);
-      return this.mergeResults(localResults, networkResults, limit);
-    }
-
-    return localResults.map(r => r.card);
-  }
-
-  /**
-   * Index an Agent Card for local search
-   */
-  indexAgentCard(card: AgentCard): void {
-    this.index.indexAgentCard(card);
-  }
-
-  /**
-   * Remove an Agent Card from local index
-   */
-  removeAgentCard(did: string): void {
-    this.index.removeAgentCard(did);
-  }
-
-  /**
-   * Get all indexed cards
-   */
-  getAllIndexedCards(): AgentCard[] {
-    return this.index.getAllCards();
-  }
-
-  /**
-   * Clear local index
-   */
-  clearIndex(): void {
-    this.index.clear();
-  }
-
-  /**
-   * Get index size
-   */
-  getIndexSize(): number {
-    return this.index.size();
-  }
-
-  /**
-   * Search network via DHT
-   */
-  private async searchNetwork(query: SemanticQuery): Promise<SearchResult[]> {
-    if (!this.dht) {
-      return [];
-    }
-
-    try {
-      // For now, use capability-based DHT query
-      // In future, implement distributed semantic search overlay
-      const capability = query.capability || this.extractPrimaryCapability(query.text);
-
-      if (!capability) {
-        logger.debug('No capability extracted from query, skipping network search');
-        return [];
-      }
-
-      const cards = await this.dht.queryByCapability(capability);
-      logger.debug('Network search results', { count: cards.length });
-
-      // Score network results
-      return cards.map(card => {
-        const score = this.scoreCard(card, query);
-        return { card, score };
-      });
-    } catch (error) {
-      logger.error('Network search failed', { error });
-      return [];
-    }
-  }
-
-  /**
-   * Merge local and network results, removing duplicates
-   */
-  private mergeResults(
-    local: SearchResult[],
-    network: SearchResult[],
-    limit: number
-  ): AgentCard[] {
-    const seen = new Set<string>();
-    const merged: SearchResult[] = [];
-
-    // Add local results first (they're already scored and sorted)
-    for (const result of local) {
-      if (!seen.has(result.card.did)) {
-        seen.add(result.card.did);
-        merged.push(result);
-      }
-    }
-
-    // Add network results
-    for (const result of network) {
-      if (!seen.has(result.card.did)) {
-        seen.add(result.card.did);
-        merged.push(result);
-
-        // Also index for future searches
-        this.index.indexAgentCard(result.card);
-      }
-    }
-
-    // Sort by score and apply limit
-    merged.sort((a, b) => b.score - a.score);
-    return merged.slice(0, limit).map(r => r.card);
-  }
-
-  /**
-   * Score a card against a query
-   */
-  private scoreCard(card: AgentCard, query: SemanticQuery): number {
-    let totalScore = 0;
-    let count = 0;
-
-    for (const capability of card.capabilities) {
-      const score = this.matcher.match(query, capability);
-      if (score > 0) {
-        totalScore += score;
-        count++;
-      }
-    }
-
-    // Average score across matching capabilities
-    const avgScore = count > 0 ? totalScore / count : 0;
-
-    // Boost by trust score if available
-    if (card.trust) {
-      const trustBoost = card.trust.interactionScore * 0.2;
-      return Math.min(avgScore + trustBoost, 1.0);
-    }
-
-    return avgScore;
-  }
-
-  /**
-   * Extract primary capability from natural language text
-   */
-  private extractPrimaryCapability(text?: string): string | undefined {
-    if (!text) return undefined;
-
-    const keywords = this.matcher.extractKeywords(text);
-
-    // Common capability keywords
-    const capabilityKeywords = [
-      'translate', 'translation',
-      'review', 'code',
-      'analyze', 'analysis',
-      'generate', 'generation',
-      'search', 'query',
-      'compute', 'calculation',
-      'store', 'storage',
-      'message', 'messaging',
-      'auth', 'authentication',
-    ];
-
-    // Find first matching keyword
-    for (const keyword of keywords) {
-      if (capabilityKeywords.includes(keyword)) {
-        return keyword;
-      }
-    }
-
-    // Return first keyword as fallback
-    return keywords[0];
-  }
-}
-
-/**
- * Create a semantic search engine
- */
-export function createSemanticSearch(dht?: DHTOperations): SemanticSearchEngine {
-  return new SemanticSearchEngine(dht);
-}

package/src/identity/did.ts

@@ -1,48 +0,0 @@
-import { base58btc } from 'multiformats/bases/base58';
-import { IdentityError } from '../utils/errors.js';
-
-/**
- * Derive a did:clawiverse DID from a public key
- * Format: did:clawiverse:<base58btc-encoded-pubkey>
- */
-export function deriveDID(publicKey: Uint8Array): string {
-  try {
-    const encoded = base58btc.encode(publicKey);
-    return `did:clawiverse:${encoded}`;
-  } catch (error) {
-    throw new IdentityError('Failed to derive DID', error);
-  }
-}
-
-/**
- * Extract public key from a did:clawiverse DID
- */
-export function extractPublicKey(did: string): Uint8Array {
-  if (!did.startsWith('did:clawiverse:')) {
-    throw new IdentityError('Invalid DID format: must start with did:clawiverse:');
-  }
-
-  try {
-    const encoded = did.replace('did:clawiverse:', '');
-    return base58btc.decode(encoded);
-  } catch (error) {
-    throw new IdentityError('Failed to extract public key from DID', error);
-  }
-}
-
-/**
- * Validate a did:clawiverse DID format
- */
-export function validateDID(did: string): boolean {
-  if (!did.startsWith('did:clawiverse:')) {
-    return false;
-  }
-
-  try {
-    const encoded = did.replace('did:clawiverse:', '');
-    base58btc.decode(encoded);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/identity/document.ts

@@ -1,77 +0,0 @@
-import { deriveDID } from './did.js';
-
-export interface DIDDocument {
-  '@context': string[];
-  id: string;
-  verificationMethod: VerificationMethod[];
-  authentication: string[];
-  assertionMethod: string[];
-  keyAgreement?: string[];
-  service?: ServiceEndpoint[];
-}
-
-export interface VerificationMethod {
-  id: string;
-  type: string;
-  controller: string;
-  publicKeyMultibase: string;
-}
-
-export interface ServiceEndpoint {
-  id: string;
-  type: string;
-  serviceEndpoint: string;
-}
-
-/**
- * Create a DID Document for a did:clawiverse identity
- */
-export function createDIDDocument(
-  publicKey: Uint8Array,
-  services?: ServiceEndpoint[]
-): DIDDocument {
-  const did = deriveDID(publicKey);
-  const keyId = `${did}#key-1`;
-  // Use base58btc encoding for multibase format
-  const publicKeyMultibase = `z${Buffer.from(publicKey).toString('hex')}`;
-
-  return {
-    '@context': [
-      'https://www.w3.org/ns/did/v1',
-      'https://w3id.org/security/suites/ed25519-2020/v1',
-    ],
-    id: did,
-    verificationMethod: [
-      {
-        id: keyId,
-        type: 'Ed25519VerificationKey2020',
-        controller: did,
-        publicKeyMultibase,
-      },
-    ],
-    authentication: [keyId],
-    assertionMethod: [keyId],
-    service: services,
-  };
-}
-
-/**
- * Validate a DID Document structure
- */
-export function validateDIDDocument(doc: unknown): doc is DIDDocument {
-  if (typeof doc !== 'object' || doc === null) {
-    return false;
-  }
-
-  const d = doc as Partial<DIDDocument>;
-
-  return (
-    Array.isArray(d['@context']) &&
-    typeof d.id === 'string' &&
-    d.id.startsWith('did:clawiverse:') &&
-    Array.isArray(d.verificationMethod) &&
-    d.verificationMethod.length > 0 &&
-    Array.isArray(d.authentication) &&
-    Array.isArray(d.assertionMethod)
-  );
-}

package/src/identity/index.ts

@@ -1,4 +0,0 @@
-export * from './keys.js';
-export * from './did.js';
-export * from './document.js';
-export * from './signer.js';

package/src/identity/keys.ts

@@ -1,79 +0,0 @@
-import * as ed25519 from '@noble/ed25519';
-import { IdentityError } from '../utils/errors.js';
-
-export interface KeyPair {
-  publicKey: Uint8Array;
-  privateKey: Uint8Array;
-}
-
-/**
- * Generate a new Ed25519 key pair
- */
-export async function generateKeyPair(): Promise<KeyPair> {
-  try {
-    const privateKey = ed25519.utils.randomPrivateKey();
-    const publicKey = await ed25519.getPublicKeyAsync(privateKey);
-
-    return {
-      publicKey,
-      privateKey,
-    };
-  } catch (error) {
-    throw new IdentityError('Failed to generate key pair', error);
-  }
-}
-
-/**
- * Sign a message with a private key
- */
-export async function sign(
-  message: Uint8Array,
-  privateKey: Uint8Array
-): Promise<Uint8Array> {
-  try {
-    return await ed25519.signAsync(message, privateKey);
-  } catch (error) {
-    throw new IdentityError('Failed to sign message', error);
-  }
-}
-
-/**
- * Verify a signature
- */
-export async function verify(
-  signature: Uint8Array,
-  message: Uint8Array,
-  publicKey: Uint8Array
-): Promise<boolean> {
-  try {
-    return await ed25519.verifyAsync(signature, message, publicKey);
-  } catch (error) {
-    throw new IdentityError('Failed to verify signature', error);
-  }
-}
-
-/**
- * Export key pair to JSON format
- */
-export function exportKeyPair(keyPair: KeyPair): {
-  publicKey: string;
-  privateKey: string;
-} {
-  return {
-    publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
-    privateKey: Buffer.from(keyPair.privateKey).toString('hex'),
-  };
-}
-
-/**
- * Import key pair from JSON format
- */
-export function importKeyPair(exported: {
-  publicKey: string;
-  privateKey: string;
-}): KeyPair {
-  return {
-    publicKey: new Uint8Array(Buffer.from(exported.publicKey, 'hex')),
-    privateKey: new Uint8Array(Buffer.from(exported.privateKey, 'hex')),
-  };
-}