aiden-runtime 3.19.5 → 3.19.7

package/workspace-templates/skills/arxiv/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: arxiv
+description: Search, fetch, and download academic papers from arXiv using the public REST API — no API key required
+category: research
+version: 1.0.0
+origin: aiden
+license: Apache-2.0
+tags: arxiv, research, papers, academic, ai, ml, science, pdf, preprint, citations
+---
+
+# arXiv Paper Search and Download
+
+Search and retrieve academic papers from arXiv using the free public REST API. No API key or authentication required.
+
+## When to Use
+
+- User wants to find recent ML/AI/CS papers on a topic
+- User wants to read the abstract of a specific paper
+- User wants to download a paper PDF
+- User wants to find papers by a specific author
+- User wants to stay up-to-date on a research area
+
+## How to Use
+
+### 1. Search papers by keyword
+
+The arXiv API uses Atom XML — parse with PowerShell or Python.
+
+```powershell
+$query   = [Uri]::EscapeDataString("attention mechanism transformer")
+$url     = "http://export.arxiv.org/api/query?search_query=all:$query&start=0&max_results=5&sortBy=lastUpdatedDate&sortOrder=descending"
+$resp    = Invoke-RestMethod -Uri $url
+$resp.feed.entry | ForEach-Object {
+  [PSCustomObject]@{
+    Title   = $_.title
+    Authors = ($_.author | ForEach-Object { $_.name }) -join ", "
+    Date    = $_.published
+    Id      = $_.id
+  }
+} | Format-Table -AutoSize
+```
+
+### 2. Search by category (cs.AI, cs.LG, stat.ML, etc.)
+
+```powershell
+$cat   = "cs.LG"
+$query = [Uri]::EscapeDataString("large language models")
+$url   = "http://export.arxiv.org/api/query?search_query=cat:$cat+AND+all:$query&max_results=10&sortBy=submittedDate&sortOrder=descending"
+$resp  = Invoke-RestMethod -Uri $url
+$resp.feed.entry | Select-Object title, published
+```
+
+### 3. Fetch a specific paper by arXiv ID
+
+```powershell
+$arxivId = "2305.17333"   # from URL: arxiv.org/abs/2305.17333
+$url     = "http://export.arxiv.org/api/query?id_list=$arxivId"
+$resp    = Invoke-RestMethod -Uri $url
+$entry   = $resp.feed.entry
+Write-Host "Title:   " $entry.title
+Write-Host "Authors: " (($entry.author | ForEach-Object { $_.name }) -join ", ")
+Write-Host "Abstract:" $entry.summary
+```
+
+### 4. Download a paper PDF
+
+```powershell
+$arxivId = "2305.17333"
+$pdfUrl  = "https://arxiv.org/pdf/$arxivId.pdf"
+$outPath = "C:\Users\shiva\Downloads\paper_$arxivId.pdf"
+Invoke-WebRequest -Uri $pdfUrl -OutFile $outPath
+Write-Host "Downloaded to $outPath"
+```
+
+### 5. Search papers with Python
+
+```python
+import urllib.request, urllib.parse, xml.etree.ElementTree as ET
+
+def search_arxiv(query, max_results=5, category="cs.LG"):
+  params = urllib.parse.urlencode({
+    "search_query": f"cat:{category} AND all:{query}",
+    "max_results": max_results,
+    "sortBy": "submittedDate",
+    "sortOrder": "descending"
+  })
+  url  = f"http://export.arxiv.org/api/query?{params}"
+  resp = urllib.request.urlopen(url).read()
+  root = ET.fromstring(resp)
+  ns   = {"a": "http://www.w3.org/2005/Atom"}
+  for entry in root.findall("a:entry", ns):
+    print(entry.find("a:title", ns).text.strip())
+    print(entry.find("a:id", ns).text.strip())
+    print()
+
+search_arxiv("chain of thought reasoning", max_results=5)
+```
+
+### 6. Find papers by author
+
+```powershell
+$author  = [Uri]::EscapeDataString("Andrej Karpathy")
+$url     = "http://export.arxiv.org/api/query?search_query=au:$author&max_results=10&sortBy=submittedDate&sortOrder=descending"
+$resp    = Invoke-RestMethod -Uri $url
+$resp.feed.entry | Select-Object title, published | Format-Table
+```
+
+## Examples
+
+**"Find the 5 most recent papers on retrieval-augmented generation"**
+→ Use step 2 with query `retrieval augmented generation` and category `cs.CL` or `cs.AI`.
+
+**"Get me the abstract of paper 2305.17333"**
+→ Use step 3 with the arXiv ID.
+
+**"Download the Attention Is All You Need paper"**
+→ arXiv ID is `1706.03762`. Use step 4 to download the PDF.
+
+## Cautions
+
+- arXiv API rate limit is 3 requests per second — add a 1-second delay between calls for bulk operations
+- Papers on arXiv are preprints and have not necessarily been peer-reviewed
+- arXiv IDs changed format in 2007 — old IDs use `category/YYMMNNN` format; new ones use `YYMM.NNNNN`
+- PDF download uses the standard `arxiv.org/pdf/<id>.pdf` URL — some papers have versioned PDFs at `arxiv.org/pdf/<id>v1.pdf`

package/workspace-templates/skills/arxiv/skill.json

@@ -0,0 +1,26 @@
+{
+  "name": "arxiv",
+  "version": "1.0.0",
+  "description": "Search, fetch, and download academic papers from arXiv using the public REST API — no API key required",
+  "author": "aiden",
+  "license": "MIT",
+  "tools": [],
+  "trigger_phrases": [],
+  "compatible_agents": [
+    "aiden"
+  ],
+  "min_agent_version": "3.0.0",
+  "tags": [
+    "arxiv",
+    "research",
+    "papers",
+    "academic",
+    "ai",
+    "ml",
+    "science",
+    "pdf",
+    "preprint",
+    "citations"
+  ],
+  "created": "2026-04-27T17:11:39.176Z"
+}

package/workspace-templates/skills/ascii-art/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: ascii-art
+description: Generate ASCII art text banners, box art, and decorative text using pyfiglet, cowsay, and boxes CLI tools
+category: creative
+version: 1.0.0
+origin: aiden
+license: Apache-2.0
+tags: ascii, art, banner, text, figlet, cowsay, terminal, decoration, cli, creative
+---
+
+# ASCII Art Generation
+
+Create ASCII art text banners, speech bubbles, box decorations, and large display text using `pyfiglet`, `cowsay`, and `boxes` — all CLI/Python tools.
+
+## When to Use
+
+- User wants a stylized text banner for a terminal script or README
+- User wants a fun cowsay/fortune-style message
+- User wants decorative box borders around text
+- User wants large ASCII letters for display purposes
+- User wants ASCII art for CLI tool headers or splash screens
+
+## How to Use
+
+### 1. Install tools
+
+```powershell
+pip install pyfiglet
+pip install cowsay
+
+# boxes (optional, for border art)
+# Windows: winget install info-zip.unzip  # then download boxes binary
+```
+
+### 2. Generate a text banner with pyfiglet
+
+```python
+import pyfiglet
+
+# Default font (Standard)
+print(pyfiglet.figlet_format("Hello World"))
+
+# Specific font
+print(pyfiglet.figlet_format("DevOS", font="banner3-D"))
+
+# List all available fonts
+fonts = pyfiglet.FigletFont.getFonts()
+print(f"Available fonts: {len(fonts)}")
+print(fonts[:20])
+```
+
+### 3. Sample popular pyfiglet fonts
+
+```python
+import pyfiglet
+
+text = "AIDEN"
+for font in ["banner3", "big", "block", "colossal", "doom", "epic", "isometric1", "larry3d", "ogre", "slant", "speed", "starwars"]:
+  print(f"\n--- {font} ---")
+  print(pyfiglet.figlet_format(text, font=font))
+```
+
+### 4. Generate cowsay messages
+
+```python
+import cowsay
+
+# Default cow
+cowsay.cow("Hello from Aiden!")
+
+# Different characters
+cowsay.tux("Linux penguin says hi")
+cowsay.dragon("Deploy to production!")
+cowsay.cheese("It is time to cheese")
+
+# List available characters
+print(cowsay.char_names)
+```
+
+### 5. Create a custom cowsay-style speech bubble
+
+```python
+def speech_bubble(text, speaker="Aiden"):
+  width  = max(len(line) for line in text.split("\n")) + 4
+  border = "─" * width
+  lines  = [f"│ {line.ljust(width-2)} │" for line in text.split("\n")]
+  bubble = [f"┌{border}┐"] + lines + [f"└{border}┘"]
+  bubble.append(f"  {speaker}")
+  print("\n".join(bubble))
+
+speech_bubble("Task complete.\n3 files created.\nAll tests passing.", speaker="🤖 Aiden")
+```
+
+### 6. Create ASCII box borders
+
+```python
+def boxed(text, style="double"):
+  styles = {
+    "single": ("┌","─","┐","│","└","┘"),
+    "double": ("╔","═","╗","║","╚","╝"),
+    "round":  ("╭","─","╮","│","╰","╯"),
+  }
+  tl,h,tr,v,bl,br = styles.get(style, styles["single"])
+  lines  = text.split("\n")
+  width  = max(len(l) for l in lines) + 2
+  border = h * width
+  print(f"{tl}{border}{tr}")
+  for line in lines:
+    print(f"{v} {line.ljust(width-1)}{v}")
+  print(f"{bl}{border}{br}")
+
+boxed("System Status: OK\nUptime: 99.9%\nTasks: 0 pending", style="double")
+```
+
+### 7. Color the output
+
+```python
+import pyfiglet
+
+CYAN  = "\033[96m"
+RESET = "\033[0m"
+banner = pyfiglet.figlet_format("DEVOS", font="slant")
+print(CYAN + banner + RESET)
+```
+
+## Examples
+
+**"Create a banner saying 'AIDEN' for the CLI startup screen"**
+→ Use step 2 with font `slant` or `doom`, then step 7 to add cyan color.
+
+**"Make a cowsay message that says 'Deployment successful'"**
+→ Use step 4: `cowsay.tux("Deployment successful!")`.
+
+**"Add a decorative box around my summary output"**
+→ Use step 6 with `style="double"` for a professional-looking double-line box.
+
+## Cautions
+
+- pyfiglet output width depends on font — some fonts produce very wide output; use short text (< 12 chars) for block fonts
+- Terminal color codes (ANSI) may not render correctly in all terminals — test before using in production scripts
+- cowsay requires `pip install cowsay` (Python port) — the Unix `cowsay` binary is separate
+- Some pyfiglet fonts are available only if `pyfiglet[all]` is installed — run `pip install pyfiglet[all]` for the full set

package/workspace-templates/skills/ascii-art/skill.json

@@ -0,0 +1,26 @@
+{
+  "name": "ascii-art",
+  "version": "1.0.0",
+  "description": "Generate ASCII art text banners, box art, and decorative text using pyfiglet, cowsay, and boxes CLI tools",
+  "author": "aiden",
+  "license": "MIT",
+  "tools": [],
+  "trigger_phrases": [],
+  "compatible_agents": [
+    "aiden"
+  ],
+  "min_agent_version": "3.0.0",
+  "tags": [
+    "ascii",
+    "art",
+    "banner",
+    "text",
+    "figlet",
+    "cowsay",
+    "terminal",
+    "decoration",
+    "cli",
+    "creative"
+  ],
+  "created": "2026-04-27T17:11:39.195Z"
+}

package/workspace-templates/skills/blogwatcher/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: blogwatcher
+description: Monitor RSS and Atom feeds for new posts from blogs, news sites, and podcasts using Python feedparser
+category: research
+version: 1.0.0
+origin: aiden
+license: Apache-2.0
+tags: rss, atom, feed, blog, news, monitor, feedparser, podcast, updates, aggregation
+---
+
+# Blog and Feed Watcher
+
+Monitor RSS and Atom feeds from blogs, news sites, and podcasts to track new posts. Uses the `feedparser` Python library — no API keys required for most feeds.
+
+## When to Use
+
+- User wants to check for new posts from specific blogs or news sites
+- User wants to aggregate headlines from multiple sources
+- User wants to monitor a research blog or tech feed for updates
+- User wants to read the latest posts from a site that has an RSS feed
+- User wants to set up periodic feed monitoring
+
+## How to Use
+
+### 1. Install feedparser
+
+```powershell
+pip install feedparser
+```
+
+### 2. Read a single RSS/Atom feed
+
+```python
+import feedparser
+from datetime import datetime
+
+feed = feedparser.parse("https://news.ycombinator.com/rss")
+print(f"Feed: {feed.feed.title}")
+print(f"Posts: {len(feed.entries)}\n")
+
+for entry in feed.entries[:5]:
+  title   = entry.get("title", "No title")
+  link    = entry.get("link", "")
+  date    = entry.get("published", "Unknown date")
+  print(f"• {title}\n  {link}\n  {date}\n")
+```
+
+### 3. Monitor multiple feeds
+
+```python
+import feedparser, time
+
+FEEDS = [
+  "https://feeds.feedburner.com/oreilly/radar",
+  "https://blog.openai.com/rss/",
+  "https://news.ycombinator.com/rss",
+  "https://simonwillison.net/atom/everything/",
+]
+
+def fetch_all(feeds, max_per_feed=5):
+  results = []
+  for url in feeds:
+    feed = feedparser.parse(url)
+    for entry in feed.entries[:max_per_feed]:
+      results.append({
+        "source":    feed.feed.get("title", url),
+        "title":     entry.get("title", ""),
+        "link":      entry.get("link", ""),
+        "published": entry.get("published", ""),
+      })
+  return sorted(results, key=lambda x: x["published"], reverse=True)
+
+for item in fetch_all(FEEDS):
+  print(f"[{item['source']}] {item['title']}\n  {item['link']}")
+```
+
+### 4. Filter posts by keyword
+
+```python
+import feedparser
+
+def search_feed(url, keyword):
+  feed    = feedparser.parse(url)
+  keyword = keyword.lower()
+  matches = [
+    e for e in feed.entries
+    if keyword in e.get("title","").lower() or keyword in e.get("summary","").lower()
+  ]
+  for e in matches:
+    print(f"• {e.title}\n  {e.link}\n")
+
+search_feed("https://news.ycombinator.com/rss", "llm")
+```
+
+### 5. Find the RSS feed URL for a site
+
+Common RSS URL patterns:
+```
+https://site.com/feed
+https://site.com/rss
+https://site.com/feed.xml
+https://site.com/atom.xml
+https://site.com/blog/feed
+```
+
+```python
+import feedparser, requests
+from bs4 import BeautifulSoup   # pip install beautifulsoup4
+
+def find_feed(site_url):
+  resp = requests.get(site_url, timeout=10, headers={"User-Agent": "Mozilla/5.0"})
+  soup = BeautifulSoup(resp.text, "html.parser")
+  for tag in soup.find_all("link", type=lambda t: t and "rss" in t or "atom" in t):
+    print(tag.get("href"))
+
+find_feed("https://simonwillison.net")
+```
+
+### 6. Save latest posts to a file
+
+```python
+import feedparser, json
+
+feed  = feedparser.parse("https://news.ycombinator.com/rss")
+posts = [{"title": e.title, "link": e.link, "date": e.get("published","")} for e in feed.entries[:20]]
+with open("hn_feed.json", "w") as f:
+  json.dump(posts, f, indent=2)
+print(f"Saved {len(posts)} posts to hn_feed.json")
+```
+
+## Examples
+
+**"What are the latest posts from Hacker News?"**
+→ Use step 2 with `https://news.ycombinator.com/rss`.
+
+**"Monitor these 4 AI blogs and show me posts about agents from the last week"**
+→ Use step 3 to fetch all, then step 4 logic to filter for `agent` keyword.
+
+**"Does this blog have an RSS feed? If so, get the latest 5 posts"**
+→ Use step 5 to discover the feed URL, then step 2 to fetch posts.
+
+## Cautions
+
+- Some sites block RSS scrapers — use a browser-like `User-Agent` header if getting 403 errors
+- feedparser handles both RSS 2.0, RSS 1.0, and Atom — no need to distinguish them
+- `entry.published` format varies by feed — some use RFC 2822, others ISO 8601; don't assume a format
+- Very active feeds (e.g. Reddit) may return 100+ entries — always use slicing (`[:n]`) to limit output

package/workspace-templates/skills/blogwatcher/skill.json

@@ -0,0 +1,26 @@
+{
+  "name": "blogwatcher",
+  "version": "1.0.0",
+  "description": "Monitor RSS and Atom feeds for new posts from blogs, news sites, and podcasts using Python feedparser",
+  "author": "aiden",
+  "license": "MIT",
+  "tools": [],
+  "trigger_phrases": [],
+  "compatible_agents": [
+    "aiden"
+  ],
+  "min_agent_version": "3.0.0",
+  "tags": [
+    "rss",
+    "atom",
+    "feed",
+    "blog",
+    "news",
+    "monitor",
+    "feedparser",
+    "podcast",
+    "updates",
+    "aggregation"
+  ],
+  "created": "2026-04-27T17:11:39.230Z"
+}

package/workspace-templates/skills/censys/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: censys
+description: Search Censys for internet-exposed hosts, certificates, and services — host lookups, queries, and certificate analysis
+category: security
+version: 1.0.0
+license: Apache-2.0
+origin: aiden
+tags: security, censys, osint, recon, ports, certificates, tls, asset-discovery, internet-scan
+env_required:
+  - CENSYS_API_ID
+  - CENSYS_API_SECRET
+---
+
+# Censys — Internet Asset Discovery
+
+Censys continuously scans the public internet and indexes detailed metadata about every reachable host: open ports, running services, TLS certificates, and BGP routing information. Complementary to Shodan with different scanner vantage points and richer certificate data.
+
+**Requires:** `CENSYS_API_ID` and `CENSYS_API_SECRET` — free tier at https://search.censys.io/register (0.4 req/sec, 250 queries/month).
+
+## When to Use
+
+- Look up what Censys sees on a specific IP address
+- Discover internet-exposed assets for a given organisation or ASN
+- Investigate TLS certificates — find all hosts sharing a certificate or subject
+- Security audit: verify which services are visible from the public internet
+- User asks "what does Censys show for IP X", "find hosts with this certificate", "look up ASN exposure"
+
+## How to Use
+
+### Look up a specific host by IP
+
+```powershell
+$ip       = "8.8.8.8"
+$id       = $env:CENSYS_API_ID
+$secret   = $env:CENSYS_API_SECRET
+$b64      = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${id}:${secret}"))
+$headers  = @{ Authorization = "Basic $b64" }
+
+$result = Invoke-RestMethod -Uri "https://search.censys.io/api/v2/hosts/$ip" -Headers $headers
+$r      = $result.result
+Write-Host "IP:           $($r.ip)"
+Write-Host "AS:           $($r.autonomous_system.name) (ASN $($r.autonomous_system.asn))"
+Write-Host "Country:      $($r.location.country)"
+Write-Host "Open ports:"
+$r.services | ForEach-Object {
+    Write-Host "  $($_.port)/$($_.transport_protocol) — $($_.service_name)"
+}
+```
+
+### Search with a query string
+
+```powershell
+$query    = "services.service_name: HTTP and location.country_code: IN"
+$b64      = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("$($env:CENSYS_API_ID):$($env:CENSYS_API_SECRET)"))
+$headers  = @{ Authorization = "Basic $b64" }
+$encoded  = [Uri]::EscapeDataString($query)
+
+$result = Invoke-RestMethod -Uri "https://search.censys.io/api/v2/hosts/search?q=$encoded" -Headers $headers
+Write-Host "Total matches: $($result.result.total)"
+$result.result.hits | Select-Object -First 10 | ForEach-Object {
+    Write-Host "  $($_.ip) — $($_.autonomous_system.name) ($($_.location.country_name))"
+}
+```
+
+### Look up a TLS certificate by SHA-256 fingerprint
+
+```powershell
+$sha256  = "YOUR_CERT_SHA256_HERE"
+$b64     = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("$($env:CENSYS_API_ID):$($env:CENSYS_API_SECRET)"))
+$headers = @{ Authorization = "Basic $b64" }
+
+$result = Invoke-RestMethod -Uri "https://search.censys.io/api/v2/certificates/$sha256" -Headers $headers
+$parsed = $result.result.parsed
+Write-Host "Subject:   $($parsed.subject_dn)"
+Write-Host "Issuer:    $($parsed.issuer_dn)"
+Write-Host "Valid:     $($parsed.validity.start) → $($parsed.validity.end)"
+Write-Host "SANs:      $($parsed.names_from_san -join ', ')"
+```
+
+## Examples
+
+**"What is exposed on IP 1.2.3.4?"**
+→ Host lookup: returns open ports, service names, ASN, and location.
+
+**"Find all exposed Redis servers in Germany"**
+→ Query: `services.service_name: REDIS and location.country_code: DE`
+
+**"Who else uses this TLS certificate?"**
+→ Certificate lookup by SHA-256 fingerprint — shows SAN names and validity.
+
+**"Show me all hosts in ASN 15169"**
+→ Query: `autonomous_system.asn: 15169`
+
+## Cautions
+
+- Free tier: 250 queries/month, 0.4 req/sec — pace bulk operations with `Start-Sleep -Milliseconds 2500`
+- Censys data reflects last scan date — real-time state may differ
+- Host lookup counts against your monthly quota
+- Certificate search may return expired or revoked certs — check validity dates
+- Never use Censys results to attempt unauthorised access; recon and awareness only
+
+## Requirements
+
+- `CENSYS_API_ID` and `CENSYS_API_SECRET` — free account at https://search.censys.io/register