@saibolla/ada 0.1.2

package/scripts/prepare-runtime-workspace.mjs

@@ -0,0 +1,162 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const appRoot = resolve(import.meta.dirname, "..");
+const settingsPath = resolve(appRoot, ".ada", "settings.json");
+const adaDir = resolve(appRoot, ".ada");
+const workspaceDir = resolve(appRoot, ".ada", "npm");
+const workspaceNodeModulesDir = resolve(workspaceDir, "node_modules");
+const manifestPath = resolve(workspaceDir, ".runtime-manifest.json");
+const workspacePackageJsonPath = resolve(workspaceDir, "package.json");
+const workspaceArchivePath = resolve(adaDir, "runtime-workspace.tgz");
+const PRUNE_VERSION = 3;
+
+function readPackageSpecs() {
+	const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+	if (!Array.isArray(settings.packages)) {
+		return [];
+	}
+
+	return settings.packages
+		.filter((value) => typeof value === "string" && value.startsWith("npm:"))
+		.map((value) => value.slice(4));
+}
+
+function parsePackageName(spec) {
+	const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@.+)?$/);
+	return match?.[1] ?? spec;
+}
+
+function arraysMatch(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function workspaceIsCurrent(packageSpecs) {
+	if (!existsSync(manifestPath) || !existsSync(workspaceNodeModulesDir)) {
+		return false;
+	}
+
+	try {
+		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+		if (!Array.isArray(manifest.packageSpecs) || !arraysMatch(manifest.packageSpecs, packageSpecs)) {
+			return false;
+		}
+		if (
+			manifest.nodeAbi !== process.versions.modules ||
+			manifest.platform !== process.platform ||
+			manifest.arch !== process.arch ||
+			manifest.pruneVersion !== PRUNE_VERSION
+		) {
+			return false;
+		}
+
+		return packageSpecs.every((spec) => existsSync(resolve(workspaceNodeModulesDir, parsePackageName(spec))));
+	} catch {
+		return false;
+	}
+}
+
+function writeWorkspacePackageJson() {
+	writeFileSync(
+		workspacePackageJsonPath,
+		JSON.stringify(
+			{
+				name: "ada-runtime",
+				private: true,
+			},
+			null,
+			2,
+		) + "\n",
+		"utf8",
+	);
+}
+
+function prepareWorkspace(packageSpecs) {
+	rmSync(workspaceDir, { recursive: true, force: true });
+	mkdirSync(workspaceDir, { recursive: true });
+	writeWorkspacePackageJson();
+
+	if (packageSpecs.length === 0) {
+		return;
+	}
+
+	const result = spawnSync(
+		process.env.npm_execpath ? process.execPath : "npm",
+		process.env.npm_execpath
+			? [process.env.npm_execpath, "install", "--prefer-offline", "--no-audit", "--no-fund", "--loglevel", "error", "--prefix", workspaceDir, ...packageSpecs]
+			: ["install", "--prefer-offline", "--no-audit", "--no-fund", "--loglevel", "error", "--prefix", workspaceDir, ...packageSpecs],
+		{ stdio: "inherit" },
+	);
+	if (result.status !== 0) {
+		process.exit(result.status ?? 1);
+	}
+}
+
+function writeManifest(packageSpecs) {
+	writeFileSync(
+		manifestPath,
+		JSON.stringify(
+				{
+					packageSpecs,
+					generatedAt: new Date().toISOString(),
+					nodeAbi: process.versions.modules,
+					nodeVersion: process.version,
+					platform: process.platform,
+					arch: process.arch,
+					pruneVersion: PRUNE_VERSION,
+				},
+			null,
+			2,
+		) + "\n",
+		"utf8",
+	);
+}
+
+function pruneWorkspace() {
+	const result = spawnSync(process.execPath, [resolve(appRoot, "scripts", "prune-runtime-deps.mjs"), workspaceDir], {
+		stdio: "inherit",
+	});
+	if (result.status !== 0) {
+		process.exit(result.status ?? 1);
+	}
+}
+
+function archiveIsCurrent() {
+	if (!existsSync(workspaceArchivePath) || !existsSync(manifestPath)) {
+		return false;
+	}
+
+	return statSync(workspaceArchivePath).mtimeMs >= statSync(manifestPath).mtimeMs;
+}
+
+function createWorkspaceArchive() {
+	rmSync(workspaceArchivePath, { force: true });
+
+	const result = spawnSync("tar", ["-czf", workspaceArchivePath, "-C", adaDir, "npm"], {
+		stdio: "inherit",
+	});
+	if (result.status !== 0) {
+		process.exit(result.status ?? 1);
+	}
+}
+
+const packageSpecs = readPackageSpecs();
+
+if (workspaceIsCurrent(packageSpecs)) {
+	console.log("[ada] vendored runtime workspace already up to date");
+	if (archiveIsCurrent()) {
+		process.exit(0);
+	}
+	console.log("[ada] refreshing runtime workspace archive...");
+	createWorkspaceArchive();
+	console.log("[ada] runtime workspace archive ready");
+	process.exit(0);
+}
+
+console.log("[ada] preparing vendored runtime workspace...");
+prepareWorkspace(packageSpecs);
+pruneWorkspace();
+writeManifest(packageSpecs);
+createWorkspaceArchive();
+console.log("[ada] vendored runtime workspace ready");

package/scripts/prune-runtime-deps.mjs

@@ -0,0 +1,131 @@
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+
+const root = resolve(process.argv[2] ?? ".");
+const nodeModulesDir = resolve(root, "node_modules");
+
+const STRIP_FILE_PATTERNS = [
+	/\.map$/i,
+	/\.d\.cts$/i,
+	/\.d\.ts$/i,
+	/^README(\..+)?\.md$/i,
+	/^CHANGELOG(\..+)?\.md$/i,
+];
+
+function safeStat(path) {
+	try {
+		return statSync(path);
+	} catch {
+		return null;
+	}
+}
+
+function removePath(path) {
+	rmSync(path, { recursive: true, force: true });
+}
+
+function walkAndPrune(dir) {
+	if (!existsSync(dir)) return;
+
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const path = join(dir, entry.name);
+		const stats = entry.isSymbolicLink() ? safeStat(path) : null;
+		const isDirectory = entry.isDirectory() || stats?.isDirectory();
+		const isFile = entry.isFile() || stats?.isFile();
+
+		if (isDirectory) {
+			walkAndPrune(path);
+			continue;
+		}
+
+		if (isFile && STRIP_FILE_PATTERNS.some((pattern) => pattern.test(entry.name))) {
+			removePath(path);
+		}
+	}
+}
+
+function currentKoffiVariant() {
+	if (process.platform === "darwin" && process.arch === "arm64") return "darwin_arm64";
+	if (process.platform === "darwin" && process.arch === "x64") return "darwin_x64";
+	if (process.platform === "linux" && process.arch === "arm64") return "linux_arm64";
+	if (process.platform === "linux" && process.arch === "x64") return "linux_x64";
+	if (process.platform === "win32" && process.arch === "arm64") return "win32_arm64";
+	if (process.platform === "win32" && process.arch === "x64") return "win32_x64";
+	return null;
+}
+
+function pruneKoffi(nodeModulesRoot) {
+	const koffiRoot = join(nodeModulesRoot, "koffi");
+	if (!existsSync(koffiRoot)) return;
+
+	for (const dirName of ["doc", "src", "vendor"]) {
+		removePath(join(koffiRoot, dirName));
+	}
+
+	const buildRoot = join(koffiRoot, "build", "koffi");
+	if (!existsSync(buildRoot)) return;
+
+	const keep = currentKoffiVariant();
+	for (const entry of readdirSync(buildRoot, { withFileTypes: true })) {
+		if (entry.name === keep) continue;
+		removePath(join(buildRoot, entry.name));
+	}
+}
+
+function pruneBetterSqlite3(nodeModulesRoot) {
+	const pkgRoot = join(nodeModulesRoot, "better-sqlite3");
+	if (!existsSync(pkgRoot)) return;
+
+	removePath(join(pkgRoot, "deps"));
+	removePath(join(pkgRoot, "src"));
+	removePath(join(pkgRoot, "binding.gyp"));
+
+	const buildRoot = join(pkgRoot, "build");
+	const releaseRoot = join(buildRoot, "Release");
+	if (existsSync(releaseRoot)) {
+		for (const entry of readdirSync(releaseRoot, { withFileTypes: true })) {
+			if (entry.name === "better_sqlite3.node") continue;
+			removePath(join(releaseRoot, entry.name));
+		}
+	}
+
+	for (const entry of ["Makefile", "binding.Makefile", "config.gypi", "deps", "gyp-mac-tool", "test_extension.target.mk", "better_sqlite3.target.mk"]) {
+		removePath(join(buildRoot, entry));
+	}
+}
+
+function pruneLiteparse(nodeModulesRoot) {
+	const pkgRoot = join(nodeModulesRoot, "@llamaindex", "liteparse");
+	if (!existsSync(pkgRoot)) return;
+	if (existsSync(join(pkgRoot, "dist"))) {
+		removePath(join(pkgRoot, "src"));
+	}
+}
+
+function prunePiCodingAgent(nodeModulesRoot) {
+	const pkgRoot = join(nodeModulesRoot, "@mariozechner", "pi-coding-agent");
+	if (!existsSync(pkgRoot)) return;
+	removePath(join(pkgRoot, "docs"));
+	removePath(join(pkgRoot, "examples"));
+}
+
+function pruneMermaid(nodeModulesRoot) {
+	const pkgRoot = join(nodeModulesRoot, "mermaid", "dist");
+	if (!existsSync(pkgRoot)) return;
+	removePath(join(pkgRoot, "docs"));
+	removePath(join(pkgRoot, "tests"));
+	removePath(join(pkgRoot, "__mocks__"));
+}
+
+if (!existsSync(nodeModulesDir)) {
+	process.exit(0);
+}
+
+walkAndPrune(nodeModulesDir);
+pruneKoffi(nodeModulesDir);
+pruneBetterSqlite3(nodeModulesDir);
+pruneLiteparse(nodeModulesDir);
+prunePiCodingAgent(nodeModulesDir);
+pruneMermaid(nodeModulesDir);
+
+console.log(`[ada] pruned runtime deps in ${basename(root)}`);

package/scripts/release.sh

@@ -0,0 +1,152 @@
+#!/bin/bash
+set -eu
+
+# Ada release script — builds locally and publishes to homebrew-tap
+# Usage: ./scripts/release.sh [version]
+# Example: ./scripts/release.sh 0.1.3
+#          ./scripts/release.sh  (uses version from package.json)
+
+REPO="saikrishnabolla/ada"
+TAP_REPO="saikrishnabolla/homebrew-tap"
+
+# Get version
+if [ -n "${1:-}" ]; then
+  VERSION="$1"
+else
+  VERSION=$(node -p "require('./package.json').version")
+fi
+
+TAG="v${VERSION}"
+echo ""
+echo "  Releasing Ada $TAG"
+echo ""
+
+# 1. Build
+echo "  [1/5] Building TypeScript..."
+npm run build
+
+echo "  [2/5] Building native bundle..."
+npm run build:native-bundle
+
+BUNDLE="dist/release/ada-${VERSION}-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m | sed 's/x86_64/x64/' | sed 's/aarch64/arm64/').tar.gz"
+
+if [ ! -f "$BUNDLE" ]; then
+  echo "  Error: Bundle not found at $BUNDLE"
+  exit 1
+fi
+
+# 2. Get SHA
+SHA=$(shasum -a 256 "$BUNDLE" | cut -d' ' -f1)
+PLATFORM=$(echo "$BUNDLE" | grep -o '[a-z]*-[a-z0-9]*\.tar\.gz' | sed 's/\.tar\.gz//')
+
+echo "  [3/5] Uploading to homebrew-tap..."
+
+# 3. Upload to homebrew-tap release
+if gh release view "$TAG" --repo "$TAP_REPO" >/dev/null 2>&1; then
+  gh release delete-asset "$TAG" "ada-${VERSION}-${PLATFORM}.tar.gz" --repo "$TAP_REPO" --yes 2>/dev/null || true
+  gh release upload "$TAG" "$BUNDLE" --repo "$TAP_REPO"
+else
+  gh release create "$TAG" "$BUNDLE" \
+    --repo "$TAP_REPO" \
+    --title "Ada $TAG" \
+    --notes "Ada ${VERSION} native bundles"
+fi
+
+echo "  [4/5] Updating Homebrew formula..."
+
+# 4. Get current formula and update SHA for this platform
+BASE_URL="https://github.com/${TAP_REPO}/releases/download/${TAG}"
+
+# Build formula — only include platforms we have bundles for
+# For a full release, run this script on each platform or use the CI workflow
+FORMULA_SHA=$(gh api "repos/${TAP_REPO}/contents/Formula/ada.rb" --jq '.sha')
+CURRENT_FORMULA=$(gh api "repos/${TAP_REPO}/contents/Formula/ada.rb" --jq '.content' | base64 -d)
+
+# Generate new formula
+cat > /tmp/ada-formula.rb << RUBY
+class Ada < Formula
+  desc "The AI research agent for the terminal"
+  homepage "https://thinkwithada.com"
+  version "${VERSION}"
+  license "Apache-2.0"
+
+  on_macos do
+    on_arm do
+      url "${BASE_URL}/ada-${VERSION}-darwin-arm64.tar.gz"
+      sha256 "PLACEHOLDER_DARWIN_ARM64"
+    end
+    on_intel do
+      url "${BASE_URL}/ada-${VERSION}-darwin-x64.tar.gz"
+      sha256 "PLACEHOLDER_DARWIN_X64"
+    end
+  end
+
+  on_linux do
+    on_intel do
+      url "${BASE_URL}/ada-${VERSION}-linux-x64.tar.gz"
+      sha256 "PLACEHOLDER_LINUX_X64"
+    end
+  end
+
+  def install
+    libexec.install Dir["*"]
+
+    (bin/"ada").write <<~EOS
+      #!/bin/bash
+      exec "#{libexec}/node/bin/node" "#{libexec}/app/bin/ada.js" "\$@"
+    EOS
+  end
+
+  test do
+    assert_match version.to_s, shell_output("#{bin}/ada --version")
+  end
+end
+RUBY
+
+# Fill in SHAs — use current formula's SHAs for platforms we didn't build, new SHA for current platform
+for p in darwin-arm64 darwin-x64 linux-x64; do
+  if [ "$p" = "$PLATFORM" ]; then
+    PLATFORM_SHA="$SHA"
+  else
+    # Try to get from existing release
+    PLATFORM_SHA=$(curl -fsSL "${BASE_URL}/ada-${VERSION}-${p}.tar.gz" -o /tmp/ada-check-${p}.tar.gz 2>/dev/null && shasum -a 256 /tmp/ada-check-${p}.tar.gz | cut -d' ' -f1 || echo "")
+    rm -f /tmp/ada-check-${p}.tar.gz
+    if [ -z "$PLATFORM_SHA" ]; then
+      # Extract from current formula
+      PLATFORM_SHA=$(echo "$CURRENT_FORMULA" | grep -A1 "ada-.*-${p}" | grep sha256 | sed 's/.*"\(.*\)".*/\1/' || echo "MISSING")
+    fi
+  fi
+  PLACEHOLDER="PLACEHOLDER_$(echo "$p" | tr '-' '_' | tr '[:lower:]' '[:upper:]')"
+  sed -i.bak "s/${PLACEHOLDER}/${PLATFORM_SHA}/" /tmp/ada-formula.rb
+done
+rm -f /tmp/ada-formula.rb.bak
+
+# Upload formula
+CONTENT=$(base64 < /tmp/ada-formula.rb | tr -d '\n')
+gh api "repos/${TAP_REPO}/contents/Formula/ada.rb" \
+  --method PUT \
+  --field message="Update Ada to ${TAG}" \
+  --field branch="main" \
+  --field sha="$FORMULA_SHA" \
+  --field content="$CONTENT" \
+  --silent
+
+rm -f /tmp/ada-formula.rb
+
+echo "  [5/5] Updating ada repo release..."
+
+# 5. Also update ada repo release
+if gh release view "$TAG" --repo "$REPO" >/dev/null 2>&1; then
+  gh release delete-asset "$TAG" "ada-${VERSION}-${PLATFORM}.tar.gz" --repo "$REPO" --yes 2>/dev/null || true
+  gh release upload "$TAG" "$BUNDLE" --repo "$REPO" --clobber
+else
+  gh release create "$TAG" "$BUNDLE" \
+    --repo "$REPO" \
+    --title "$TAG" \
+    --notes "Ada ${VERSION} native bundles"
+fi
+
+echo ""
+echo "  Done! Released Ada $TAG (${PLATFORM})"
+echo "  Users can update with: ada update"
+echo ""

package/skills/adaptyv/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: adaptyv
+description: Cloud laboratory platform for automated protein testing and validation. Use when designing proteins and needing experimental validation including binding assays, expression testing, thermostability measurements, enzyme activity assays, or protein sequence optimization. Also use for submitting experiments via API, tracking experiment status, downloading results, optimizing protein sequences for better expression using computational tools (NetSolP, SoluProt, SolubleMPNN, ESM), or managing protein design workflows with wet-lab validation.
+license: Unknown
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# Adaptyv
+
+Adaptyv is a cloud laboratory platform that provides automated protein testing and validation services. Submit protein sequences via API or web interface and receive experimental results in approximately 21 days.
+
+## Quick Start
+
+### Authentication Setup
+
+Adaptyv requires API authentication. Set up your credentials:
+
+1. Contact support@adaptyvbio.com to request API access (platform is in alpha/beta)
+2. Receive your API access token
+3. Set environment variable:
+
+```bash
+export ADAPTYV_API_KEY="your_api_key_here"
+```
+
+Or create a `.env` file:
+
+```
+ADAPTYV_API_KEY=your_api_key_here
+```
+
+### Installation
+
+Install the required package using uv:
+
+```bash
+uv pip install requests python-dotenv
+```
+
+### Basic Usage
+
+Submit protein sequences for testing:
+
+```python
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+api_key = os.getenv("ADAPTYV_API_KEY")
+base_url = "https://kq5jp7qj7wdqklhsxmovkzn4l40obksv.lambda-url.eu-central-1.on.aws"
+
+headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json"
+}
+
+# Submit experiment
+response = requests.post(
+    f"{base_url}/experiments",
+    headers=headers,
+    json={
+        "sequences": ">protein1\nMKVLWALLGLLGAA...",
+        "experiment_type": "binding",
+        "webhook_url": "https://your-webhook.com/callback"
+    }
+)
+
+experiment_id = response.json()["experiment_id"]
+```
+
+## Available Experiment Types
+Adaptyv supports multiple assay types:
+- **Binding assays** - Test protein-target interactions using biolayer interferometry
+- **Expression testing** - Measure protein expression levels
+- **Thermostability** - Characterize protein thermal stability
+- **Enzyme activity** - Assess enzymatic function
+
+See `reference/experiments.md` for detailed information on each experiment type and workflows.
+
+## Protein Sequence Optimization
+Before submitting sequences, optimize them for better expression and stability:
+
+**Common issues to address:**
+- Unpaired cysteines that create unwanted disulfides
+- Excessive hydrophobic regions causing aggregation
+- Poor solubility predictions
+
+**Recommended tools:**
+- NetSolP / SoluProt - Initial solubility filtering
+- SolubleMPNN - Sequence redesign for improved solubility
+- ESM - Sequence likelihood scoring
+- ipTM - Interface stability assessment
+- pSAE - Hydrophobic exposure quantification
+
+See `reference/protein_optimization.md` for detailed optimization workflows and tool usage.
+
+## API Reference
+For complete API documentation including all endpoints, request/response formats, and authentication details, see `reference/api_reference.md`.
+
+## Examples
+For concrete code examples covering common use cases (experiment submission, status tracking, result retrieval, batch processing), see `reference/examples.md`.
+
+## Important Notes
+- Platform is currently in alpha/beta phase with features subject to change
+- Not all platform features are available via API yet
+- Results typically delivered in ~21 days
+- Contact support@adaptyvbio.com for access requests or questions
+- Suitable for high-throughput AI-driven protein design workflows
+