@tangle-network/starter-foundry 0.1.0

package/registry/layers/capability/agent-multi-agent/files/supervisor.ts

@@ -0,0 +1,154 @@
+// Types
+
+export interface AgentConfig {
+  id: string
+  name: string
+  capabilities: string[]
+  maxConcurrent: number
+}
+
+export interface AgentResult {
+  agentId: string
+  taskId: string
+  status: 'success' | 'failure' | 'partial'
+  output: unknown
+  durationMs: number
+  error?: string
+}
+
+export interface SupervisorState {
+  agents: AgentConfig[]
+  pendingTasks: string[]
+  activeTasks: Map<string, string>
+  completedResults: AgentResult[]
+}
+
+interface RouteDecision {
+  agentId: string
+  agentName: string
+  confidence: number
+  reason: string
+}
+
+interface AggregatedResult {
+  status: 'success' | 'partial' | 'failure'
+  outputs: unknown[]
+  conflicts: string[]
+  summary: string
+  successRate: number
+}
+
+// Implementation
+
+export function createSupervisor(agents: AgentConfig[]): SupervisorState {
+  return {
+    agents: [...agents],
+    pendingTasks: [],
+    activeTasks: new Map(),
+    completedResults: [],
+  }
+}
+
+export function routeTask(task: string, agents: AgentConfig[]): RouteDecision {
+  if (agents.length === 0) {
+    throw new Error('No agents available for routing')
+  }
+
+  const taskWords = task.toLowerCase().split(/\s+/)
+
+  const scored = agents.map((agent) => {
+    const capWords = agent.capabilities.flatMap((c) => c.toLowerCase().split(/[\s-_]+/))
+    const nameWords = agent.name.toLowerCase().split(/[\s-_]+/)
+    const allAgentWords = new Set([...capWords, ...nameWords])
+
+    // Score by word overlap between task description and agent capabilities
+    let score = 0
+    for (const word of taskWords) {
+      if (word.length <= 2) continue
+      if (allAgentWords.has(word)) score += 2
+
+      // Partial match: check if any capability word contains the task word
+      for (const aw of allAgentWords) {
+        if (aw.includes(word) || word.includes(aw)) {
+          score += 1
+          break
+        }
+      }
+    }
+
+    return { agent, score }
+  })
+
+  scored.sort((a, b) => b.score - a.score)
+  const best = scored[0]
+  const maxPossible = taskWords.filter((w) => w.length > 2).length * 2
+
+  return {
+    agentId: best.agent.id,
+    agentName: best.agent.name,
+    confidence: maxPossible > 0 ? Math.min(best.score / maxPossible, 1) : 0,
+    reason: best.score > 0
+      ? `Matched capabilities: ${best.agent.capabilities.join(', ')}`
+      : `Default fallback to ${best.agent.name} (no keyword match)`,
+  }
+}
+
+export function aggregateResults(results: AgentResult[]): AggregatedResult {
+  if (results.length === 0) {
+    return {
+      status: 'failure',
+      outputs: [],
+      conflicts: [],
+      summary: 'No results to aggregate',
+      successRate: 0,
+    }
+  }
+
+  const successes = results.filter((r) => r.status === 'success')
+  const failures = results.filter((r) => r.status === 'failure')
+  const partials = results.filter((r) => r.status === 'partial')
+
+  const successRate = successes.length / results.length
+
+  // Detect conflicts: multiple agents producing different outputs for overlapping work
+  const conflicts: string[] = []
+  const outputsByTask = new Map<string, AgentResult[]>()
+  for (const result of results) {
+    const existing = outputsByTask.get(result.taskId) ?? []
+    existing.push(result)
+    outputsByTask.set(result.taskId, existing)
+  }
+
+  for (const [taskId, taskResults] of outputsByTask) {
+    if (taskResults.length > 1) {
+      const outputs = taskResults.map((r) => JSON.stringify(r.output))
+      const unique = new Set(outputs)
+      if (unique.size > 1) {
+        conflicts.push(`Task ${taskId}: ${taskResults.length} agents produced ${unique.size} different outputs`)
+      }
+    }
+  }
+
+  let status: AggregatedResult['status'] = 'success'
+  if (failures.length === results.length) status = 'failure'
+  else if (failures.length > 0 || partials.length > 0 || conflicts.length > 0) status = 'partial'
+
+  const parts: string[] = [
+    `${results.length} task(s) completed`,
+    `${successes.length} succeeded`,
+  ]
+  if (failures.length > 0) parts.push(`${failures.length} failed`)
+  if (partials.length > 0) parts.push(`${partials.length} partial`)
+  if (conflicts.length > 0) parts.push(`${conflicts.length} conflict(s) detected`)
+
+  const avgDuration = results.reduce((s, r) => s + r.durationMs, 0) / results.length
+  parts.push(`avg duration: ${Math.round(avgDuration)}ms`)
+
+  return {
+    status,
+    outputs: successes.map((r) => r.output),
+    conflicts,
+    summary: parts.join(', '),
+    successRate,
+  }
+}

package/registry/layers/capability/agent-multi-agent/manifest.json

@@ -0,0 +1,39 @@
+{
+  "id": "agent-multi-agent",
+  "description": "Adds supervisor/worker multi-agent orchestration with routing and handoff protocols.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "orchestrationStrategy": "supervisor",
+    "maxAgentTurns": 10
+  },
+  "files": [
+    {
+      "source": "files/orchestration-config.json",
+      "target": "orchestration-config.json"
+    },
+    {
+      "source": "files/supervisor.ts",
+      "target": "supervisor.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "orchestration-config.json",
+      "supervisor.ts"
+    ]
+  },
+  "keywords": [
+    "multi-agent",
+    "multi agent",
+    "supervisor agent",
+    "agent orchestration",
+    "agent team",
+    "crew",
+    "swarm",
+    "agent hierarchy"
+  ]
+}

package/registry/layers/capability/agent-openclaw/files/openclaw-config.json

@@ -0,0 +1,6 @@
+{
+  "orchestrator": "{{orchestrator}}",
+  "features": ["session-management", "tool-routing", "multi-model", "streaming", "context-windows"],
+  "models": ["claude-sonnet-4-6", "gpt-4o", "llama-3.1-70b"],
+  "notes": ["OpenClaw provides a unified orchestration layer across model providers.", "Session management handles context windows and conversation persistence.", "Tool routing dispatches function calls to the appropriate handler."]
+}

package/registry/layers/capability/agent-openclaw/manifest.json

@@ -0,0 +1,28 @@
+{
+  "id": "agent-openclaw",
+  "description": "Adds OpenClaw agent orchestration with session management, tool routing, and multi-model support.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "orchestrator": "openclaw"
+  },
+  "files": [
+    {
+      "source": "files/openclaw-config.json",
+      "target": "openclaw-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "openclaw-config.json"
+    ]
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw agent",
+    "openclaw orchestration"
+  ]
+}

package/registry/layers/capability/agent-rag/files/rag-config.json

@@ -0,0 +1,12 @@
+{
+  "vectorDb": "{{vectorDb}}",
+  "embeddingModel": "{{embeddingModel}}",
+  "chunkSize": "{{chunkSize}}",
+  "chunkOverlap": 50,
+  "topK": 5,
+  "notes": [
+    "Configure the vector store connection in your environment.",
+    "The retrieval pipeline handles ingest, chunk, embed, and query.",
+    "Extend retrieval-pipeline.mjs with reranking or hybrid search if needed."
+  ]
+}

package/registry/layers/capability/agent-rag/files/retrieval-pipeline.ts

@@ -0,0 +1,183 @@
+// Types
+
+export interface Chunk {
+  id: string
+  text: string
+  index: number
+  metadata?: Record<string, unknown>
+}
+
+export interface ScoredChunk {
+  chunk: Chunk
+  score: number
+}
+
+export interface RetrievalResult {
+  query: string
+  chunks: ScoredChunk[]
+  context: string
+  tokenEstimate: number
+}
+
+// Implementation
+
+function estimateTokens(text: string): number {
+  // Rough approximation: ~4 chars per token for English text
+  return Math.ceil(text.length / 4)
+}
+
+export function chunkDocument(
+  text: string,
+  maxTokens: number = 512,
+  overlapTokens: number = 64,
+): Chunk[] {
+  const paragraphs = text.split(/\n\s*\n/)
+  const chunks: Chunk[] = []
+  let currentChunkParts: string[] = []
+  let currentTokens = 0
+  let index = 0
+
+  const flushChunk = () => {
+    if (currentChunkParts.length === 0) return
+    const chunkText = currentChunkParts.join('\n\n').trim()
+    if (chunkText.length > 0) {
+      chunks.push({
+        id: `chunk-${index}`,
+        text: chunkText,
+        index,
+      })
+      index++
+    }
+  }
+
+  for (const para of paragraphs) {
+    const trimmed = para.trim()
+    if (trimmed.length === 0) continue
+
+    const paraTokens = estimateTokens(trimmed)
+
+    // Single paragraph exceeds max: split by sentences
+    if (paraTokens > maxTokens) {
+      flushChunk()
+      currentChunkParts = []
+      currentTokens = 0
+
+      const sentences = trimmed.split(/(?<=[.!?])\s+/)
+      for (const sentence of sentences) {
+        const sentenceTokens = estimateTokens(sentence)
+        if (currentTokens + sentenceTokens > maxTokens && currentChunkParts.length > 0) {
+          flushChunk()
+          // Overlap: keep last part
+          const overlapText = currentChunkParts.slice(-1)
+          currentChunkParts = [...overlapText]
+          currentTokens = estimateTokens(overlapText.join(' '))
+        }
+        currentChunkParts.push(sentence)
+        currentTokens += sentenceTokens
+      }
+      continue
+    }
+
+    if (currentTokens + paraTokens > maxTokens && currentChunkParts.length > 0) {
+      flushChunk()
+      // Overlap: keep last paragraph
+      const overlapParts = currentChunkParts.slice(-1)
+      const overlapEst = estimateTokens(overlapParts.join('\n\n'))
+      if (overlapEst <= overlapTokens) {
+        currentChunkParts = [...overlapParts]
+        currentTokens = overlapEst
+      } else {
+        currentChunkParts = []
+        currentTokens = 0
+      }
+    }
+
+    currentChunkParts.push(trimmed)
+    currentTokens += paraTokens
+  }
+
+  flushChunk()
+  return chunks
+}
+
+export function scoreChunks(query: string, chunks: Chunk[]): ScoredChunk[] {
+  // BM25-style scoring
+  const k1 = 1.2
+  const b = 0.75
+  const queryTerms = tokenize(query)
+  const avgDocLen = chunks.reduce((s, c) => s + c.text.split(/\s+/).length, 0) / Math.max(chunks.length, 1)
+
+  // Compute document frequency for each query term
+  const df = new Map<string, number>()
+  for (const term of queryTerms) {
+    let count = 0
+    for (const chunk of chunks) {
+      if (tokenize(chunk.text).includes(term)) count++
+    }
+    df.set(term, count)
+  }
+
+  const N = chunks.length
+
+  return chunks
+    .map((chunk) => {
+      const docTerms = tokenize(chunk.text)
+      const docLen = docTerms.length
+      const termFreq = new Map<string, number>()
+      for (const t of docTerms) {
+        termFreq.set(t, (termFreq.get(t) ?? 0) + 1)
+      }
+
+      let score = 0
+      for (const term of queryTerms) {
+        const tf = termFreq.get(term) ?? 0
+        if (tf === 0) continue
+
+        const docFreq = df.get(term) ?? 0
+        const idf = Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1)
+        const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLen / avgDocLen)))
+        score += idf * tfNorm
+      }
+
+      return { chunk, score }
+    })
+    .sort((a, b) => b.score - a.score)
+}
+
+export function buildContext(
+  query: string,
+  chunks: Chunk[],
+  maxTokens: number = 2048,
+): RetrievalResult {
+  const scored = scoreChunks(query, chunks)
+  const selected: ScoredChunk[] = []
+  let tokenBudget = maxTokens
+  let contextParts: string[] = []
+
+  for (const item of scored) {
+    if (item.score <= 0) break
+    const tokens = estimateTokens(item.chunk.text)
+    if (tokens > tokenBudget) continue
+    selected.push(item)
+    contextParts.push(`[Source ${item.chunk.id}]\n${item.chunk.text}`)
+    tokenBudget -= tokens
+  }
+
+  const context = contextParts.join('\n\n---\n\n')
+  return {
+    query,
+    chunks: selected,
+    context,
+    tokenEstimate: maxTokens - tokenBudget,
+  }
+}
+
+// Internal helpers
+
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .filter((t) => t.length > 2)
+}

package/registry/layers/capability/agent-rag/manifest.json

@@ -0,0 +1,65 @@
+{
+  "id": "agent-rag",
+  "description": "Adds RAG pipeline seams with vector DB config, embedding strategy, and retrieval hooks.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "vectorDb": "chromadb",
+    "embeddingModel": "text-embedding-3-small",
+    "chunkSize": 512
+  },
+  "files": [
+    {
+      "source": "files/rag-config.json",
+      "target": "rag-config.json"
+    },
+    {
+      "source": "files/retrieval-pipeline.ts",
+      "target": "retrieval-pipeline.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "rag-config.json",
+      "retrieval-pipeline.ts"
+    ]
+  },
+  "keywords": [
+    "rag",
+    "retrieval augmented",
+    "vector database",
+    "knowledge base",
+    "document qa",
+    "embeddings",
+    "semantic search",
+    "pinecone",
+    "chromadb",
+    "weaviate",
+    "qdrant"
+  ],
+  "buildHints": {
+    "apiRoutes": [
+      "/api/ingest",
+      "/api/query"
+    ],
+    "components": [
+      "DocumentUploader",
+      "SearchResults",
+      "SourceCitation"
+    ],
+    "dataModels": [
+      "Document",
+      "Chunk",
+      "Embedding",
+      "SearchResult"
+    ],
+    "integrations": [
+      "Vector database",
+      "Embedding API",
+      "Document parser"
+    ]
+  }
+}

package/registry/layers/capability/agent-slack/files/slack-config.json

@@ -0,0 +1,10 @@
+{
+  "eventTypes": ["message", "app_mention", "reaction_added"],
+  "threadMode": "{{slackThreadMode}}",
+  "channels": [],
+  "notes": [
+    "Set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET in your environment.",
+    "Events are verified and routed through slack-handler.mjs.",
+    "Thread mode controls whether replies go in-thread or as new messages."
+  ]
+}

package/registry/layers/capability/agent-slack/files/slack-handler.ts

@@ -0,0 +1,125 @@
+import { createHmac, timingSafeEqual } from 'crypto'
+
+// Types
+
+export interface SlackEvent {
+  type: 'message' | 'app_mention' | 'reaction_added'
+  channel: string
+  user?: string
+  text?: string
+  thread_ts?: string
+  ts: string
+  reaction?: string
+  item?: { type: string; channel: string; ts: string }
+}
+
+export interface SlackMessage {
+  channel: string
+  text: string
+  thread_ts?: string
+  mrkdwn?: boolean
+}
+
+interface ParsedCommand {
+  command: string
+  args: string[]
+  raw: string
+}
+
+interface EventResponse {
+  type: SlackEvent['type']
+  channel: string
+  threadTs?: string
+  text?: string
+  reaction?: string
+  user?: string
+}
+
+// Implementation
+
+export function verifySlackRequest(
+  body: string,
+  timestamp: string,
+  signature: string,
+  signingSecret: string,
+): boolean {
+  // Reject requests older than 5 minutes to prevent replay attacks
+  const now = Math.floor(Date.now() / 1000)
+  if (Math.abs(now - Number(timestamp)) > 300) return false
+
+  const baseString = `v0:${timestamp}:${body}`
+  const computed = 'v0=' + createHmac('sha256', signingSecret).update(baseString).digest('hex')
+
+  const expected = Buffer.from(computed, 'utf8')
+  const actual = Buffer.from(signature, 'utf8')
+  if (expected.length !== actual.length) return false
+  return timingSafeEqual(expected, actual)
+}
+
+export function handleEvent(event: SlackEvent): EventResponse {
+  switch (event.type) {
+    case 'message':
+      return {
+        type: 'message',
+        channel: event.channel,
+        threadTs: event.thread_ts,
+        text: event.text,
+        user: event.user,
+      }
+
+    case 'app_mention':
+      return {
+        type: 'app_mention',
+        channel: event.channel,
+        threadTs: event.thread_ts ?? event.ts,
+        text: event.text,
+        user: event.user,
+      }
+
+    case 'reaction_added':
+      return {
+        type: 'reaction_added',
+        channel: event.item?.channel ?? event.channel,
+        reaction: event.reaction,
+        user: event.user,
+      }
+  }
+}
+
+export function formatSlackMessage(agentReply: string): string {
+  let text = agentReply
+
+  // Convert markdown bold **text** to Slack bold *text*
+  text = text.replace(/\*\*(.+?)\*\*/g, '*$1*')
+
+  // Convert markdown inline code (already compatible)
+
+  // Convert markdown fenced code blocks to Slack format
+  text = text.replace(/```(\w+)?\n([\s\S]*?)```/g, '```$2```')
+
+  // Convert markdown links [text](url) to Slack format <url|text>
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<$2|$1>')
+
+  // Convert markdown headers ## to bold
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, '*$1*')
+
+  // Convert markdown unordered lists to Slack bullets
+  text = text.replace(/^[-*]\s+/gm, '\u2022 ')
+
+  // Convert markdown strikethrough ~~text~~ to Slack ~text~
+  text = text.replace(/~~(.+?)~~/g, '~$1~')
+
+  return text
+}
+
+export function parseCommand(text: string): ParsedCommand | null {
+  // Strip bot mention (<@UXXXXX>) from the beginning
+  const cleaned = text.replace(/^<@\w+>\s*/, '').trim()
+  if (cleaned.length === 0) return null
+
+  const parts = cleaned.split(/\s+/)
+  const command = parts[0].toLowerCase()
+  const args = parts.slice(1)
+
+  return { command, args, raw: cleaned }
+}

package/registry/layers/capability/agent-slack/manifest.json

@@ -0,0 +1,34 @@
+{
+  "id": "agent-slack",
+  "description": "Adds Slack event handling, message routing, and thread-aware response patterns.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "slackThreadMode": "reply-in-thread"
+  },
+  "files": [
+    {
+      "source": "files/slack-config.json",
+      "target": "slack-config.json"
+    },
+    {
+      "source": "files/slack-handler.ts",
+      "target": "slack-handler.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "slack-config.json",
+      "slack-handler.ts"
+    ]
+  },
+  "keywords": [
+    "slack bot",
+    "slack integration",
+    "slack agent",
+    "slack app"
+  ]
+}