@tangle-network/starter-foundry 0.1.0

package/registry/layers/capability/agent-code-review/manifest.json

@@ -0,0 +1,37 @@
+{
+  "id": "agent-code-review",
+  "description": "Adds code review pipeline with diff analysis, rule checking, and inline comment generation.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "reviewLanguages": "typescript,python",
+    "reviewRules": "security,performance,style"
+  },
+  "files": [
+    {
+      "source": "files/review-config.json",
+      "target": "review-config.json"
+    },
+    {
+      "source": "files/review-pipeline.ts",
+      "target": "review-pipeline.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "review-config.json",
+      "review-pipeline.ts"
+    ]
+  },
+  "keywords": [
+    "code review agent",
+    "code analysis agent",
+    "pr reviewer agent",
+    "code quality agent",
+    "linting agent",
+    "code audit agent"
+  ]
+}

package/registry/layers/capability/agent-customer-support/files/support-config.json

@@ -0,0 +1,15 @@
+{
+  "kbSource": "{{kbSource}}",
+  "escalation": "{{supportEscalation}}",
+  "intents": ["billing", "technical", "account", "feature-request", "bug-report"],
+  "escalationRules": [
+    { "condition": "negative-sentiment", "action": "escalate-human" },
+    { "condition": "repeated-contact", "action": "escalate-human" },
+    { "condition": "billing-dispute", "action": "escalate-human" }
+  ],
+  "notes": [
+    "Classify intent first, then search KB for matching articles.",
+    "Escalate to human when confidence is low or escalation rules trigger.",
+    "Track resolution rate and CSAT for quality monitoring."
+  ]
+}

package/registry/layers/capability/agent-customer-support/files/support-pipeline.ts

@@ -0,0 +1,122 @@
+// Types
+
+interface Ticket {
+  id: string
+  content: string
+  customerName: string
+  channel: string
+  createdAt: string
+}
+
+interface KBArticle {
+  id: string
+  title: string
+  body: string
+  tags: string[]
+}
+
+interface Classification {
+  category: 'billing' | 'technical' | 'account' | 'feature-request' | 'general'
+  priority: 'low' | 'medium' | 'high' | 'urgent'
+  sentiment: 'positive' | 'neutral' | 'negative'
+}
+
+// Keyword maps for rule-based classification
+
+const CATEGORY_KEYWORDS: Record<Classification['category'], string[]> = {
+  billing: ['invoice', 'charge', 'refund', 'payment', 'subscription', 'price', 'cost', 'bill', 'credit card', 'plan'],
+  technical: ['error', 'bug', 'crash', 'broken', 'not working', '500', 'timeout', 'slow', 'api', 'integration'],
+  account: ['password', 'login', 'sign in', 'locked', 'access', 'permission', 'reset', 'email', 'username', '2fa'],
+  'feature-request': ['feature', 'wish', 'would be nice', 'suggestion', 'could you add', 'request', 'roadmap'],
+  general: [],
+}
+
+const URGENCY_WORDS = ['asap', 'urgent', 'immediately', 'emergency', 'critical', 'down', 'outage', 'blocked', 'cannot access', 'production']
+const NEGATIVE_WORDS = ['frustrated', 'angry', 'terrible', 'worst', 'unacceptable', 'disappointed', 'ridiculous', 'awful', 'hate']
+const POSITIVE_WORDS = ['thanks', 'great', 'love', 'excellent', 'amazing', 'helpful', 'appreciate', 'wonderful']
+
+// Implementation
+
+export function classifyTicket(content: string): Classification {
+  const lower = content.toLowerCase()
+
+  // Category: score each category by keyword hits
+  let bestCategory: Classification['category'] = 'general'
+  let bestScore = 0
+  for (const [cat, keywords] of Object.entries(CATEGORY_KEYWORDS) as [Classification['category'], string[]][]) {
+    const score = keywords.reduce((sum, kw) => sum + (lower.includes(kw) ? 1 : 0), 0)
+    if (score > bestScore) {
+      bestScore = score
+      bestCategory = cat
+    }
+  }
+
+  // Priority: check for urgency signals
+  const urgencyHits = URGENCY_WORDS.reduce((sum, w) => sum + (lower.includes(w) ? 1 : 0), 0)
+  let priority: Classification['priority'] = 'low'
+  if (urgencyHits >= 3) priority = 'urgent'
+  else if (urgencyHits >= 2) priority = 'high'
+  else if (urgencyHits >= 1) priority = 'medium'
+
+  // Sentiment
+  const negHits = NEGATIVE_WORDS.reduce((sum, w) => sum + (lower.includes(w) ? 1 : 0), 0)
+  const posHits = POSITIVE_WORDS.reduce((sum, w) => sum + (lower.includes(w) ? 1 : 0), 0)
+  let sentiment: Classification['sentiment'] = 'neutral'
+  if (negHits > posHits) sentiment = 'negative'
+  else if (posHits > negHits) sentiment = 'positive'
+
+  return { category: bestCategory, priority, sentiment }
+}
+
+export function buildContext(ticket: Ticket, knowledgeBase: KBArticle[]): string {
+  const classification = classifyTicket(ticket.content)
+  const words = ticket.content.toLowerCase().split(/\s+/)
+
+  // Score KB articles by keyword overlap
+  const scored = knowledgeBase.map((article) => {
+    const articleWords = new Set(
+      (article.title + ' ' + article.body + ' ' + article.tags.join(' '))
+        .toLowerCase()
+        .split(/\s+/),
+    )
+    const overlap = words.filter((w) => w.length > 3 && articleWords.has(w)).length
+    return { article, score: overlap }
+  })
+
+  scored.sort((a, b) => b.score - a.score)
+  const relevant = scored.filter((s) => s.score > 0).slice(0, 3)
+
+  const lines: string[] = [
+    `Ticket ID: ${ticket.id}`,
+    `Customer: ${ticket.customerName}`,
+    `Category: ${classification.category}`,
+    `Priority: ${classification.priority}`,
+    `Sentiment: ${classification.sentiment}`,
+    '',
+    `Customer message:`,
+    ticket.content,
+  ]
+
+  if (relevant.length > 0) {
+    lines.push('', '--- Relevant KB Articles ---')
+    for (const { article, score } of relevant) {
+      lines.push(`[${article.id}] ${article.title} (relevance: ${score})`)
+      lines.push(article.body.slice(0, 500))
+      lines.push('')
+    }
+  }
+
+  return lines.join('\n')
+}
+
+export function formatResponse(agentReply: string, ticket: Ticket): string {
+  const greeting = `Hi ${ticket.customerName},`
+  const signature = [
+    '',
+    '---',
+    `Reference: ${ticket.id}`,
+    'If this doesn\'t resolve your issue, reply to this message and we\'ll follow up.',
+  ].join('\n')
+
+  return `${greeting}\n\n${agentReply}\n${signature}`
+}

package/registry/layers/capability/agent-customer-support/manifest.json

@@ -0,0 +1,38 @@
+{
+  "id": "agent-customer-support",
+  "description": "Adds customer support workflow with KB search, intent classification, and escalation.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "supportEscalation": "human-handoff",
+    "kbSource": "docs"
+  },
+  "files": [
+    {
+      "source": "files/support-config.json",
+      "target": "support-config.json"
+    },
+    {
+      "source": "files/support-pipeline.ts",
+      "target": "support-pipeline.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "support-config.json",
+      "support-pipeline.ts"
+    ]
+  },
+  "keywords": [
+    "customer support agent",
+    "support agent",
+    "help desk agent",
+    "ticket agent",
+    "support bot",
+    "customer service agent",
+    "helpdesk"
+  ]
+}

package/registry/layers/capability/agent-data-pipeline/files/analyst.ts

@@ -0,0 +1,192 @@
+// Types
+
+export interface SchemaField {
+  name: string
+  type: 'number' | 'string' | 'boolean' | 'null' | 'mixed'
+  nullRate: number
+  uniqueCount: number
+  sampleValues: unknown[]
+}
+
+export interface NumberStats {
+  min: number
+  max: number
+  mean: number
+  nullCount: number
+}
+
+export interface StringStats {
+  topValues: Array<{ value: string; count: number }>
+  avgLength: number
+  nullCount: number
+}
+
+export type ColumnStats = { type: 'number'; stats: NumberStats } | { type: 'string'; stats: StringStats }
+
+export interface AnalysisSummary {
+  rowCount: number
+  columnCount: number
+  columns: Array<SchemaField & { stats: ColumnStats }>
+}
+
+// Implementation
+
+function inferType(values: unknown[]): SchemaField['type'] {
+  const nonNull = values.filter((v) => v !== null && v !== undefined && v !== '')
+  if (nonNull.length === 0) return 'null'
+
+  let numCount = 0
+  let strCount = 0
+  let boolCount = 0
+
+  for (const v of nonNull) {
+    if (typeof v === 'boolean') boolCount++
+    else if (typeof v === 'number' || (typeof v === 'string' && v.trim() !== '' && !isNaN(Number(v)))) numCount++
+    else strCount++
+  }
+
+  const total = nonNull.length
+  if (numCount / total > 0.8) return 'number'
+  if (boolCount / total > 0.8) return 'boolean'
+  if (strCount / total > 0.8) return 'string'
+  return 'mixed'
+}
+
+export function analyzeSchema(rows: Record<string, unknown>[]): SchemaField[] {
+  if (rows.length === 0) return []
+
+  const columnNames = new Set<string>()
+  for (const row of rows) {
+    for (const key of Object.keys(row)) columnNames.add(key)
+  }
+
+  return Array.from(columnNames).map((name) => {
+    const values = rows.map((r) => r[name])
+    const nullCount = values.filter((v) => v === null || v === undefined || v === '').length
+    const uniqueValues = new Set(values.filter((v) => v !== null && v !== undefined && v !== ''))
+
+    return {
+      name,
+      type: inferType(values),
+      nullRate: values.length > 0 ? nullCount / values.length : 0,
+      uniqueCount: uniqueValues.size,
+      sampleValues: Array.from(uniqueValues).slice(0, 5),
+    }
+  })
+}
+
+export function generateSummary(schema: SchemaField[], rows: Record<string, unknown>[]): AnalysisSummary {
+  const columns = schema.map((field) => {
+    const values = rows.map((r) => r[field.name])
+    const nullCount = values.filter((v) => v === null || v === undefined || v === '').length
+
+    if (field.type === 'number') {
+      const nums = values
+        .map((v) => (typeof v === 'number' ? v : Number(v)))
+        .filter((n) => !isNaN(n))
+
+      const stats: NumberStats = nums.length > 0
+        ? {
+            min: Math.min(...nums),
+            max: Math.max(...nums),
+            mean: nums.reduce((s, n) => s + n, 0) / nums.length,
+            nullCount,
+          }
+        : { min: 0, max: 0, mean: 0, nullCount }
+
+      return { ...field, stats: { type: 'number' as const, stats } }
+    }
+
+    // String/mixed/boolean: frequency analysis
+    const freq = new Map<string, number>()
+    let totalLength = 0
+    let strCount = 0
+
+    for (const v of values) {
+      if (v === null || v === undefined || v === '') continue
+      const s = String(v)
+      freq.set(s, (freq.get(s) ?? 0) + 1)
+      totalLength += s.length
+      strCount++
+    }
+
+    const topValues = Array.from(freq.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([value, count]) => ({ value, count }))
+
+    const stats: StringStats = {
+      topValues,
+      avgLength: strCount > 0 ? totalLength / strCount : 0,
+      nullCount,
+    }
+
+    return { ...field, stats: { type: 'string' as const, stats } }
+  })
+
+  return {
+    rowCount: rows.length,
+    columnCount: schema.length,
+    columns,
+  }
+}
+
+export function buildQuery(question: string, schema: SchemaField[]): string {
+  const lower = question.toLowerCase()
+  const columnNames = schema.map((f) => f.name)
+  const numericColumns = schema.filter((f) => f.type === 'number').map((f) => f.name)
+
+  // Detect referenced columns
+  const referencedCols = columnNames.filter((c) => lower.includes(c.toLowerCase()))
+  const selectCols = referencedCols.length > 0 ? referencedCols : columnNames
+
+  // Detect aggregation intent
+  const wantsAvg = /average|avg|mean/.test(lower)
+  const wantsSum = /total|sum/.test(lower)
+  const wantsCount = /how many|count|number of/.test(lower)
+  const wantsMax = /max|maximum|highest|largest|most/.test(lower)
+  const wantsMin = /min|minimum|lowest|smallest|least/.test(lower)
+  const wantsGroup = /by\s+(\w+)|per\s+(\w+)|group/.test(lower)
+
+  // Detect grouping column
+  let groupCol: string | null = null
+  if (wantsGroup) {
+    const groupMatch = lower.match(/(?:by|per|group\s+by)\s+(\w+)/)
+    if (groupMatch) {
+      const candidate = groupMatch[1]
+      groupCol = columnNames.find((c) => c.toLowerCase() === candidate) ?? null
+    }
+  }
+
+  // Build pseudo-SQL
+  const aggTarget = numericColumns.find((c) => referencedCols.includes(c)) ?? numericColumns[0] ?? selectCols[0]
+
+  let select = selectCols.join(', ')
+  if (wantsAvg) select = `AVG(${aggTarget})`
+  else if (wantsSum) select = `SUM(${aggTarget})`
+  else if (wantsCount) select = 'COUNT(*)'
+  else if (wantsMax) select = `MAX(${aggTarget})`
+  else if (wantsMin) select = `MIN(${aggTarget})`
+
+  if (groupCol && (wantsAvg || wantsSum || wantsCount || wantsMax || wantsMin)) {
+    select = `${groupCol}, ${select}`
+  }
+
+  let query = `SELECT ${select} FROM data`
+
+  // Simple WHERE detection
+  const whereMatch = lower.match(/where\s+(\w+)\s*(=|>|<|>=|<=)\s*['"]?(\w+)['"]?/)
+  if (whereMatch) {
+    const [, col, op, val] = whereMatch
+    const realCol = columnNames.find((c) => c.toLowerCase() === col) ?? col
+    query += ` WHERE ${realCol} ${op} '${val}'`
+  }
+
+  if (groupCol) query += ` GROUP BY ${groupCol}`
+
+  // Detect ordering
+  if (/top|highest|largest|most/.test(lower)) query += ` ORDER BY ${aggTarget} DESC LIMIT 10`
+  else if (/bottom|lowest|smallest|least/.test(lower)) query += ` ORDER BY ${aggTarget} ASC LIMIT 10`
+
+  return query
+}

package/registry/layers/capability/agent-data-pipeline/files/pipeline-config.json

@@ -0,0 +1,15 @@
+{
+  "dataSources": [
+    { "type": "{{dataSourceType}}", "name": "primary" }
+  ],
+  "queryLimits": {
+    "maxRows": "{{maxQueryRows}}",
+    "timeoutMs": 30000
+  },
+  "outputFormats": ["table", "csv", "chart-spec", "summary"],
+  "notes": [
+    "analyst.mjs converts natural-language questions into SQL queries.",
+    "Query limits prevent runaway scans. Adjust maxRows for large datasets.",
+    "Chart specs follow a Vega-Lite compatible schema for frontend rendering."
+  ]
+}

package/registry/layers/capability/agent-data-pipeline/manifest.json

@@ -0,0 +1,38 @@
+{
+  "id": "agent-data-pipeline",
+  "description": "Adds data analysis pipeline with SQL generation, result formatting, and report output.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "dataSourceType": "sqlite",
+    "maxQueryRows": 10000
+  },
+  "files": [
+    {
+      "source": "files/pipeline-config.json",
+      "target": "pipeline-config.json"
+    },
+    {
+      "source": "files/analyst.ts",
+      "target": "analyst.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "pipeline-config.json",
+      "analyst.ts"
+    ]
+  },
+  "keywords": [
+    "data analysis agent",
+    "data pipeline agent",
+    "sql agent",
+    "analytics agent",
+    "data analyst agent",
+    "report generation agent",
+    "bi agent"
+  ]
+}

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

@@ -0,0 +1,10 @@
+{
+  "events": ["pull_request", "issues", "push", "issue_comment"],
+  "actions": "{{githubActions}}",
+  "repos": [],
+  "notes": [
+    "Set GITHUB_TOKEN and GITHUB_WEBHOOK_SECRET in your environment.",
+    "github-handler.mjs routes events to the appropriate agent action.",
+    "PR reviews use diff analysis; issue triage uses label classification."
+  ]
+}

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

@@ -0,0 +1,153 @@
+import { createHmac, timingSafeEqual } from 'crypto'
+
+// Types
+
+interface PRUser {
+  login: string
+  id: number
+}
+
+interface PullRequest {
+  number: number
+  title: string
+  body: string | null
+  state: string
+  user: PRUser
+  changed_files: number
+  additions: number
+  deletions: number
+  head: { ref: string; sha: string }
+  base: { ref: string; sha: string }
+}
+
+interface Issue {
+  number: number
+  title: string
+  body: string | null
+  state: string
+  user: PRUser
+  labels: Array<{ name: string }>
+  assignees: Array<{ login: string }>
+}
+
+interface PREvent {
+  action: string
+  pull_request: PullRequest
+  repository: { full_name: string }
+}
+
+interface IssueEvent {
+  action: string
+  issue: Issue
+  repository: { full_name: string }
+}
+
+interface PRMetadata {
+  number: number
+  title: string
+  author: string
+  baseBranch: string
+  headBranch: string
+  headSha: string
+  additions: number
+  deletions: number
+  changedFiles: number
+  action: string
+}
+
+interface IssueMetadata {
+  number: number
+  title: string
+  body: string | null
+  author: string
+  labels: string[]
+  assignees: string[]
+  state: string
+  action: string
+}
+
+interface AgentPrompt {
+  role: string
+  repo: string
+  eventType: 'pull_request' | 'issue'
+  summary: string
+  detail: string
+}
+
+// Implementation
+
+export function handlePREvent(event: PREvent): PRMetadata {
+  const { pull_request: pr, action } = event
+  return {
+    number: pr.number,
+    title: pr.title,
+    author: pr.user.login,
+    baseBranch: pr.base.ref,
+    headBranch: pr.head.ref,
+    headSha: pr.head.sha,
+    additions: pr.additions,
+    deletions: pr.deletions,
+    changedFiles: pr.changed_files,
+    action,
+  }
+}
+
+export function handleIssueEvent(event: IssueEvent): IssueMetadata {
+  const { issue, action } = event
+  return {
+    number: issue.number,
+    title: issue.title,
+    body: issue.body,
+    author: issue.user.login,
+    labels: issue.labels.map((l) => l.name),
+    assignees: issue.assignees.map((a) => a.login),
+    state: issue.state,
+    action,
+  }
+}
+
+export function formatForAgent(event: PREvent | IssueEvent): AgentPrompt {
+  const repo = event.repository.full_name
+
+  if ('pull_request' in event) {
+    const meta = handlePREvent(event)
+    return {
+      role: 'You are a code review assistant.',
+      repo,
+      eventType: 'pull_request',
+      summary: `PR #${meta.number}: "${meta.title}" by ${meta.author} (${meta.action})`,
+      detail: [
+        `Branch: ${meta.headBranch} -> ${meta.baseBranch}`,
+        `Changes: +${meta.additions} -${meta.deletions} across ${meta.changedFiles} file(s)`,
+        `Head SHA: ${meta.headSha}`,
+      ].join('\n'),
+    }
+  }
+
+  const meta = handleIssueEvent(event as IssueEvent)
+  return {
+    role: 'You are an issue triage assistant.',
+    repo,
+    eventType: 'issue',
+    summary: `Issue #${meta.number}: "${meta.title}" by ${meta.author} (${meta.action})`,
+    detail: [
+      `Labels: ${meta.labels.length > 0 ? meta.labels.join(', ') : 'none'}`,
+      `Assignees: ${meta.assignees.length > 0 ? meta.assignees.join(', ') : 'unassigned'}`,
+      meta.body ? `Body:\n${meta.body.slice(0, 2000)}` : 'No body provided.',
+    ].join('\n'),
+  }
+}
+
+export function verifyWebhook(
+  payload: string,
+  signatureHeader: string,
+  secret: string,
+): boolean {
+  const expected = Buffer.from(
+    'sha256=' + createHmac('sha256', secret).update(payload).digest('hex'),
+    'utf8',
+  )
+  const actual = Buffer.from(signatureHeader, 'utf8')
+  if (expected.length !== actual.length) return false
+  return timingSafeEqual(expected, actual)
+}

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

@@ -0,0 +1,36 @@
+{
+  "id": "agent-github",
+  "description": "Adds GitHub webhook handling for PR review, issue triage, and commit analysis.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "githubActions": "review,label,comment"
+  },
+  "files": [
+    {
+      "source": "files/github-config.json",
+      "target": "github-config.json"
+    },
+    {
+      "source": "files/github-handler.ts",
+      "target": "github-handler.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "github-config.json",
+      "github-handler.ts"
+    ]
+  },
+  "keywords": [
+    "github bot",
+    "github integration",
+    "pr review agent",
+    "issue triage",
+    "github agent",
+    "github webhook agent"
+  ]
+}

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

@@ -0,0 +1,15 @@
+{
+  "model": "{{hermesModel}}",
+  "features": ["function-calling", "tool-use", "structured-output", "json-mode", "system-prompts"],
+  "toolFormat": "hermes-function-calling",
+  "inference": {
+    "providers": ["together", "replicate", "local-vllm", "ollama"],
+    "contextLength": 128000
+  },
+  "notes": [
+    "Hermes models are fine-tuned for function calling and tool use.",
+    "Use the Hermes tool-call format for reliable structured output.",
+    "Run locally via Ollama or vLLM, or use Together/Replicate APIs.",
+    "Hermes-3 supports 128K context — good for RAG and long document analysis."
+  ]
+}