lingot 1.0.0

package/README.md

@@ -0,0 +1,59 @@
+# lingot
+
+The standard library for AI agents. Intelligence blocks that make Cursor, Windsurf, and Claude Code measurably better at writing code.
+
+## Quick Start
+
+```bash
+# Install a block
+npx lingot add supabase-auth
+
+# Detect your stack and see recommendations
+npx lingot init
+
+# Install multiple blocks
+npx lingot add drizzle-orm stripe-billing tailwind-v4
+```
+
+## What Are Intelligence Blocks?
+
+Each block contains 4 files of curated, token-optimized context:
+
+- **knowledge.md** — Dense domain knowledge, mental models, architecture patterns
+- **rules.xml** — ALWAYS/NEVER heuristic rules that prevent hallucinations
+- **examples.yaml** — Few-shot input/output examples for common tasks
+- **manifest.json** — Metadata, version, scope coverage
+
+Load blocks into your AI agent's context to get measurably better output. Our Supabase Auth block improved LLM accuracy from 35.3% to 100% on domain-specific tasks.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `lingot add <name>` | Install a block from the registry |
+| `lingot init` | Scan package.json and suggest relevant blocks |
+| `lingot list` | List installed blocks |
+| `lingot inspect <name>` | Show block details and token counts |
+| `lingot serve` | Start local MCP server for installed blocks |
+
+## 40+ Blocks Available
+
+Auth, frontend, backend, database, AI SDKs, payments, testing, DevOps, and more.
+
+Browse all blocks at [lingot.sh](https://lingot.sh).
+
+## MCP Integration
+
+Start the local MCP server to expose installed blocks to any MCP-compatible agent:
+
+```bash
+lingot serve
+```
+
+This provides two tools:
+- `search_packages` — Find relevant blocks by topic or domain
+- `get_package_context` — Load block content into agent context
+
+## License
+
+MIT

package/bin/lingot.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import { install } from '../lib/install.js';
+import { init } from '../lib/init.js';
+import { list } from '../lib/list.js';
+import { serve } from '../lib/serve.js';
+import { inspect } from '../lib/inspect.js';
+import { PACKAGES_DIR } from '../lib/config.js';
+
+const [,, command, ...args] = process.argv;
+
+const HELP = `
+lingot — The standard library for AI agents.
+
+Usage:
+  lingot add <name>          Install an intelligence block from the registry
+  lingot init                Detect your stack and suggest relevant blocks
+  lingot list                List installed blocks
+  lingot inspect <name>      Show block details and token counts
+  lingot serve               Start local MCP server for installed blocks
+  lingot help                Show this help
+
+Blocks are installed to: ${PACKAGES_DIR}
+
+Examples:
+  npx lingot add supabase-auth
+  npx lingot init
+  npx lingot add drizzle-orm stripe-billing tailwind-v4
+
+Registry: https://lingot.sh
+`;
+
+async function main() {
+  switch (command) {
+    case 'add':
+    case 'install':
+    case 'i':
+      if (!args[0]) {
+        console.error('Usage: lingot add <block-name> [block-name...]');
+        process.exit(1);
+      }
+      for (const name of args) {
+        await install(name);
+      }
+      break;
+
+    case 'init':
+      await init();
+      break;
+
+    case 'list':
+    case 'ls':
+      await list();
+      break;
+
+    case 'inspect':
+      if (!args[0]) {
+        console.error('Usage: lingot inspect <block-name>');
+        process.exit(1);
+      }
+      await inspect(args[0]);
+      break;
+
+    case 'serve':
+      await serve();
+      break;
+
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      console.log(HELP);
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error(err.message);
+  process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,5 @@
+import { join } from 'path';
+import { homedir } from 'os';
+
+export const PACKAGES_DIR = join(homedir(), '.lingot', 'packages');
+export const REGISTRY_URL = 'https://lingot.sh/api/v1';

package/lib/init.js

@@ -0,0 +1,104 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { REGISTRY_URL } from './config.js';
+
+// Maps package.json dependency names to lingot block slugs
+const DEPENDENCY_MAP = {
+  '@supabase/supabase-js': 'supabase-auth',
+  '@supabase/ssr': 'supabase-auth',
+  'next': 'nextjs-app-router',
+  'typescript': 'typescript-strict',
+  'tailwindcss': 'tailwind-patterns',
+  '@tailwindcss/vite': 'tailwind-v4',
+  'drizzle-orm': 'drizzle-orm',
+  'drizzle-kit': 'drizzle-orm',
+  'zod': 'zod',
+  'stripe': 'stripe-billing',
+  '@aws-sdk/client-s3': 'aws-s3-v3',
+  'resend': 'resend',
+  '@tanstack/react-query': 'tanstack-query',
+  '@prisma/client': 'prisma',
+  'prisma': 'prisma',
+  'openai': 'openai',
+  '@anthropic-ai/sdk': 'anthropic',
+  'react-email': 'react-email',
+  '@react-email/components': 'react-email',
+  'ioredis': 'redis',
+  '@upstash/redis': 'redis',
+  'vitest': 'vitest',
+  'framer-motion': 'framer-motion',
+  'motion': 'framer-motion',
+  'next-auth': 'next-auth',
+  '@trpc/server': 'trpc',
+  '@trpc/client': 'trpc',
+  'react-hook-form': 'react-hook-form',
+  '@clerk/nextjs': 'clerk',
+  'mongoose': 'mongoose',
+  'zustand': 'zustand',
+  'uploadthing': 'uploadthing',
+  '@uploadthing/react': 'uploadthing',
+  'lucia': 'lucia-auth',
+  'arctic': 'lucia-auth',
+  'swr': 'swr',
+  'eslint': 'eslint',
+  '@playwright/test': 'playwright',
+  'next-intl': 'next-intl',
+  'convex': 'convex',
+  'turbo': 'turborepo',
+  'nuxt': 'nuxt',
+  'cypress': 'cypress',
+  'prettier': 'prettier',
+};
+
+export async function init() {
+  const pkgPath = join(process.cwd(), 'package.json');
+
+  if (!existsSync(pkgPath)) {
+    console.error('No package.json found in current directory.');
+    console.error('Run this command from your project root.');
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  const detected = new Set();
+  for (const dep of Object.keys(allDeps)) {
+    if (DEPENDENCY_MAP[dep]) {
+      detected.add(DEPENDENCY_MAP[dep]);
+    }
+  }
+
+  if (detected.size === 0) {
+    console.log('\nNo matching blocks found for your dependencies.');
+    console.log('Browse all 40+ blocks at https://lingot.sh');
+    return;
+  }
+
+  const blocks = [...detected].sort();
+
+  console.log(`\nDetected ${blocks.length} relevant intelligence blocks:\n`);
+
+  for (const slug of blocks) {
+    console.log(`  lingot add ${slug}`);
+  }
+
+  console.log(`\nInstall all at once:`);
+  console.log(`  lingot add ${blocks.join(' ')}`);
+
+  // SaaS stack upsell — if user has auth + payments + db detected
+  const hasSaasStack = detected.has('supabase-auth') || detected.has('next-auth') || detected.has('clerk');
+  const hasPayments = detected.has('stripe-billing');
+  const hasDb = detected.has('drizzle-orm') || detected.has('prisma') || detected.has('mongoose');
+
+  if (hasSaasStack && (hasPayments || hasDb)) {
+    console.log(`\n  \u{1F4A1} SaaS stack detected. Give your AI the integration patterns`);
+    console.log(`     to wire auth, payments, and database together securely:`);
+    console.log(`     npx lingot add saas-blueprint  (https://lingot.sh/blueprint)`);
+  }
+
+  console.log();
+}

package/lib/inspect.js

@@ -0,0 +1,55 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { PACKAGES_DIR } from './config.js';
+
+function fmt(num) {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+export async function inspect(name) {
+  const pkgDir = join(PACKAGES_DIR, name);
+  const manifestPath = join(pkgDir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Package not found: ${name}\nRun 'lingot list' to see installed packages.`);
+  }
+
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+
+  console.log(`\n${manifest.name}@${manifest.version}`);
+  console.log(`${'─'.repeat(50)}`);
+  console.log(`Description:  ${manifest.description}`);
+  console.log(`Domain:       ${manifest.domain}`);
+  console.log(`Category:     ${manifest.category}`);
+  console.log(`Requires:     ${manifest.requires?.join(', ') || 'none'}`);
+  console.log(`Keywords:     ${manifest.keywords?.join(', ')}`);
+  console.log(`Author:       ${manifest.author}`);
+  console.log(`License:      ${manifest.license}`);
+  console.log();
+
+  if (manifest.quality) {
+    const q = manifest.quality;
+    const compression = (q.source_tokens / manifest.tokens.total).toFixed(1);
+    const coveragePct = Math.round((q.scope.covered_items / q.scope.total_items) * 100);
+
+    console.log(`Quality:`);
+    console.log(`  Compression:  ${compression}x (${fmt(q.source_tokens)} source tokens -> ${fmt(manifest.tokens.total)} block tokens)`);
+    console.log(`  Coverage:     ${coveragePct}% of ${q.scope.type} (${q.scope.covered_items}/${q.scope.total_items} items)`);
+    console.log(`  Scope:        ${q.scope.description}`);
+    console.log(`  Verified:     ${q.verified} (${q.timestamp})`);
+    console.log(`  Status:       ${q.maintenance}`);
+    console.log();
+  }
+
+  console.log(`Tokens:`);
+  console.log(`  knowledge:  ${fmt(manifest.tokens.knowledge)}`);
+  console.log(`  rules:      ${fmt(manifest.tokens.rules)}`);
+  console.log(`  examples:   ${fmt(manifest.tokens.examples)}`);
+  console.log(`  total:      ${fmt(manifest.tokens.total)}`);
+  console.log();
+  console.log(`Sources:`);
+  for (const src of manifest.sources || []) {
+    console.log(`  ${src.title}: ${src.url}`);
+  }
+  console.log();
+}

package/lib/install.js

@@ -0,0 +1,114 @@
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { PACKAGES_DIR, REGISTRY_URL } from './config.js';
+
+function computeIntegrity(filePath) {
+  const content = readFileSync(filePath);
+  const hash = createHash('sha256').update(content).digest('hex');
+  return `sha256-${hash}`;
+}
+
+function updateLockfile(manifest) {
+  const lockPath = join(process.cwd(), 'aipkg.lock');
+  let lock = { lockfileVersion: 1, packages: {} };
+
+  if (existsSync(lockPath)) {
+    lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
+  }
+
+  lock.packages[manifest.name] = {
+    version: manifest.version,
+    integrity: computeIntegrity(join(PACKAGES_DIR, manifest.name, 'knowledge.md')),
+    tokens: manifest.tokens?.total || 0,
+    requires: manifest.requires || [],
+  };
+
+  writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
+  return lockPath;
+}
+
+function isLocalPath(arg) {
+  return arg.startsWith('.') || arg.startsWith('/') || arg.startsWith('~');
+}
+
+async function fetchFile(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download ${url}: ${res.status}`);
+  return res.text();
+}
+
+async function installRemote(packageName) {
+  // Fetch metadata from registry
+  console.log(`Resolving ${packageName}...`);
+  const metaRes = await fetch(`${REGISTRY_URL}/packages/${packageName}`);
+  if (!metaRes.ok) {
+    throw new Error(`Package not found: ${packageName}`);
+  }
+  const meta = await metaRes.json();
+
+  const destDir = join(PACKAGES_DIR, packageName);
+  mkdirSync(destDir, { recursive: true });
+
+  // Download all 4 files in parallel
+  console.log(`Downloading ${meta.name}@${meta.version}...`);
+  const files = ['manifest', 'knowledge', 'rules', 'examples'];
+  const filenames = {
+    manifest: 'manifest.json',
+    knowledge: 'knowledge.md',
+    rules: 'rules.xml',
+    examples: 'examples.yaml',
+  };
+
+  const downloads = await Promise.all(
+    files.map(async (key) => {
+      const content = await fetchFile(meta.files[key]);
+      return { key, content };
+    })
+  );
+
+  for (const { key, content } of downloads) {
+    writeFileSync(join(destDir, filenames[key]), content);
+  }
+
+  const manifest = JSON.parse(readFileSync(join(destDir, 'manifest.json'), 'utf-8'));
+  const lockPath = updateLockfile(manifest);
+
+  console.log(`✓ Installed ${manifest.name}@${manifest.version} (${manifest.tokens.total} tokens)`);
+  console.log(`  → ${destDir}`);
+  console.log(`  → ${lockPath}`);
+}
+
+async function installLocal(sourcePath) {
+  const manifestPath = join(sourcePath, 'manifest.json');
+  if (!existsSync(manifestPath)) {
+    throw new Error(`No manifest.json found in ${sourcePath}`);
+  }
+
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+
+  const required = ['knowledge.md', 'rules.xml', 'examples.yaml'];
+  for (const file of required) {
+    if (!existsSync(join(sourcePath, file))) {
+      throw new Error(`Missing required file: ${file}`);
+    }
+  }
+
+  const destDir = join(PACKAGES_DIR, manifest.name);
+  mkdirSync(destDir, { recursive: true });
+  cpSync(sourcePath, destDir, { recursive: true });
+
+  const lockPath = updateLockfile(manifest);
+
+  console.log(`✓ Installed ${manifest.name}@${manifest.version} (${manifest.tokens.total} tokens)`);
+  console.log(`  → ${destDir}`);
+  console.log(`  → ${lockPath}`);
+}
+
+export async function install(arg) {
+  if (isLocalPath(arg)) {
+    await installLocal(arg);
+  } else {
+    await installRemote(arg);
+  }
+}

package/lib/list.js

@@ -0,0 +1,32 @@
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { PACKAGES_DIR } from './config.js';
+
+export async function list() {
+  if (!existsSync(PACKAGES_DIR)) {
+    console.log('No packages installed.');
+    console.log(`Install path: ${PACKAGES_DIR}`);
+    return;
+  }
+
+  const dirs = readdirSync(PACKAGES_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory());
+
+  if (dirs.length === 0) {
+    console.log('No packages installed.');
+    return;
+  }
+
+  console.log(`\nInstalled packages (${PACKAGES_DIR}):\n`);
+
+  for (const dir of dirs) {
+    const manifestPath = join(PACKAGES_DIR, dir.name, 'manifest.json');
+    if (!existsSync(manifestPath)) continue;
+
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    const tokens = manifest.tokens?.total || '?';
+    console.log(`  ${manifest.name}@${manifest.version}  (${tokens} tokens)`);
+    console.log(`    ${manifest.description}`);
+    console.log();
+  }
+}

package/lib/serve.js

@@ -0,0 +1,256 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { PACKAGES_DIR } from './config.js';
+
+function loadPackages() {
+  if (!existsSync(PACKAGES_DIR)) return [];
+
+  return readdirSync(PACKAGES_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => {
+      const dir = join(PACKAGES_DIR, d.name);
+      const manifestPath = join(dir, 'manifest.json');
+      if (!existsSync(manifestPath)) return null;
+
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+      return { dir, manifest };
+    })
+    .filter(Boolean);
+}
+
+function readFile(pkgDir, filename) {
+  const filepath = join(pkgDir, filename);
+  return existsSync(filepath) ? readFileSync(filepath, 'utf-8') : '';
+}
+
+function buildCombined(pkgDir) {
+  const knowledge = readFile(pkgDir, 'knowledge.md');
+  const rules = readFile(pkgDir, 'rules.xml');
+  const examples = readFile(pkgDir, 'examples.yaml');
+
+  return [
+    knowledge,
+    '',
+    rules,
+    '',
+    '# Examples',
+    '```yaml',
+    examples,
+    '```',
+  ].join('\n');
+}
+
+export async function serve() {
+  const server = new Server(
+    { name: 'lingot-registry', version: '1.0.0' },
+    { capabilities: { resources: {}, tools: {} } }
+  );
+
+  // List all resources from installed packages
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const packages = loadPackages();
+    const resources = [];
+
+    for (const pkg of packages) {
+      const name = pkg.manifest.name;
+
+      // Combined resource
+      resources.push({
+        uri: `aipkg://local/${name}/combined`,
+        name: `${name} (full context)`,
+        description: pkg.manifest.description,
+        mimeType: 'text/markdown',
+      });
+
+      // Granular resources
+      resources.push({
+        uri: `aipkg://local/${name}/knowledge`,
+        name: `${name}/knowledge`,
+        description: `Domain knowledge for ${name}`,
+        mimeType: 'text/markdown',
+      });
+      resources.push({
+        uri: `aipkg://local/${name}/rules`,
+        name: `${name}/rules`,
+        description: `Constraints and heuristics for ${name}`,
+        mimeType: 'application/xml',
+      });
+      resources.push({
+        uri: `aipkg://local/${name}/examples`,
+        name: `${name}/examples`,
+        description: `Few-shot examples for ${name}`,
+        mimeType: 'text/yaml',
+      });
+    }
+
+    return { resources };
+  });
+
+  // Read a specific resource
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const match = uri.match(/^aipkg:\/\/local\/([^/]+)\/(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid resource URI: ${uri}`);
+    }
+
+    const [, pkgName, part] = match;
+    const pkgDir = join(PACKAGES_DIR, pkgName);
+
+    if (!existsSync(pkgDir)) {
+      throw new Error(`Package not found: ${pkgName}`);
+    }
+
+    let content;
+    let mimeType = 'text/plain';
+
+    switch (part) {
+      case 'combined':
+        content = buildCombined(pkgDir);
+        mimeType = 'text/markdown';
+        break;
+      case 'knowledge':
+        content = readFile(pkgDir, 'knowledge.md');
+        mimeType = 'text/markdown';
+        break;
+      case 'rules':
+        content = readFile(pkgDir, 'rules.xml');
+        mimeType = 'application/xml';
+        break;
+      case 'examples':
+        content = readFile(pkgDir, 'examples.yaml');
+        mimeType = 'text/yaml';
+        break;
+      default:
+        throw new Error(`Unknown resource part: ${part}`);
+    }
+
+    return {
+      contents: [{ uri, mimeType, text: content }],
+    };
+  });
+
+  // List available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: 'search_packages',
+          description: 'Search locally installed Lingot intelligence blocks by topic, domain, or category. Returns verified, version-locked context packages with token counts. Use when you need authoritative reference material for a specific technology or domain.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Search term to match against package names, descriptions, and keywords',
+              },
+              domain: {
+                type: 'string',
+                description: 'Filter by domain (e.g., payments, infrastructure)',
+              },
+              category: {
+                type: 'string',
+                description: 'Filter by category (e.g., developer, architect)',
+              },
+            },
+          },
+        },
+        {
+          name: 'get_package_context',
+          description: 'Retrieve the full verified context of an Ingot intelligence block. Returns curated domain knowledge, strict heuristic constraints, and schema-validated code examples. Use to ensure syntax compliance with the latest API patterns.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'The package name (e.g., stripe-webhooks)',
+              },
+              part: {
+                type: 'string',
+                enum: ['combined', 'knowledge', 'rules', 'examples'],
+                description: 'Which part to retrieve. Defaults to combined.',
+              },
+            },
+            required: ['name'],
+          },
+        },
+      ],
+    };
+  });
+
+  // Handle tool calls
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    if (name === 'search_packages') {
+      const packages = loadPackages();
+      const query = (args.query || '').toLowerCase();
+      const domain = args.domain?.toLowerCase();
+      const category = args.category?.toLowerCase();
+
+      const results = packages.filter(pkg => {
+        const m = pkg.manifest;
+        const matchesQuery = !query ||
+          m.name.includes(query) ||
+          m.description.toLowerCase().includes(query) ||
+          m.keywords?.some(k => k.toLowerCase().includes(query));
+        const matchesDomain = !domain || m.domain?.toLowerCase() === domain;
+        const matchesCategory = !category || m.category?.toLowerCase() === category;
+        return matchesQuery && matchesDomain && matchesCategory;
+      });
+
+      const text = results.length === 0
+        ? 'No packages found.'
+        : results.map(pkg => {
+            const m = pkg.manifest;
+            return `${m.name}@${m.version} (${m.tokens.total} tokens)\n  ${m.description}\n  domain: ${m.domain} | category: ${m.category}\n  keywords: ${m.keywords?.join(', ')}`;
+          }).join('\n\n');
+
+      return { content: [{ type: 'text', text }] };
+    }
+
+    if (name === 'get_package_context') {
+      const pkgName = args.name;
+      const part = args.part || 'combined';
+      const pkgDir = join(PACKAGES_DIR, pkgName);
+
+      if (!existsSync(pkgDir)) {
+        return { content: [{ type: 'text', text: `Package not found: ${pkgName}` }] };
+      }
+
+      let content;
+      switch (part) {
+        case 'combined':
+          content = buildCombined(pkgDir);
+          break;
+        case 'knowledge':
+          content = readFile(pkgDir, 'knowledge.md');
+          break;
+        case 'rules':
+          content = readFile(pkgDir, 'rules.xml');
+          break;
+        case 'examples':
+          content = readFile(pkgDir, 'examples.yaml');
+          break;
+        default:
+          content = buildCombined(pkgDir);
+      }
+
+      return { content: [{ type: 'text', text: content }] };
+    }
+
+    throw new Error(`Unknown tool: ${name}`);
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // Server is now running on stdio
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "lingot",
+  "version": "1.0.0",
+  "description": "The standard library for AI agents. Intelligence blocks that make Cursor, Windsurf, and Claude Code measurably better.",
+  "type": "module",
+  "bin": {
+    "lingot": "./bin/lingot.js"
+  },
+  "scripts": {
+    "test": "node bin/lingot.js list"
+  },
+  "keywords": ["ai", "agents", "context", "mcp", "cursor", "windsurf", "claude", "intelligence-blocks", "llm"],
+  "author": "Lingot <hello@lingot.sh>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lingot-sh/lingot"
+  },
+  "homepage": "https://lingot.sh",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}