@tangle-network/starter-foundry 0.1.0

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

@@ -0,0 +1,30 @@
+{
+  "id": "agent-hermes",
+  "description": "Adds NousResearch Hermes function-calling model configuration for tool-use agents.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-service-py",
+    "agent-service-rust"
+  ],
+  "defaults": {
+    "hermesModel": "NousResearch/Hermes-3-Llama-3.1-8B"
+  },
+  "files": [
+    {
+      "source": "files/hermes-config.json",
+      "target": "hermes-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "hermes-config.json"
+    ]
+  },
+  "keywords": [
+    "hermes",
+    "hermes model",
+    "hermes agent",
+    "nousresearch",
+    "hermes function calling"
+  ]
+}

package/registry/layers/capability/agent-intel/files/entity-card.tsx

@@ -0,0 +1,97 @@
+import { Card, CardContent, CardHeader } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { ExternalLink, Trash2, Download, Building2, User, Package, Calendar, MapPin } from 'lucide-react'
+
+interface EntityCardProps {
+  type: string
+  name: string
+  data: Record<string, string>
+  source: string
+  sourceUrl: string
+  scrapedAt: string
+  onViewSource: () => void
+  onExport: () => void
+  onDelete: () => void
+}
+
+const typeIcons: Record<string, typeof User> = {
+  person: User,
+  company: Building2,
+  product: Package,
+  event: Calendar,
+  location: MapPin,
+}
+
+const typeBadgeVariant: Record<string, 'default' | 'secondary' | 'outline'> = {
+  person: 'default',
+  company: 'secondary',
+  product: 'outline',
+  event: 'default',
+  location: 'secondary',
+}
+
+export function EntityCard({
+  type,
+  name,
+  data,
+  source,
+  sourceUrl,
+  scrapedAt,
+  onViewSource,
+  onExport,
+  onDelete,
+}: EntityCardProps) {
+  const Icon = typeIcons[type] || Package
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-start justify-between gap-2 pb-3">
+        <div className="flex items-center gap-3">
+          <div className="flex h-9 w-9 items-center justify-center rounded-lg bg-primary/10">
+            <Icon className="h-4 w-4 text-primary" />
+          </div>
+          <div>
+            <h3 className="text-sm font-semibold leading-tight">{name}</h3>
+            <Badge variant={typeBadgeVariant[type] || 'outline'} className="mt-1 text-xs capitalize">
+              {type}
+            </Badge>
+          </div>
+        </div>
+        <span className="shrink-0 text-xs text-muted-foreground">{scrapedAt}</span>
+      </CardHeader>
+      <CardContent>
+        <div className="space-y-2">
+          {Object.entries(data).map(([key, value]) => (
+            <div key={key} className="flex items-baseline justify-between gap-2">
+              <span className="text-xs font-medium capitalize text-muted-foreground">{key}</span>
+              <span className="truncate text-sm">{value}</span>
+            </div>
+          ))}
+        </div>
+
+        <div className="mt-4 flex items-center justify-between border-t pt-3">
+          <a
+            href={sourceUrl}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="text-xs text-muted-foreground hover:text-foreground"
+          >
+            {source}
+          </a>
+          <div className="flex items-center gap-1">
+            <Button variant="ghost" size="icon" className="h-7 w-7" onClick={onViewSource}>
+              <ExternalLink className="h-3.5 w-3.5" />
+            </Button>
+            <Button variant="ghost" size="icon" className="h-7 w-7" onClick={onExport}>
+              <Download className="h-3.5 w-3.5" />
+            </Button>
+            <Button variant="ghost" size="icon" className="h-7 w-7 text-destructive hover:text-destructive" onClick={onDelete}>
+              <Trash2 className="h-3.5 w-3.5" />
+            </Button>
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  )
+}

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

@@ -0,0 +1,14 @@
+{
+  "entityTypes": ["person", "company", "product", "event", "location"],
+  "maxConcurrentScrapes": "{{maxConcurrentScrapes}}",
+  "refreshIntervalMs": "{{refreshIntervalMs}}",
+  "extraction": {
+    "model": "gpt-4o-mini",
+    "prompt": "Extract structured entities from the following content. Return JSON array of {type, name, data}."
+  },
+  "display": {
+    "defaultView": "table",
+    "views": ["table", "cards", "chart"],
+    "groupBy": ["type", "source", "date"]
+  }
+}

package/registry/layers/capability/agent-intel/files/intel-dashboard.tsx

@@ -0,0 +1,224 @@
+'use client'
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Separator } from '@/components/ui/separator'
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table'
+import { Database, Globe, Activity, CheckCircle, Plus, RefreshCw } from 'lucide-react'
+
+interface Entity {
+  id: string
+  type: string
+  name: string
+  source: string
+  scrapedAt: string
+}
+
+interface ScrapeRun {
+  id: string
+  sourceUrl: string
+  status: 'running' | 'completed' | 'failed'
+  entitiesFound: number
+  duration: string
+}
+
+interface Source {
+  id: string
+  url: string
+}
+
+interface IntelDashboardProps {
+  entities: Entity[]
+  scrapeRuns: ScrapeRun[]
+  sources: Source[]
+  onNewScrape: () => void
+}
+
+const typeBadgeVariant: Record<string, 'default' | 'secondary' | 'outline'> = {
+  person: 'default',
+  company: 'secondary',
+  product: 'outline',
+  event: 'default',
+  location: 'secondary',
+}
+
+const statusStyles: Record<string, { variant: 'default' | 'secondary' | 'destructive'; label: string }> = {
+  running: { variant: 'default', label: 'Running' },
+  completed: { variant: 'secondary', label: 'Completed' },
+  failed: { variant: 'destructive', label: 'Failed' },
+}
+
+const sampleEntities: Entity[] = [
+  { id: '1', type: 'company', name: 'Acme Corp', source: 'crunchbase.com', scrapedAt: '2 min ago' },
+  { id: '2', type: 'person', name: 'Jane Smith', source: 'linkedin.com', scrapedAt: '5 min ago' },
+  { id: '3', type: 'product', name: 'DataSync Pro', source: 'g2.com', scrapedAt: '12 min ago' },
+  { id: '4', type: 'company', name: 'NovaTech', source: 'crunchbase.com', scrapedAt: '15 min ago' },
+  { id: '5', type: 'event', name: 'SaaStr Annual 2026', source: 'saastr.com', scrapedAt: '20 min ago' },
+  { id: '6', type: 'person', name: 'Alex Rivera', source: 'linkedin.com', scrapedAt: '30 min ago' },
+  { id: '7', type: 'location', name: 'SF Bay Area HQ', source: 'maps.google.com', scrapedAt: '45 min ago' },
+  { id: '8', type: 'product', name: 'CloudWatch AI', source: 'producthunt.com', scrapedAt: '1 hr ago' },
+]
+
+const sampleRuns: ScrapeRun[] = [
+  { id: 'r1', sourceUrl: 'crunchbase.com/discover', status: 'running', entitiesFound: 14, duration: '2m 30s' },
+  { id: 'r2', sourceUrl: 'linkedin.com/search', status: 'completed', entitiesFound: 42, duration: '5m 12s' },
+  { id: 'r3', sourceUrl: 'g2.com/categories/crm', status: 'completed', entitiesFound: 28, duration: '3m 45s' },
+  { id: 'r4', sourceUrl: 'producthunt.com/topics/ai', status: 'failed', entitiesFound: 0, duration: '0m 8s' },
+  { id: 'r5', sourceUrl: 'saastr.com/events', status: 'completed', entitiesFound: 6, duration: '1m 20s' },
+]
+
+const kpis = [
+  { label: 'Total Entities', value: '1,247', icon: Database },
+  { label: 'Active Sources', value: '18', icon: Globe },
+  { label: 'Scrapes Today', value: '34', icon: Activity },
+  { label: 'Success Rate', value: '94.2%', icon: CheckCircle },
+]
+
+function entityTypeCounts(entities: Entity[]) {
+  const counts: Record<string, number> = {}
+  for (const e of entities) {
+    counts[e.type] = (counts[e.type] || 0) + 1
+  }
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])
+}
+
+export function IntelDashboard({
+  entities = sampleEntities,
+  scrapeRuns = sampleRuns,
+  sources: _sources,
+  onNewScrape,
+}: IntelDashboardProps) {
+  const typeDist = entityTypeCounts(entities)
+  const maxCount = Math.max(...typeDist.map(([, c]) => c), 1)
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-3xl font-bold tracking-tight">Intelligence Dashboard</h1>
+          <p className="text-muted-foreground">Scraped entities, source health, and run history.</p>
+        </div>
+        <div className="flex items-center gap-2">
+          <Button variant="outline" size="icon">
+            <RefreshCw className="h-4 w-4" />
+          </Button>
+          <Button onClick={onNewScrape}>
+            <Plus className="mr-2 h-4 w-4" />
+            New Scrape
+          </Button>
+        </div>
+      </div>
+
+      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
+        {kpis.map((kpi) => (
+          <Card key={kpi.label}>
+            <CardHeader className="flex flex-row items-center justify-between pb-2">
+              <CardDescription className="text-sm font-medium">{kpi.label}</CardDescription>
+              <kpi.icon className="h-4 w-4 text-muted-foreground" />
+            </CardHeader>
+            <CardContent>
+              <div className="text-2xl font-bold">{kpi.value}</div>
+            </CardContent>
+          </Card>
+        ))}
+      </div>
+
+      <div className="grid gap-6 lg:grid-cols-7">
+        <Card className="lg:col-span-4">
+          <CardHeader>
+            <CardTitle>Recent Entities</CardTitle>
+            <CardDescription>Last 20 extracted entities across all sources</CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Type</TableHead>
+                  <TableHead>Name</TableHead>
+                  <TableHead>Source</TableHead>
+                  <TableHead className="text-right">Time</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {entities.slice(0, 20).map((entity) => (
+                  <TableRow key={entity.id}>
+                    <TableCell>
+                      <Badge variant={typeBadgeVariant[entity.type] || 'outline'} className="text-xs capitalize">
+                        {entity.type}
+                      </Badge>
+                    </TableCell>
+                    <TableCell className="font-medium">{entity.name}</TableCell>
+                    <TableCell className="text-muted-foreground">{entity.source}</TableCell>
+                    <TableCell className="text-right text-muted-foreground text-xs">{entity.scrapedAt}</TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </CardContent>
+        </Card>
+
+        <div className="space-y-6 lg:col-span-3">
+          <Card>
+            <CardHeader>
+              <CardTitle>Scrape Runs</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <div className="space-y-3">
+                {scrapeRuns.map((run) => {
+                  const s = statusStyles[run.status]
+                  return (
+                    <div key={run.id}>
+                      <div className="flex items-center justify-between">
+                        <div className="flex-1 truncate">
+                          <p className="truncate text-sm font-medium">{run.sourceUrl}</p>
+                          <div className="flex items-center gap-2 text-xs text-muted-foreground">
+                            <span>{run.entitiesFound} entities</span>
+                            <span>{run.duration}</span>
+                          </div>
+                        </div>
+                        <Badge variant={s.variant} className="ml-2 text-xs">
+                          {s.label}
+                        </Badge>
+                      </div>
+                      <Separator className="mt-3" />
+                    </div>
+                  )
+                })}
+              </div>
+            </CardContent>
+          </Card>
+
+          <Card>
+            <CardHeader>
+              <CardTitle>Entity Distribution</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <div className="space-y-3">
+                {typeDist.map(([type, count]) => (
+                  <div key={type} className="flex items-center gap-3">
+                    <span className="w-20 text-sm capitalize text-muted-foreground">{type}</span>
+                    <div className="flex-1">
+                      <div
+                        className="h-2 rounded-full bg-primary"
+                        style={{ width: `${(count / maxCount) * 100}%` }}
+                      />
+                    </div>
+                    <span className="w-8 text-right text-sm font-medium">{count}</span>
+                  </div>
+                ))}
+              </div>
+            </CardContent>
+          </Card>
+        </div>
+      </div>
+    </div>
+  )
+}

package/registry/layers/capability/agent-intel/files/scrape-status.tsx

@@ -0,0 +1,78 @@
+'use client'
+
+import { Card, CardContent, CardHeader } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Progress } from '@/components/ui/progress'
+import { Loader2, X, AlertCircle } from 'lucide-react'
+
+interface ScrapeStatusProps {
+  sourceUrl: string
+  status: 'queued' | 'running' | 'completed' | 'failed'
+  startedAt: string
+  entitiesFound: number
+  errors: number
+  progress?: number
+  onCancel: () => void
+}
+
+const statusConfig: Record<string, { variant: 'default' | 'secondary' | 'destructive' | 'outline'; label: string }> = {
+  queued: { variant: 'outline', label: 'Queued' },
+  running: { variant: 'default', label: 'Running' },
+  completed: { variant: 'secondary', label: 'Completed' },
+  failed: { variant: 'destructive', label: 'Failed' },
+}
+
+export function ScrapeStatus({
+  sourceUrl,
+  status,
+  startedAt,
+  entitiesFound,
+  errors,
+  progress,
+  onCancel,
+}: ScrapeStatusProps) {
+  const config = statusConfig[status]
+  const isActive = status === 'queued' || status === 'running'
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between gap-2 pb-3">
+        <div className="flex items-center gap-2 truncate">
+          {status === 'running' && <Loader2 className="h-4 w-4 shrink-0 animate-spin text-primary" />}
+          <span className="truncate text-sm font-medium">{sourceUrl}</span>
+        </div>
+        <Badge variant={config.variant} className="shrink-0 text-xs">
+          {config.label}
+        </Badge>
+      </CardHeader>
+      <CardContent>
+        {progress !== undefined ? (
+          <Progress value={progress} className="mb-3 h-2" />
+        ) : status === 'running' ? (
+          <div className="mb-3 h-2 overflow-hidden rounded-full bg-secondary">
+            <div className="h-full w-1/3 animate-pulse rounded-full bg-primary" />
+          </div>
+        ) : null}
+
+        <div className="flex items-center gap-4 text-xs text-muted-foreground">
+          <span>Started {startedAt}</span>
+          <span>{entitiesFound} entities</span>
+          {errors > 0 && (
+            <span className="flex items-center gap-1 text-destructive">
+              <AlertCircle className="h-3 w-3" />
+              {errors} error{errors !== 1 && 's'}
+            </span>
+          )}
+        </div>
+
+        {isActive && (
+          <Button variant="outline" size="sm" className="mt-3" onClick={onCancel}>
+            <X className="mr-1 h-3 w-3" />
+            Cancel
+          </Button>
+        )}
+      </CardContent>
+    </Card>
+  )
+}

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

@@ -0,0 +1,32 @@
+{
+  "id": "agent-intel",
+  "description": "AI-powered data intelligence layer: web scraping, entity extraction, and structured data display with tables and charts.",
+  "group": "capability",
+  "appliesTo": ["nextjs-ts", "react-vite-ts", "fullstack-ts", "agent-service-ts"],
+  "keywords": ["scrape", "scraper", "scraping", "web scraping", "data extraction", "intelligence", "research agent", "market research", "icp", "ideal customer", "lead generation", "lead gen", "competitive analysis", "data collection", "crawl", "enrichment", "prospect"],
+  "files": [
+    { "source": "files/intel-config.json", "target": "intel-config.json" },
+    { "source": "files/intel-dashboard.tsx", "target": "src/components/intel/intel-dashboard.tsx" },
+    { "source": "files/entity-card.tsx", "target": "src/components/intel/entity-card.tsx" },
+    { "source": "files/scrape-status.tsx", "target": "src/components/intel/scrape-status.tsx" }
+  ],
+  "defaults": {
+    "maxConcurrentScrapes": 5,
+    "refreshIntervalMs": 60000
+  },
+  "buildHints": {
+    "pages": ["/intel", "/intel/entities", "/intel/sources", "/intel/runs"],
+    "apiRoutes": ["/api/intel/scrape", "/api/intel/entities", "/api/intel/sources"],
+    "components": ["IntelDashboard", "EntityCard", "ScrapeStatus", "SourceManager", "EntityTable"],
+    "dataModels": ["Entity { id, type, name, data, source, scrapedAt }", "Source { id, url, selector, schedule }", "ScrapeRun { id, sourceId, status, entitiesFound, duration }"],
+    "integrations": ["Playwright or Puppeteer for scraping", "LLM for entity extraction", "Cron or BullMQ for scheduled scrapes"],
+    "architectureNotes": [
+      "IntelDashboard shows scrape run history, entity counts by type, and source health.",
+      "EntityCard displays a single extracted entity with structured fields and source attribution.",
+      "ScrapeStatus shows real-time progress of active scrape jobs with entity count and errors.",
+      "Wire /api/intel/scrape to a background worker that runs Playwright + LLM extraction.",
+      "Entities are typed by category (person, company, product, etc.) with flexible JSON data field.",
+      "Sources define URL patterns + CSS selectors or natural language extraction instructions."
+    ]
+  }
+}

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

@@ -0,0 +1,17 @@
+{
+  "framework": "{{agentFramework}}",
+  "features": ["graph-builder", "conditional-edges", "checkpointing", "human-in-the-loop", "streaming"],
+  "checkpointing": { "backend": "sqlite", "path": "./checkpoints.db" },
+  "nodes": [
+    { "name": "planner", "description": "Decomposes task into steps" },
+    { "name": "executor", "description": "Executes individual steps with tools" },
+    { "name": "reviewer", "description": "Validates output quality" }
+  ],
+  "notes": [
+    "LangGraph models agent workflows as directed graphs with typed state.",
+    "Each node is a function: (state) → state update.",
+    "Conditional edges route to different nodes based on state values.",
+    "Checkpointing persists state to SQLite/Postgres for durability.",
+    "Human-in-the-loop uses interrupt_before to pause for approval."
+  ]
+}

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

@@ -0,0 +1,17 @@
+{
+  "id": "agent-langgraph",
+  "description": "Adds LangGraph workflow patterns with graph nodes, edges, checkpointing, and human-in-the-loop.",
+  "appliesTo": ["agent-service-ts", "agent-service-py"],
+  "defaults": { "agentFramework": "langgraph" },
+  "files": [
+    { "source": "files/langgraph-config.json", "target": "langgraph-config.json" }
+  ],
+  "contextHints": { "extensionPoints": ["langgraph-config.json"] },
+  "keywords": ["langgraph", "langchain graph", "graph workflow", "langgraph agent", "langgraph checkpoint", "langchain agents"],
+  "buildHints": {
+    "components": ["GraphBuilder", "NodeFunction", "CheckpointStore"],
+    "dataModels": ["GraphState", "NodeResult", "Checkpoint"],
+    "integrations": ["LangGraph", "LangChain", "Checkpointing (SQLite/Postgres)"],
+    "architectureNotes": ["Define graph nodes as functions that transform GraphState.", "Use conditional edges for branching logic (route to different nodes based on state).", "Enable checkpointing for durable workflows that survive restarts.", "Human-in-the-loop: add interrupt_before on nodes that need approval."]
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "framework": "{{agentFramework}}",
+  "features": ["tools", "workflows", "syncs", "rag", "evals"],
+  "integrations": [],
+  "notes": ["Mastra provides tools, workflows, and syncs out of the box.", "Use mastra.init() to bootstrap the agent runtime.", "Add integrations via the Mastra integration registry."]
+}

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

@@ -0,0 +1,27 @@
+{
+  "id": "agent-mastra",
+  "description": "Adds Mastra agent framework configuration with tools, workflows, and syncs.",
+  "appliesTo": [
+    "agent-service-ts"
+  ],
+  "defaults": {
+    "agentFramework": "mastra"
+  },
+  "files": [
+    {
+      "source": "files/mastra-config.json",
+      "target": "mastra-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "mastra-config.json"
+    ]
+  },
+  "keywords": [
+    "mastra",
+    "mastra agent",
+    "mastra tools",
+    "mastra workflows"
+  ]
+}

package/registry/layers/capability/agent-multi-agent/files/orchestration-config.json

@@ -0,0 +1,18 @@
+{
+  "strategy": "{{orchestrationStrategy}}",
+  "maxTurns": "{{maxAgentTurns}}",
+  "agents": [
+    { "role": "planner", "description": "Decomposes tasks into subtasks" },
+    { "role": "executor", "description": "Executes individual subtasks" },
+    { "role": "reviewer", "description": "Validates outputs and catches errors" }
+  ],
+  "handoff": {
+    "protocol": "structured-message",
+    "retryOnFailure": true
+  },
+  "notes": [
+    "The supervisor routes tasks to the right agent role.",
+    "Each agent reports back with structured results or escalates.",
+    "Add new roles by extending the agents array and supervisor routing."
+  ]
+}