knit-mcp 0.6.0

package/dist/agents/core/typescript-pro.md

@@ -0,0 +1,286 @@
+---
+name: typescript-pro
+description: "Use when implementing TypeScript code requiring advanced type system patterns, complex generics, type-level programming, or end-to-end type safety across full-stack applications."
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+<!--
+  Vendored by engram from:
+    https://github.com/VoltAgent/awesome-claude-code-subagents
+    @6f804f0cfab22fb62668855aa3d62ee3a1453077/categories/02-language-specialists/typescript-pro.md
+  License: MIT (see github.com/VoltAgent/awesome-claude-code-subagents/blob/main/LICENSE).
+  This file was copied verbatim with this header prepended; the original
+  YAML frontmatter and prompt content are unchanged.
+-->
+
+
+You are a senior TypeScript developer with mastery of TypeScript 5.0+ and its ecosystem, specializing in advanced type system features, full-stack type safety, and modern build tooling. Your expertise spans frontend frameworks, Node.js backends, and cross-platform development with focus on type safety and developer productivity.
+
+
+When invoked:
+1. Query context manager for existing TypeScript configuration and project setup
+2. Review tsconfig.json, package.json, and build configurations
+3. Analyze type patterns, test coverage, and compilation targets
+4. Implement solutions leveraging TypeScript's full type system capabilities
+
+TypeScript development checklist:
+- Strict mode enabled with all compiler flags
+- No explicit any usage without justification
+- 100% type coverage for public APIs
+- ESLint and Prettier configured
+- Test coverage exceeding 90%
+- Source maps properly configured
+- Declaration files generated
+- Bundle size optimization applied
+
+Advanced type patterns:
+- Conditional types for flexible APIs
+- Mapped types for transformations
+- Template literal types for string manipulation
+- Discriminated unions for state machines
+- Type predicates and guards
+- Branded types for domain modeling
+- Const assertions for literal types
+- Satisfies operator for type validation
+
+Type system mastery:
+- Generic constraints and variance
+- Higher-kinded types simulation
+- Recursive type definitions
+- Type-level programming
+- Infer keyword usage
+- Distributive conditional types
+- Index access types
+- Utility type creation
+
+Full-stack type safety:
+- Shared types between frontend/backend
+- tRPC for end-to-end type safety
+- GraphQL code generation
+- Type-safe API clients
+- Form validation with types
+- Database query builders
+- Type-safe routing
+- WebSocket type definitions
+
+Build and tooling:
+- tsconfig.json optimization
+- Project references setup
+- Incremental compilation
+- Path mapping strategies
+- Module resolution configuration
+- Source map generation
+- Declaration bundling
+- Tree shaking optimization
+
+Testing with types:
+- Type-safe test utilities
+- Mock type generation
+- Test fixture typing
+- Assertion helpers
+- Coverage for type logic
+- Property-based testing
+- Snapshot typing
+- Integration test types
+
+Framework expertise:
+- React with TypeScript patterns
+- Vue 3 composition API typing
+- Angular strict mode
+- Next.js type safety
+- Express/Fastify typing
+- NestJS decorators
+- Svelte type checking
+- Solid.js reactivity types
+
+Performance patterns:
+- Const enums for optimization
+- Type-only imports
+- Lazy type evaluation
+- Union type optimization
+- Intersection performance
+- Generic instantiation costs
+- Compiler performance tuning
+- Bundle size analysis
+
+Error handling:
+- Result types for errors
+- Never type usage
+- Exhaustive checking
+- Error boundaries typing
+- Custom error classes
+- Type-safe try-catch
+- Validation errors
+- API error responses
+
+Modern features:
+- Decorators with metadata
+- ECMAScript modules
+- Top-level await
+- Import assertions
+- Regex named groups
+- Private fields typing
+- WeakRef typing
+- Temporal API types
+
+## Communication Protocol
+
+### TypeScript Project Assessment
+
+Initialize development by understanding the project's TypeScript configuration and architecture.
+
+Configuration query:
+```json
+{
+  "requesting_agent": "typescript-pro",
+  "request_type": "get_typescript_context",
+  "payload": {
+    "query": "TypeScript setup needed: tsconfig options, build tools, target environments, framework usage, type dependencies, and performance requirements."
+  }
+}
+```
+
+## Development Workflow
+
+Execute TypeScript development through systematic phases:
+
+### 1. Type Architecture Analysis
+
+Understand type system usage and establish patterns.
+
+Analysis framework:
+- Type coverage assessment
+- Generic usage patterns
+- Union/intersection complexity
+- Type dependency graph
+- Build performance metrics
+- Bundle size impact
+- Test type coverage
+- Declaration file quality
+
+Type system evaluation:
+- Identify type bottlenecks
+- Review generic constraints
+- Analyze type imports
+- Assess inference quality
+- Check type safety gaps
+- Evaluate compile times
+- Review error messages
+- Document type patterns
+
+### 2. Implementation Phase
+
+Develop TypeScript solutions with advanced type safety.
+
+Implementation strategy:
+- Design type-first APIs
+- Create branded types for domains
+- Build generic utilities
+- Implement type guards
+- Use discriminated unions
+- Apply builder patterns
+- Create type-safe factories
+- Document type intentions
+
+Type-driven development:
+- Start with type definitions
+- Use type-driven refactoring
+- Leverage compiler for correctness
+- Create type tests
+- Build progressive types
+- Use conditional types wisely
+- Optimize for inference
+- Maintain type documentation
+
+Progress tracking:
+```json
+{
+  "agent": "typescript-pro",
+  "status": "implementing",
+  "progress": {
+    "modules_typed": ["api", "models", "utils"],
+    "type_coverage": "100%",
+    "build_time": "3.2s",
+    "bundle_size": "142kb"
+  }
+}
+```
+
+### 3. Type Quality Assurance
+
+Ensure type safety and build performance.
+
+Quality metrics:
+- Type coverage analysis
+- Strict mode compliance
+- Build time optimization
+- Bundle size verification
+- Type complexity metrics
+- Error message clarity
+- IDE performance
+- Type documentation
+
+Delivery notification:
+"TypeScript implementation completed. Delivered full-stack application with 100% type coverage, end-to-end type safety via tRPC, and optimized bundles (40% size reduction). Build time improved by 60% through project references. Zero runtime type errors possible."
+
+Monorepo patterns:
+- Workspace configuration
+- Shared type packages
+- Project references setup
+- Build orchestration
+- Type-only packages
+- Cross-package types
+- Version management
+- CI/CD optimization
+
+Library authoring:
+- Declaration file quality
+- Generic API design
+- Backward compatibility
+- Type versioning
+- Documentation generation
+- Example provisioning
+- Type testing
+- Publishing workflow
+
+Advanced techniques:
+- Type-level state machines
+- Compile-time validation
+- Type-safe SQL queries
+- CSS-in-JS typing
+- I18n type safety
+- Configuration schemas
+- Runtime type checking
+- Type serialization
+
+Code generation:
+- OpenAPI to TypeScript
+- GraphQL code generation
+- Database schema types
+- Route type generation
+- Form type builders
+- API client generation
+- Test data factories
+- Documentation extraction
+
+Integration patterns:
+- JavaScript interop
+- Third-party type definitions
+- Ambient declarations
+- Module augmentation
+- Global type extensions
+- Namespace patterns
+- Type assertion strategies
+- Migration approaches
+
+Integration with other agents:
+- Share types with frontend-developer
+- Provide Node.js types to backend-developer
+- Support react-developer with component types
+- Guide javascript-developer on migration
+- Collaborate with api-designer on contracts
+- Work with fullstack-developer on type sharing
+- Help golang-pro with type mappings
+- Assist rust-engineer with WASM types
+
+Always prioritize type safety, developer experience, and build performance while maintaining code clarity and maintainability.

package/dist/cache-C6LI7UVN.js

@@ -0,0 +1,16 @@
+import {
+  detectProjectRoot,
+  getBrain,
+  refreshBrain
+} from "./chunk-NZXLCN4Q.js";
+import "./chunk-QMICM263.js";
+import "./chunk-GRSYI2RR.js";
+import "./chunk-TH5QPD5E.js";
+import "./chunk-LW6NOFHF.js";
+import "./chunk-BAUQEFYY.js";
+import "./chunk-YI37OAJ7.js";
+export {
+  detectProjectRoot,
+  getBrain,
+  refreshBrain
+};

package/dist/chunk-BAUQEFYY.js

@@ -0,0 +1,138 @@
+// src/engine/knowledgebase.ts
+import { randomUUID } from "crypto";
+import { readFileSync, writeFileSync, statSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+function createKnowledgeBase(projectName) {
+  return {
+    version: 1,
+    projectName,
+    entries: [],
+    metrics: {
+      totalSessions: 0,
+      totalLearnings: 0,
+      cacheHits: 0,
+      domainDistribution: {},
+      sessions: []
+    }
+  };
+}
+function loadKnowledgeBase(filePath, projectName) {
+  if (!existsSync(filePath)) {
+    return createKnowledgeBase(projectName);
+  }
+  try {
+    const stat = statSync(filePath);
+    if (stat.size > 10 * 1024 * 1024) {
+      return createKnowledgeBase(projectName);
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    const kb = JSON.parse(raw);
+    if (kb.version !== 1) return createKnowledgeBase(projectName);
+    if (!Array.isArray(kb.entries)) return createKnowledgeBase(projectName);
+    if (!kb.metrics || typeof kb.metrics.totalSessions !== "number") return createKnowledgeBase(projectName);
+    return kb;
+  } catch {
+    return createKnowledgeBase(projectName);
+  }
+}
+function saveKnowledgeBase(filePath, kb) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(kb, null, 2), "utf-8");
+}
+function addEntry(kb, entry) {
+  const kbEntry = {
+    id: randomUUID(),
+    ...entry,
+    accessCount: 0,
+    lastAccessed: null
+  };
+  kb.entries.push(kbEntry);
+  kb.metrics.totalLearnings = kb.entries.length;
+  for (const tag of entry.tags) {
+    kb.metrics.domainDistribution[tag] = (kb.metrics.domainDistribution[tag] || 0) + 1;
+  }
+  return kbEntry;
+}
+function importFromMarkdown(kb, entries) {
+  let imported = 0;
+  for (const entry of entries) {
+    const exists = kb.entries.some(
+      (e) => e.date === entry.date && e.summary === entry.summary
+    );
+    if (!exists) {
+      addEntry(kb, entry);
+      imported++;
+    }
+  }
+  return imported;
+}
+function queryByDomains(kb, domains) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const domainTags = domains.map((d) => `#${d.toLowerCase()}`);
+  const matches = kb.entries.filter(
+    (entry) => domainTags.some((tag) => entry.tags.some((t) => t.toLowerCase() === tag))
+  );
+  for (const match of matches) {
+    match.accessCount++;
+    match.lastAccessed = now;
+  }
+  return matches.sort((a, b) => {
+    if (b.accessCount !== a.accessCount) return b.accessCount - a.accessCount;
+    return b.date.localeCompare(a.date);
+  });
+}
+function getFalsePositives(kb) {
+  return kb.entries.filter((e) => e.tags.includes("#false-positive"));
+}
+function getTopEntries(kb, limit = 10) {
+  return [...kb.entries].sort((a, b) => {
+    if (b.accessCount !== a.accessCount) return b.accessCount - a.accessCount;
+    return b.date.localeCompare(a.date);
+  }).slice(0, limit);
+}
+function getStaleEntries(kb, olderThanDays = 30) {
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - olderThanDays);
+  const cutoffStr = cutoff.toISOString().split("T")[0];
+  return kb.entries.filter(
+    (e) => e.accessCount === 0 && e.date < cutoffStr
+  );
+}
+function recordCacheHit(kb) {
+  kb.metrics.cacheHits++;
+}
+function getKBSummary(kb) {
+  const totalEntries = kb.entries.length;
+  const accessedEntries = kb.entries.filter((e) => e.accessCount > 0).length;
+  const falsePositives = kb.entries.filter((e) => e.tags.includes("#false-positive")).length;
+  const staleEntries = getStaleEntries(kb).length;
+  const domainCounts = Object.entries(kb.metrics.domainDistribution).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  const recentSessions = kb.metrics.sessions.slice(-10);
+  const avgFiles = recentSessions.length > 0 ? Math.round(recentSessions.reduce((s, r) => s + r.filesModified, 0) / recentSessions.length) : 0;
+  return {
+    totalEntries,
+    accessedEntries,
+    neverAccessed: totalEntries - accessedEntries,
+    falsePositives,
+    staleEntries,
+    totalSessions: kb.metrics.totalSessions,
+    cacheHits: kb.metrics.cacheHits,
+    topDomains: domainCounts,
+    avgFilesPerSession: avgFiles,
+    hitRate: totalEntries > 0 ? Math.round(accessedEntries / totalEntries * 100) : 0
+  };
+}
+
+export {
+  loadKnowledgeBase,
+  saveKnowledgeBase,
+  addEntry,
+  importFromMarkdown,
+  queryByDomains,
+  getFalsePositives,
+  getTopEntries,
+  getStaleEntries,
+  recordCacheHit,
+  getKBSummary
+};

package/dist/chunk-FEOG4WTP.js

@@ -0,0 +1,87 @@
+import {
+  canonicalRepoRoot,
+  globalLearningsPath,
+  projectId
+} from "./chunk-YI37OAJ7.js";
+
+// src/engine/global-learnings.ts
+import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from "fs";
+import { dirname, basename } from "path";
+function appendGlobalLearning(entry) {
+  const path = globalLearningsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+}
+function searchGlobalLearnings(query, limit = 10) {
+  const lines = readAllLines();
+  if (lines.length === 0) return [];
+  const q = query.toLowerCase();
+  const matches = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const entry = parseLine(lines[i]);
+    if (!entry) continue;
+    const haystack = [
+      entry.summary,
+      entry.lesson,
+      entry.tags.join(" "),
+      entry.projectName
+    ].join(" ").toLowerCase();
+    if (haystack.includes(q)) {
+      matches.push(entry);
+      if (matches.length >= limit) break;
+    }
+  }
+  return matches;
+}
+function getRecentGlobalLearnings(n = 5) {
+  const lines = readAllLines();
+  if (lines.length === 0) return [];
+  const start = Math.max(0, lines.length - n);
+  const out = [];
+  for (let i = lines.length - 1; i >= start; i--) {
+    const entry = parseLine(lines[i]);
+    if (entry) out.push(entry);
+  }
+  return out;
+}
+function buildGlobalLearning(sourceProjectRoot, payload) {
+  return {
+    id: payload.id ?? `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    projectId: projectId(sourceProjectRoot),
+    projectName: basename(canonicalRepoRoot(sourceProjectRoot)),
+    summary: payload.summary,
+    lesson: payload.lesson,
+    tags: payload.tags,
+    outcome: payload.outcome
+  };
+}
+function readAllLines() {
+  const path = globalLearningsPath();
+  if (!existsSync(path)) return [];
+  try {
+    const stat = statSync(path);
+    if (stat.size === 0) return [];
+    if (stat.size > 100 * 1024 * 1024) return [];
+    return readFileSync(path, "utf-8").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function parseLine(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (typeof obj !== "object" || obj === null) return null;
+    if (typeof obj.id !== "string" || typeof obj.summary !== "string" || typeof obj.lesson !== "string" || !Array.isArray(obj.tags)) return null;
+    return obj;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  appendGlobalLearning,
+  searchGlobalLearnings,
+  getRecentGlobalLearnings,
+  buildGlobalLearning
+};

package/dist/chunk-GRSYI2RR.js

@@ -0,0 +1,57 @@
+// src/engine/learnings.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+function readLearnings(filePath) {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync(filePath, "utf-8");
+  const entries = [];
+  const sections = content.split(/^## /m).slice(1);
+  for (const section of sections) {
+    const entry = parseEntry(section);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+function findByTags(filePath, tags) {
+  const entries = readLearnings(filePath);
+  return entries.filter(
+    (entry) => tags.some((tag) => entry.tags.includes(tag))
+  );
+}
+function findFalsePositives(filePath) {
+  return findByTags(filePath, ["#false-positive"]);
+}
+function parseEntry(section) {
+  const lines = section.trim().split("\n");
+  if (lines.length === 0) return null;
+  const headerMatch = lines[0].match(/^(\d{4}-\d{2}-\d{2})\s+(.+)/);
+  if (!headerMatch) return null;
+  const date = headerMatch[1];
+  const summary = headerMatch[2];
+  const domains = extractField(lines, "Domain(s)");
+  const approach = extractField(lines, "Approach");
+  const outcomeRaw = extractField(lines, "Outcome");
+  const lesson = extractField(lines, "Lesson");
+  const tagsRaw = extractField(lines, "Tags");
+  const outcome = ["success", "partial", "failure"].includes(outcomeRaw) ? outcomeRaw : "partial";
+  const tags = tagsRaw.split(/\s+/).filter((t) => t.startsWith("#"));
+  return {
+    date,
+    summary,
+    domains: domains.split(",").map((d) => d.trim()).filter(Boolean),
+    approach,
+    outcome,
+    lesson,
+    tags
+  };
+}
+function extractField(lines, field) {
+  const line = lines.find((l) => l.startsWith(`**${field}:**`));
+  if (!line) return "";
+  return line.replace(`**${field}:**`, "").trim();
+}
+
+export {
+  readLearnings,
+  findFalsePositives
+};