Compare commits

..
Author SHA1 Message Date
Rohit Ghumare 6eb06f647d fix(agents): getAllAdapters returns correct agent types
Fixed getAllAdapters() to return the correct agent type from the
record keys instead of relying on adapter.type property, which
was returning 'universal' for all UniversalAdapter instances.

This fixes the E2E test that checks for all 32 agents in init --list
output (cline, codebuddy, commandcode, etc. were showing as 'universal').
2026-01-29 19:19:35 +00:00
Rohit Ghumare 2d094fdd71 feat(primer): support multi-format output rendering
Refactored generateContent to properly respect the format field
instead of always producing Markdown output.

- Added FormatRenderer interface with format-specific implementations
- Created renderers for markdown, mdc, json, xml formats
- JSON format generates structured data via generateJsonContent()
- MDC format includes YAML frontmatter via wrap() method
- XML format properly escapes content with escapeXml()
- Updated all section generators to accept and use the renderer
2026-01-29 19:07:59 +00:00
Rohit Ghumare e9b5c647e2 fix: additional CodeRabbit review fixes for primer
- Fix Python detection to use correct source file (pyproject.toml, requirements.txt, or setup.py)
- Escape regex special characters in glob pattern matching (e.g., *.module.css)
- Derive ALL_AGENTS from AGENT_CONFIG to avoid divergence
- Map agent config format to template format based on file extension
2026-01-29 18:45:43 +00:00
Rohit Ghumare 8a51c73f2a fix: address CodeRabbit PR review issues for primer
- Fix OS-agnostic path handling in analyzer using path.relative() and path.sep
- Prevent output collisions when multiple agents produce same filename
- Add defensive check in test before accessing generated[0]
- Remove duplicate projectPath parameter in CLI primer command
- Use PackageManager enum instead of z.string() for type safety
- Detect monorepos before src-based layout to prevent misclassification
- Document --output and --json flags in README examples
2026-01-29 18:34:06 +00:00
Rohit Ghumare db277fedbc feat: add skillkit primer command for AI instruction generation
New feature that analyzes codebases and generates AI instruction files
for all 32 supported agents (inspired by pierceboggan/primer).

## New Module: packages/core/src/primer/
- types.ts: Zod schemas and TypeScript interfaces
- analyzer.ts: Codebase analysis (languages, frameworks, conventions)
- generator.ts: Agent-specific instruction file generation
- index.ts: Barrel exports
- __tests__/primer.test.ts: 15 comprehensive tests

## CLI Command: skillkit primer
- --agent/-a: Generate for specific agents
- --all-agents/-A: Generate for all 32 agents
- --output/-o: Custom output directory
- --dry-run/-n: Preview without writing
- --analyze-only: Show analysis only
- --verbose/-v: Detailed output
- --json/-j: JSON output

## Features
- Detects: languages, frameworks, package managers, libraries
- Analyzes: project structure, code conventions, CI/CD, Docker
- Generates: CLAUDE.md, .cursorrules, copilot-instructions.md, etc.
2026-01-29 13:36:00 +00:00
166 changed files with 3598 additions and 19815 deletions
-42
View File
@@ -1,42 +0,0 @@
---
name: Add Skill Source
about: Submit your skill repository to be included in SkillKit
title: "[Source] Add <repository-name>"
labels: skill-source, enhancement
assignees: rohitg00
---
## Repository Information
**Repository URL:** `https://github.com/<owner>/<repo>`
**Repository Name:**
<!-- Short name for display (e.g., "Anthropic Official", "React Patterns") -->
**Description:**
<!-- Brief description of the skills in your repository -->
**License:**
<!-- MIT, Apache 2.0, etc. -->
## Skill Details
**Approximate skill count:**
<!-- How many skills does your repository contain? -->
**Categories/Tags:**
<!-- What categories do your skills cover? e.g., react, typescript, security, testing -->
**Target AI Agents:**
<!-- Which agents are your skills designed for? e.g., Claude Code, Cursor, all -->
## Checklist
- [ ] Repository is public
- [ ] Repository contains valid SKILL.md files
- [ ] Repository has a clear license
- [ ] Skills follow the [Agent Skills specification](https://agenstskills.com)
## Additional Context
<!-- Any other information about your repository -->
+1 -1
View File
@@ -83,7 +83,7 @@ body:
options:
- label: Repository is public
required: true
- label: SKILL.md follows the agenstskills.com standard format
- label: SKILL.md follows the agentskills.io standard format
required: true
- label: Skill has been tested with at least one AI agent
required: false
+1 -1
View File
@@ -206,7 +206,7 @@ To add support for a new AI coding agent:
If you want to contribute skills to the ecosystem:
1. Follow the [Agent Skills specification](https://agenstskills.com)
1. Follow the [Agent Skills specification](https://agentskills.io/specification)
2. Include a `SKILL.md` with proper frontmatter
3. Test with multiple agents using `skillkit translate`
4. Submit to the appropriate skill repository
+22 -83
View File
@@ -22,10 +22,6 @@
> **What are AI Agent Skills?** Skills are instruction files that teach AI coding agents how to handle specific tasks - like processing PDFs, following React best practices, or enforcing security patterns. Think of them as plugins for your AI assistant.
```bash
# Quick start (no install required)
npx skillkit@latest
# Or install globally
npm install -g skillkit
```
@@ -82,17 +78,22 @@ SkillKit features a polished, interactive CLI with visual feedback:
## 5-Minute Quick Start
```bash
# Launch interactive TUI (no install required)
npx skillkit@latest
# Or with specific commands:
npx skillkit recommend # Get smart recommendations
npx skillkit install anthropics/skills # Install official skills
npx skillkit sync # Sync to your AI agent
# For frequent use, install globally:
# 1. Install SkillKit globally
npm install -g skillkit
skillkit # Launch TUI
# 2. Launch the interactive TUI (easiest way to start)
skillkit
# Or use CLI commands directly:
# 3. Get personalized skill recommendations
skillkit recommend
# 4. Install skills from the marketplace
skillkit install anthropics/skills
# 5. Sync to your AI agent
skillkit sync
```
## Core Features
@@ -353,37 +354,6 @@ skillkit memory compress # Compress observations
skillkit memory export # Export as skill
```
### Mesh Network
```bash
skillkit mesh init # Initialize mesh network
skillkit mesh add <address> # Add a host to mesh
skillkit mesh remove <id> # Remove a host from mesh
skillkit mesh list # List known hosts
skillkit mesh discover # Discover hosts on LAN
skillkit mesh health # Check host health
skillkit mesh status # Show mesh status
# Security
skillkit mesh security init # Setup encryption keys
skillkit mesh security status # Show security status
skillkit mesh peer trust <id> # Trust a peer
skillkit mesh peer revoke <id># Revoke peer trust
skillkit mesh peer list # List trusted peers
```
### Inter-Agent Messaging
```bash
skillkit message send # Send message to agent
skillkit message inbox # View inbox
skillkit message read <id> # Read a message
skillkit message reply <id> # Reply to message
skillkit message archive <id> # Archive message
skillkit message sent # View sent messages
skillkit message status # Messaging status
```
### Quality & Testing
```bash
@@ -450,7 +420,7 @@ skillkit create my-skill
### Manual Creation
Create a `SKILL.md` file following the [Agent Skills specification](https://agenstskills.com):
Create a `SKILL.md` file following the [Agent Skills specification](https://agentskills.io/specification):
```markdown
---
@@ -522,43 +492,12 @@ const profile = await analyzeProject('./my-project');
const recs = engine.recommend(profile);
```
## Skill Sources & Attribution
## Popular Skill Repositories
SkillKit aggregates skills from trusted sources. We credit and link back to all original creators. Each source retains its original license.
### Official Partner Sources
| Repository | Description | License |
|------------|-------------|---------|
| [anthropics/skills](https://github.com/anthropics/skills) | Official Claude Code skills from Anthropic | Apache 2.0 |
| [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | Next.js, React, and Vercel platform skills | MIT |
| [expo/skills](https://github.com/expo/skills) | Mobile development with Expo and React Native | MIT |
| [remotion-dev/skills](https://github.com/remotion-dev/skills) | Programmatic video creation with React | MIT |
| [supabase/agent-skills](https://github.com/supabase/agent-skills) | Database, auth, and backend skills | Apache 2.0 |
| [stripe/ai](https://github.com/stripe/ai) | Payment integration and Stripe API patterns | MIT |
### Community Contributors
| Repository | Description | License |
|------------|-------------|---------|
| [trailofbits/skills](https://github.com/trailofbits/skills) | Security analysis and vulnerability detection | Apache 2.0 |
| [obra/superpowers](https://github.com/obra/superpowers) | Test-driven development and workflow automation | MIT |
| [wshobson/agents](https://github.com/wshobson/agents) | Development patterns and agent configurations (48 agents) | MIT |
| [ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) | Curated collection of Claude Code skills | MIT |
| [travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) | Community-curated skill collection | MIT |
| [langgenius/dify](https://github.com/langgenius/dify) | AI application development platform patterns | Apache 2.0 |
| [better-auth/skills](https://github.com/better-auth/skills) | Authentication and authorization patterns | MIT |
| [onmax/nuxt-skills](https://github.com/onmax/nuxt-skills) | Vue.js and Nuxt framework skills | MIT |
| [elysiajs/skills](https://github.com/elysiajs/skills) | Bun runtime and ElysiaJS framework | MIT |
| [kadajett/agent-nestjs-skills](https://github.com/kadajett/agent-nestjs-skills) | NestJS backend framework patterns | MIT |
| [cloudai-x/threejs-skills](https://github.com/cloudai-x/threejs-skills) | 3D graphics and WebGL development | MIT |
| [dimillian/skills](https://github.com/dimillian/skills) | iOS and SwiftUI development patterns | MIT |
| [waynesutton/convexskills](https://github.com/waynesutton/convexskills) | Convex backend development | MIT |
| [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) | Obsidian plugin and vault management | MIT |
| [giuseppe-trisciuoglio/developer-kit](https://github.com/giuseppe-trisciuoglio/developer-kit) | UI component libraries (Shadcn/Radix) | MIT |
| [openrouterteam/agent-skills](https://github.com/openrouterteam/agent-skills) | OpenRouter API integration patterns | MIT |
**Want to add your skills?** [Submit your repository](https://github.com/rohitg00/skillkit/issues/new?template=add-source.md) to be included in SkillKit
| Repository | Description |
|------------|-------------|
| [anthropics/skills](https://github.com/anthropics/skills) | Official Claude Code marketplace - PDF, XLSX, DOCX processing |
| [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | React/Next.js best practices, web design guidelines |
## Installation Options
@@ -609,7 +548,7 @@ Contributions welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md
- [Documentation](https://agenstskills.com/docs)
- [Website](https://agenstskills.com)
- [Agent Skills Specification](https://agenstskills.com)
- [Agent Skills Specification](https://agentskills.io/specification)
- [GitHub Repository](https://github.com/rohitg00/skillkit)
- [NPM Package](https://www.npmjs.com/package/skillkit)
- [GitHub Package](https://github.com/rohitg00/skillkit/pkgs/npm/skillkit)
+1 -4
View File
@@ -1,6 +1,6 @@
{
"name": "skillkit",
"version": "1.8.0",
"version": "1.7.9",
"description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 13 more",
"type": "module",
"bin": {
@@ -57,9 +57,6 @@
"@skillkit/agents": "workspace:*",
"@skillkit/cli": "workspace:*",
"@skillkit/tui": "workspace:*",
"@skillkit/memory": "workspace:*",
"@skillkit/mesh": "workspace:*",
"@skillkit/messaging": "workspace:*",
"clipanion": "^4.0.0-rc.4"
},
"devDependencies": {
-84
View File
@@ -26,8 +26,6 @@ import {
WorkflowRunCommand,
WorkflowListCommand,
WorkflowCreateCommand,
WorkflowPipelineCommand,
WorkflowPipelineListCommand,
RunCommand,
TestCommand,
MarketplaceCommand,
@@ -38,13 +36,8 @@ import {
PluginCommand,
MethodologyCommand,
HookCommand,
HookTemplateListCommand,
HookTemplateApplyCommand,
HookTemplateShowCommand,
PlanCommand,
CommandCmd,
CommandAvailableCommand,
CommandInstallCommand,
AICommand,
AuditCommand,
PublishCommand,
@@ -55,8 +48,6 @@ import {
AgentTranslateCommand,
AgentSyncCommand,
AgentValidateCommand,
AgentInstallCommand,
AgentAvailableCommand,
CheckCommand,
FindCommand,
ManifestCommand,
@@ -66,35 +57,6 @@ import {
ManifestInstallCommand,
ManifestGenerateCommand,
PrimerCommand,
MeshCommand,
MessageCommand,
LearnCommand,
PatternStatusCommand,
PatternFeedbackCommand,
PatternApproveCommand,
PatternRejectCommand,
PatternExportCommand,
PatternImportCommand,
PatternClusterCommand,
SessionCommand,
SessionStatusCommand,
SessionStartCommand,
SessionLoadCommand,
SessionListCommand,
SessionNoteCommand,
SessionCompleteCommand,
SessionInProgressCommand,
ProfileCommand,
ProfileListCommand,
ProfileCreateCommand,
ProfileRemoveCommand,
GuidelineCommand,
GuidelineListCommand,
GuidelineShowCommand,
GuidelineEnableCommand,
GuidelineDisableCommand,
GuidelineCreateCommand,
GuidelineRemoveCommand,
} from '@skillkit/cli';
const __filename = fileURLToPath(import.meta.url);
@@ -166,51 +128,5 @@ cli.register(ManifestRemoveCommand);
cli.register(ManifestInstallCommand);
cli.register(ManifestGenerateCommand);
cli.register(PrimerCommand);
cli.register(MeshCommand);
cli.register(MessageCommand);
cli.register(WorkflowPipelineCommand);
cli.register(WorkflowPipelineListCommand);
cli.register(HookTemplateListCommand);
cli.register(HookTemplateApplyCommand);
cli.register(HookTemplateShowCommand);
cli.register(CommandAvailableCommand);
cli.register(CommandInstallCommand);
cli.register(AgentInstallCommand);
cli.register(AgentAvailableCommand);
cli.register(LearnCommand);
cli.register(PatternStatusCommand);
cli.register(PatternFeedbackCommand);
cli.register(PatternApproveCommand);
cli.register(PatternRejectCommand);
cli.register(PatternExportCommand);
cli.register(PatternImportCommand);
cli.register(PatternClusterCommand);
cli.register(SessionCommand);
cli.register(SessionStatusCommand);
cli.register(SessionStartCommand);
cli.register(SessionLoadCommand);
cli.register(SessionListCommand);
cli.register(SessionNoteCommand);
cli.register(SessionCompleteCommand);
cli.register(SessionInProgressCommand);
cli.register(ProfileCommand);
cli.register(ProfileListCommand);
cli.register(ProfileCreateCommand);
cli.register(ProfileRemoveCommand);
cli.register(GuidelineCommand);
cli.register(GuidelineListCommand);
cli.register(GuidelineShowCommand);
cli.register(GuidelineEnableCommand);
cli.register(GuidelineDisableCommand);
cli.register(GuidelineCreateCommand);
cli.register(GuidelineRemoveCommand);
cli.runExit(process.argv.slice(2));
+1 -12
View File
@@ -5,18 +5,7 @@ description: Install SkillKit and set up your first project
# Installation
SkillKit is distributed as an npm package. Current version: **v1.8.0**
## Quick Start (No Install)
```bash
# Run without installing
npx skillkit@latest
# Run specific commands
npx skillkit recommend
npx skillkit install anthropics/skills
```
SkillKit is distributed as an npm package. Current version: **v1.7.5**
## Install Globally
-118
View File
@@ -1,118 +0,0 @@
---
title: Mesh Network
description: Multi-machine agent distribution with secure peer-to-peer communication
---
# Mesh Network
SkillKit's mesh network enables secure communication between AI agents across multiple machines. Share skills, synchronize memory, and collaborate across your development environment.
## Quick Start
```bash
# Initialize mesh on your machine
npx skillkit mesh init
# Discover other hosts on your LAN
npx skillkit mesh discover
# Add a specific host
npx skillkit mesh add 192.168.1.100
```
## Security
The mesh network uses enterprise-grade security:
- **Ed25519** - Peer identity and message signing
- **XChaCha20-Poly1305** - End-to-end message encryption
- **TLS 1.3** - Transport layer security
- **JWT with EdDSA** - Authentication tokens
### Initialize Security
```bash
# Generate encryption keys
npx skillkit mesh security init
# Check security status
npx skillkit mesh security status
```
### Peer Trust Management
```bash
# Trust a peer by fingerprint
npx skillkit mesh peer trust abc123def456
# Revoke a peer's trust
npx skillkit mesh peer revoke abc123def456
# List trusted peers
npx skillkit mesh peer list
```
## Commands Reference
| Command | Description |
|---------|-------------|
| `mesh init` | Initialize mesh network |
| `mesh add <address>` | Add a host to mesh |
| `mesh remove <id>` | Remove a host |
| `mesh list` | List known hosts |
| `mesh discover` | Discover hosts on LAN |
| `mesh health` | Check host health |
| `mesh status` | Show mesh status |
| `mesh security init` | Setup encryption keys |
| `mesh security status` | Show security status |
| `mesh peer trust <id>` | Trust a peer |
| `mesh peer revoke <id>` | Revoke peer trust |
| `mesh peer list` | List trusted peers |
## Security Levels
| Level | Discovery | Transport | Auth | Use Case |
|-------|-----------|-----------|------|----------|
| `development` | open | none | none | Local dev |
| `signed` | signed | optional | optional | Trusted LAN |
| `secure` (default) | signed | required | required | Production |
| `strict` | trusted-only | required | mTLS | High security |
## Architecture
The mesh network uses:
1. **UDP Multicast** - LAN discovery with signed announcements
2. **WebSocket (WSS)** - Real-time bidirectional communication
3. **HTTPS** - RESTful API for management
All messages are signed and optionally encrypted based on your security level.
## Programmatic API
```typescript
import { MeshHost, PeerIdentity } from '@skillkit/mesh';
// Generate identity
const identity = await PeerIdentity.generate();
// Create mesh host
const host = new MeshHost({
hostId: 'my-workstation',
identity,
security: { mode: 'secure' },
});
await host.start();
// Send message to peer
await host.send('peer-fingerprint', {
type: 'skill-sync',
payload: { skills: ['react-patterns'] },
});
```
## Next Steps
- [Inter-Agent Messaging](/docs/messaging) - Send messages between agents
- [Memory System](/docs/memory) - Share learnings across the mesh
-98
View File
@@ -1,98 +0,0 @@
---
title: Inter-Agent Messaging
description: Send messages between AI agents across the mesh network
---
# Inter-Agent Messaging
SkillKit's messaging system enables asynchronous communication between AI agents. Send code reviews, share insights, and coordinate work across your team.
## Quick Start
```bash
# Send a message
npx skillkit message send
# View inbox
npx skillkit message inbox
# Read a message
npx skillkit message read <message-id>
```
## Commands Reference
| Command | Description |
|---------|-------------|
| `message send` | Send message to agent |
| `message inbox` | View inbox |
| `message read <id>` | Read a message |
| `message reply <id>` | Reply to message |
| `message archive <id>` | Archive message |
| `message sent` | View sent messages |
| `message status` | Messaging status |
## Message Types
Messages can include:
- **Text** - Plain text messages
- **Code** - Code snippets with syntax highlighting
- **Diffs** - Code changes and patches
- **Skills** - Skill file attachments
## Priority Levels
- **urgent** - Immediate attention required
- **normal** - Standard priority (default)
- **low** - Can be addressed when convenient
## Inbox Management
```bash
# View unread messages
npx skillkit message inbox --unread
# Archive old messages
npx skillkit message archive <id>
# View sent messages
npx skillkit message sent
```
## Programmatic API
```typescript
import { MessagingClient } from '@skillkit/messaging';
import { MeshHost } from '@skillkit/mesh';
// Create messaging client
const messaging = new MessagingClient({
meshHost: host,
storagePath: '~/.skillkit/messages',
});
await messaging.init();
// Send a message
await messaging.send({
to: 'claude@laptop',
subject: 'Code review completed',
body: 'I reviewed the auth module...',
priority: 'normal',
});
// Listen for new messages
messaging.on('message', (msg) => {
console.log('New message from:', msg.from);
});
```
## TUI Navigation
In the Terminal UI, press `j` to access the Messages screen.
## Next Steps
- [Mesh Network](/docs/mesh) - Configure the underlying network
- [Team Collaboration](/docs/teams) - Share skills with your team
+6 -9
View File
@@ -7,18 +7,15 @@ description: Get up and running with SkillKit in 5 minutes
This guide walks you through installing SkillKit, setting up your first project, and installing skills.
## 1. Run SkillKit
No installation required! Use npx:
```bash
npx skillkit@latest
```
Or install globally for frequent use:
## 1. Install SkillKit
```bash
npm install -g skillkit
```
Verify installation:
```bash
skillkit --version
```
+3 -125
View File
@@ -6,9 +6,6 @@ import { Footer } from './components/Footer';
import { SkillGenerator } from './components/SkillGenerator';
import { SkillSubmitForm } from './components/SkillSubmitForm';
import { Commands } from './components/Commands';
import { StackBuilder } from './components/StackBuilder';
import { TrendingSkills } from './components/TrendingSkills';
import { Attribution } from './components/Attribution';
const GITHUB_ICON = (
<svg className="w-5 h-5" fill="currentColor" viewBox="0 0 24 24">
@@ -27,15 +24,6 @@ function scrollToTop(e: React.MouseEvent): void {
window.scrollTo({ top: 0, behavior: 'smooth' });
}
function scrollToSection(e: React.MouseEvent, sectionId: string): void {
e.preventDefault();
const element = document.getElementById(sectionId);
if (element) {
element.scrollIntoView({ behavior: 'smooth' });
history.replaceState(null, '', `#${sectionId}`);
}
}
export default function App(): React.ReactElement {
return (
<div className="min-h-screen text-zinc-100 font-sans selection:bg-white selection:text-black" style={{ backgroundColor: '#000000' }}>
@@ -46,40 +34,10 @@ export default function App(): React.ReactElement {
<div className="w-4 h-4 bg-white"></div>
<span className="text-base font-bold tracking-tight text-white font-mono">SKILLKIT</span>
</a>
<div className="hidden sm:flex items-center gap-4 text-xs font-mono">
<a
href="#stack"
onClick={(e) => scrollToSection(e, 'stack')}
className="text-zinc-500 hover:text-white transition-colors"
>
Stack
</a>
<a
href="#trending"
onClick={(e) => scrollToSection(e, 'trending')}
className="text-zinc-500 hover:text-white transition-colors"
>
Trending
</a>
<a
href="#skills"
onClick={(e) => scrollToSection(e, 'skills')}
className="text-zinc-500 hover:text-white transition-colors"
>
Find Skills
</a>
<a
href="#sources"
onClick={(e) => scrollToSection(e, 'sources')}
className="text-zinc-500 hover:text-white transition-colors"
>
Sources
</a>
</div>
<div className="flex items-center gap-2 sm:gap-4">
<a
href="https://agenstskills.com/docs"
className="text-zinc-400 hover:text-white transition-colors text-sm font-mono hidden sm:block"
className="text-zinc-400 hover:text-white transition-colors text-sm font-mono"
>
Docs
</a>
@@ -108,91 +66,15 @@ export default function App(): React.ReactElement {
<main className="pt-14">
<Hero />
<div className="border-b border-zinc-800 py-4 bg-zinc-950">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="flex flex-wrap items-center justify-center gap-3 sm:gap-4">
<a
href="https://www.npmjs.com/package/skillkit"
target="_blank"
rel="noopener noreferrer"
className="flex items-center"
>
<img
src="https://img.shields.io/npm/v/skillkit.svg?style=flat&color=white&labelColor=000000"
alt="npm version"
className="h-5"
/>
</a>
<a
href="https://www.npmjs.com/package/skillkit"
target="_blank"
rel="noopener noreferrer"
className="flex items-center"
>
<img
src="https://img.shields.io/npm/dt/skillkit.svg?style=flat&color=white&labelColor=000000"
alt="npm downloads"
className="h-5"
/>
</a>
<a
href="https://github.com/rohitg00/skillkit"
target="_blank"
rel="noopener noreferrer"
className="flex items-center"
>
<img
src="https://img.shields.io/github/stars/rohitg00/skillkit?style=flat&color=white&labelColor=000000"
alt="GitHub stars"
className="h-5"
/>
</a>
<a
href="https://github.com/rohitg00/skillkit/blob/main/LICENSE"
target="_blank"
rel="noopener noreferrer"
className="flex items-center"
>
<img
src="https://img.shields.io/badge/License-Apache%202.0-white?style=flat&labelColor=000000"
alt="License"
className="h-5"
/>
</a>
<a
href="https://github.com/rohitg00/skillkit"
target="_blank"
rel="noopener noreferrer"
className="flex items-center"
>
<img
src="https://img.shields.io/badge/PRs-welcome-white?style=flat&labelColor=000000"
alt="PRs Welcome"
className="h-5"
/>
</a>
</div>
</div>
</div>
<Agents />
<Features />
<Commands />
<section id="stack" style={{ scrollMarginTop: '4rem' }}>
<StackBuilder />
</section>
<section id="trending" style={{ scrollMarginTop: '4rem' }}>
<TrendingSkills />
</section>
<section id="skills" className="py-12 border-b border-zinc-800" style={{ scrollMarginTop: '4rem' }}>
<section id="skills" className="py-12 border-b border-zinc-800">
<SkillGenerator />
</section>
<section id="submit" className="py-12 border-b border-zinc-800" style={{ backgroundColor: '#09090b', scrollMarginTop: '4rem' }}>
<section id="submit" className="py-12 border-b border-zinc-800" style={{ backgroundColor: '#09090b' }}>
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="text-center mb-8">
<h2 className="text-2xl font-bold text-white mb-2 font-mono">Submit Your Skill</h2>
@@ -203,10 +85,6 @@ export default function App(): React.ReactElement {
<SkillSubmitForm />
</div>
</section>
<section id="sources" style={{ scrollMarginTop: '4rem' }}>
<Attribution />
</section>
</main>
<Footer />
-280
View File
@@ -1,280 +0,0 @@
import React from 'react';
interface SkillSource {
name: string;
repo: string;
description: string;
official?: boolean;
license?: string;
skillCount?: string;
}
const SKILL_SOURCES: SkillSource[] = [
{
name: 'Anthropic Official',
repo: 'anthropics/skills',
description: 'Official Claude Code skills from Anthropic',
official: true,
license: 'Apache 2.0',
skillCount: '21+',
},
{
name: 'Vercel Labs',
repo: 'vercel-labs/agent-skills',
description: 'Next.js, React, and Vercel platform skills',
official: true,
license: 'MIT',
skillCount: '15+',
},
{
name: 'Expo / React Native',
repo: 'expo/skills',
description: 'Mobile development with Expo and React Native',
official: true,
license: 'MIT',
skillCount: '12+',
},
{
name: 'Remotion Video',
repo: 'remotion-dev/skills',
description: 'Programmatic video creation with React',
official: true,
license: 'MIT',
skillCount: '8+',
},
{
name: 'Supabase',
repo: 'supabase/agent-skills',
description: 'Database, auth, and backend skills',
official: true,
license: 'Apache 2.0',
skillCount: '10+',
},
{
name: 'Stripe Payments',
repo: 'stripe/ai',
description: 'Payment integration and Stripe API patterns',
official: true,
license: 'MIT',
skillCount: '8+',
},
{
name: 'Trail of Bits Security',
repo: 'trailofbits/skills',
description: 'Security analysis, auditing, and vulnerability detection',
license: 'Apache 2.0',
skillCount: '25+',
},
{
name: 'Superpowers TDD',
repo: 'obra/superpowers',
description: 'Test-driven development and workflow automation by Jesse Obra',
license: 'MIT',
skillCount: '14+',
},
{
name: 'Dev Patterns',
repo: 'wshobson/agents',
description: 'Development patterns and agent configurations',
license: 'MIT',
skillCount: '48+',
},
{
name: 'Composio Awesome',
repo: 'ComposioHQ/awesome-claude-skills',
description: 'Curated collection of Claude Code skills',
license: 'MIT',
},
{
name: 'Travis Awesome',
repo: 'travisvn/awesome-claude-skills',
description: 'Community-curated skill collection',
license: 'MIT',
},
{
name: 'Skills Marketplace',
repo: 'mhattingpete/claude-skills-marketplace',
description: 'Community skill marketplace',
license: 'MIT',
},
{
name: 'Dify Frontend',
repo: 'langgenius/dify',
description: 'AI application development platform patterns',
license: 'Apache 2.0',
},
{
name: 'Better Auth',
repo: 'better-auth/skills',
description: 'Authentication and authorization patterns',
license: 'MIT',
},
{
name: 'Nuxt / Vue',
repo: 'onmax/nuxt-skills',
description: 'Vue.js and Nuxt framework skills',
license: 'MIT',
},
{
name: 'ElysiaJS / Bun',
repo: 'elysiajs/skills',
description: 'Bun runtime and ElysiaJS framework',
license: 'MIT',
},
{
name: 'NestJS',
repo: 'kadajett/agent-nestjs-skills',
description: 'NestJS backend framework patterns',
license: 'MIT',
},
{
name: 'Three.js',
repo: 'cloudai-x/threejs-skills',
description: '3D graphics and WebGL development',
license: 'MIT',
},
{
name: 'SwiftUI iOS',
repo: 'dimillian/skills',
description: 'iOS and SwiftUI development patterns',
license: 'MIT',
},
{
name: 'Convex Backend',
repo: 'waynesutton/convexskills',
description: 'Convex backend development',
license: 'MIT',
},
{
name: 'Obsidian Notes',
repo: 'kepano/obsidian-skills',
description: 'Obsidian plugin and vault management',
license: 'MIT',
},
{
name: 'Shadcn / Radix',
repo: 'giuseppe-trisciuoglio/developer-kit',
description: 'UI component libraries and design systems',
license: 'MIT',
},
{
name: 'OpenRouter SDK',
repo: 'openrouterteam/agent-skills',
description: 'OpenRouter API integration patterns',
license: 'MIT',
},
{
name: 'Context7',
repo: 'intellectronica/agent-skills',
description: 'Context management and documentation tools',
license: 'MIT',
},
];
export function Attribution(): React.ReactElement {
const officialSources = SKILL_SOURCES.filter(s => s.official);
const communitySources = SKILL_SOURCES.filter(s => !s.official);
return (
<section className="py-12 border-b border-zinc-800 bg-black">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="text-center mb-6 sm:mb-8">
<h2 className="text-lg sm:text-xl font-bold text-white mb-2 font-mono">Skill Sources</h2>
<p className="text-zinc-500 font-mono text-[10px] sm:text-xs max-w-2xl mx-auto px-2">
SkillKit aggregates skills from trusted sources. We credit and link back to all original creators.
Each source retains its original license.
</p>
</div>
<div className="mb-6 sm:mb-8">
<h3 className="text-xs sm:text-sm font-mono text-zinc-400 uppercase tracking-wider mb-3 sm:mb-4 flex items-center gap-2">
<span className="w-2 h-2 bg-blue-500 rounded-full"></span>
Official Partner Sources
</h3>
<div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-2 sm:gap-3">
{officialSources.map(source => (
<a
key={source.repo}
href={`https://github.com/${source.repo}`}
target="_blank"
rel="noopener noreferrer"
className="group bg-zinc-900/50 border border-zinc-800 p-3 sm:p-4 hover:border-blue-800 hover:bg-blue-950/20 transition-all"
>
<div className="flex items-start justify-between mb-1 sm:mb-2">
<div className="font-mono text-xs sm:text-sm text-white group-hover:text-blue-400 transition-colors">
{source.name}
</div>
{source.skillCount && (
<span className="text-[9px] sm:text-[10px] bg-blue-900/50 text-blue-400 px-1 sm:px-1.5 py-0.5 border border-blue-800/50">
{source.skillCount}
</span>
)}
</div>
<div className="text-[10px] sm:text-xs text-zinc-600 mb-2 line-clamp-2">{source.description}</div>
<div className="flex items-center gap-1 sm:gap-2 text-[9px] sm:text-[10px] text-zinc-700">
<svg className="w-3 h-3 flex-shrink-0" fill="currentColor" viewBox="0 0 24 24">
<path fillRule="evenodd" d="M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z" clipRule="evenodd" />
</svg>
<span className="font-mono truncate">{source.repo}</span>
{source.license && (
<>
<span className="hidden sm:inline">•</span>
<span className="hidden sm:inline">{source.license}</span>
</>
)}
</div>
</a>
))}
</div>
</div>
<div>
<h3 className="text-xs sm:text-sm font-mono text-zinc-400 uppercase tracking-wider mb-3 sm:mb-4 flex items-center gap-2">
<span className="w-2 h-2 bg-purple-500 rounded-full"></span>
Community Contributors
</h3>
<div className="grid grid-cols-2 sm:grid-cols-2 lg:grid-cols-4 gap-2">
{communitySources.map(source => (
<a
key={source.repo}
href={`https://github.com/${source.repo}`}
target="_blank"
rel="noopener noreferrer"
className="group bg-zinc-900/30 border border-zinc-800 p-2 sm:p-3 hover:border-purple-800/50 hover:bg-purple-950/10 transition-all"
>
<div className="flex items-center justify-between mb-0.5 sm:mb-1">
<div className="font-mono text-[10px] sm:text-xs text-white group-hover:text-purple-400 transition-colors truncate">
{source.name}
</div>
{source.skillCount && (
<span className="text-[8px] sm:text-[9px] bg-purple-900/30 text-purple-500 px-1 py-0.5 flex-shrink-0 ml-1">
{source.skillCount}
</span>
)}
</div>
<div className="text-[9px] sm:text-[10px] text-zinc-600 truncate">{source.repo}</div>
</a>
))}
</div>
</div>
<div className="mt-6 sm:mt-8 pt-4 sm:pt-6 border-t border-zinc-800 text-center">
<p className="text-zinc-600 text-[10px] sm:text-xs font-mono mb-2 sm:mb-3">
Want to add your skills to SkillKit?
</p>
<a
href="https://github.com/rohitg00/skillkit/issues/new?template=add-source.md"
target="_blank"
rel="noopener noreferrer"
className="inline-flex items-center gap-1.5 sm:gap-2 bg-zinc-900 text-zinc-400 px-3 sm:px-4 py-1.5 sm:py-2 font-mono text-[10px] sm:text-xs border border-zinc-800 hover:border-zinc-600 hover:text-white transition-colors"
>
<svg className="w-3 h-3 sm:w-4 sm:h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
</svg>
Add Your Repository
</a>
</div>
</div>
</section>
);
}
+25 -36
View File
@@ -7,48 +7,39 @@ interface CommandGroup {
const COMMAND_GROUPS: CommandGroup[] = [
{
name: 'Start',
name: 'Core',
commands: [
{ cmd: '', desc: 'Launch interactive TUI' },
{ cmd: 'install <repo>', desc: 'Install from GitHub' },
{ cmd: 'recommend', desc: 'Get suggestions for your project' },
{ cmd: 'find <query>', desc: 'Search 15K+ skills' },
{ cmd: 'install', desc: 'Install from GitHub/GitLab/local' },
{ cmd: 'sync', desc: 'Sync skills across agents' },
{ cmd: 'translate', desc: 'Convert between agent formats' },
{ cmd: 'update', desc: 'Update installed skills' },
],
},
{
name: 'Manage',
name: 'Discovery',
commands: [
{ cmd: 'find', desc: 'Search marketplace (15K+ skills)' },
{ cmd: 'recommend', desc: 'AI-powered suggestions' },
{ cmd: 'check', desc: 'Dry-run update check' },
{ cmd: 'list', desc: 'View installed skills' },
{ cmd: 'sync', desc: 'Deploy to all agents' },
{ cmd: 'translate --to <agent>', desc: 'Convert formats' },
{ cmd: 'update', desc: 'Update all skills' },
],
},
{
name: 'Mesh',
commands: [
{ cmd: 'mesh init', desc: 'Initialize mesh network' },
{ cmd: 'mesh discover', desc: 'Find hosts on LAN' },
{ cmd: 'message send', desc: 'Send to another agent' },
{ cmd: 'message inbox', desc: 'View inbox' },
],
},
{
name: 'Team',
commands: [
{ cmd: 'manifest init', desc: 'Create .skills file' },
{ cmd: 'team share', desc: 'Share via Git' },
{ cmd: 'manifest install', desc: 'Install from manifest' },
{ cmd: 'team share', desc: 'Share skills via Git' },
{ cmd: 'publish', desc: 'Submit to marketplace' },
{ cmd: 'cicd init', desc: 'CI/CD templates' },
],
},
{
name: 'Advanced',
commands: [
{ cmd: 'primer', desc: 'Generate CLAUDE.md from code' },
{ cmd: 'agent translate', desc: 'Batch convert agents' },
{ cmd: 'ui', desc: 'Launch terminal UI' },
{ cmd: 'workflow run', desc: 'Execute skill pipelines' },
{ cmd: 'command generate', desc: 'Create /slash commands' },
{ cmd: 'memory export', desc: 'Save session learnings' },
{ cmd: 'cicd init', desc: 'Generate CI templates' },
],
},
];
@@ -67,7 +58,7 @@ export function Commands(): React.ReactElement {
</p>
</div>
<div className="flex justify-center gap-1.5 sm:gap-2 mb-4 sm:mb-6 flex-wrap">
<div className="flex justify-center gap-2 mb-6">
{COMMAND_GROUPS.map((g, i) => {
const isActive = i === activeGroup;
const buttonClass = isActive
@@ -77,7 +68,7 @@ export function Commands(): React.ReactElement {
<button
key={g.name}
onClick={() => setActiveGroup(i)}
className={`px-2 sm:px-3 py-1 sm:py-1.5 text-[10px] sm:text-xs font-mono border transition-colors ${buttonClass}`}
className={`px-3 py-1.5 text-xs font-mono border transition-colors ${buttonClass}`}
>
{g.name}
</button>
@@ -85,26 +76,24 @@ export function Commands(): React.ReactElement {
})}
</div>
<div className="border border-zinc-800 bg-black/50 p-2 sm:p-4 font-mono text-[10px] sm:text-xs">
<div className="grid grid-cols-1 sm:grid-cols-2 gap-1 sm:gap-2">
<div className="border border-zinc-800 bg-black/50 p-4 font-mono text-xs">
<div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
{group.commands.map((c) => (
<div
key={c.cmd || 'tui'}
className="flex items-center gap-2 p-1.5 sm:p-2 hover:bg-zinc-900/50 transition-colors rounded"
key={c.cmd}
className="flex items-center gap-3 p-2 hover:bg-zinc-900/50 transition-colors rounded"
>
<span className="text-zinc-600">$</span>
<span className="text-white text-[10px] sm:text-xs">
{c.cmd ? `skillkit ${c.cmd}` : 'npx skillkit@latest'}
</span>
<span className="text-zinc-600 ml-auto">→</span>
<span className="text-zinc-500 truncate max-w-[80px] sm:max-w-none">{c.desc}</span>
<span className="text-white">skillkit {c.cmd}</span>
<span className="text-zinc-600 hidden sm:inline">→</span>
<span className="text-zinc-500 hidden sm:inline truncate">{c.desc}</span>
</div>
))}
</div>
</div>
<div className="mt-3 sm:mt-4 text-center">
<span className="text-zinc-600 text-[10px] sm:text-xs font-mono">
<div className="mt-4 text-center">
<span className="text-zinc-600 text-xs font-mono">
Run <span className="text-zinc-400">skillkit --help</span> for all commands
</span>
</div>
@@ -46,7 +46,6 @@ const sections: DocSection[] = [
</p>
<h3 className="text-lg font-semibold text-white mt-6">Core Capabilities</h3>
<ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">AI Instruction Generation (Primer)</span> - Analyze your codebase and generate customized instruction files for all 32 agents</li>
<li><span className="text-white">Skill Discovery</span> - Browse 15,000+ skills from marketplace with AI-powered recommendations</li>
<li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 32 agent-specific formats</li>
<li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li>
@@ -204,15 +203,6 @@ skillkit manifest install # Install from manifest
skillkit publish # Publish skill to marketplace
skillkit cicd init # Setup CI/CD integration`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">AI Instruction Generation (Primer)</h3>
<CodeBlock>{`skillkit primer # Analyze codebase, generate for detected agents
skillkit primer --all-agents # Generate for all 32 agents
skillkit primer --agent claude-code,cursor # Specific agents only
skillkit primer --analyze-only # Only show codebase analysis
skillkit primer --dry-run # Preview without writing files
skillkit primer --json # Output analysis as JSON
skillkit primer --output ./dir # Custom output directory`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Advanced</h3>
<CodeBlock>{`skillkit ui # Launch Terminal UI
skillkit workflow # Manage workflows
+11 -38
View File
@@ -7,15 +7,6 @@ interface Feature {
}
const FEATURES: Feature[] = [
{
title: 'Primer',
description: 'Generate AI instructions from codebase analysis.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z" />
</svg>
)
},
{
title: 'Multi-Agent',
description: 'Deploy to 32 AI coding agents with one command.',
@@ -25,24 +16,6 @@ const FEATURES: Feature[] = [
</svg>
)
},
{
title: 'Mesh Network',
description: 'Multi-machine agent distribution with encrypted P2P.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9" />
</svg>
)
},
{
title: 'Security',
description: 'Ed25519 signing, TLS, and encrypted storage.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z" />
</svg>
)
},
{
title: 'Terminal UI',
description: 'Beautiful interactive TUI for browsing & installing.',
@@ -52,15 +25,6 @@ const FEATURES: Feature[] = [
</svg>
)
},
{
title: 'Messaging',
description: 'Inter-agent messaging across the mesh.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 10h.01M12 10h.01M16 10h.01M9 16H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-5l-5 5v-5z" />
</svg>
)
},
{
title: 'Plugins',
description: 'Extend with custom plugins & hooks.',
@@ -79,6 +43,15 @@ const FEATURES: Feature[] = [
</svg>
)
},
{
title: 'CI/CD',
description: 'GitHub, GitLab, CircleCI templates included.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
</svg>
)
},
{
title: 'Slash Commands',
description: 'Generate /commands for Claude, Cursor & more.',
@@ -92,10 +65,10 @@ const FEATURES: Feature[] = [
const COMPARISONS = [
['Agents', '1', '32'],
['Instructions', 'Manual', 'Primer Auto'],
['Translation', 'Manual', 'Auto'],
['Sharing', 'Copy/paste', '.skills manifest'],
['Discovery', 'Forums', 'CLI + AI'],
['CI/CD', 'Custom', 'Templates'],
] as const;
export function Features(): React.ReactElement {
@@ -146,7 +119,7 @@ export function Features(): React.ReactElement {
</div>
</div>
<div className="grid grid-cols-2 sm:grid-cols-4 lg:grid-cols-8 gap-3">
<div className="grid grid-cols-1 xs:grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-3">
{FEATURES.map((feature, index) => (
<div
key={feature.title}
+1 -1
View File
@@ -18,7 +18,7 @@ export function Footer(): React.ReactElement {
</p>
<span className="hidden sm:inline text-zinc-700">•</span>
<a
href="https://agenstskills.com"
href="https://agentskills.io"
target="_blank"
rel="noopener noreferrer"
className="text-zinc-600 hover:text-zinc-400 text-xs font-mono transition-colors"
+14 -12
View File
@@ -16,15 +16,17 @@ interface TerminalLine {
}
const TERMINAL_LINES: TerminalLine[] = [
{ type: 'cmd', text: 'skillkit recommend' },
{ type: 'out', text: ' 92% react-best-practices' },
{ type: 'out', text: ' 87% typescript-strict' },
{ type: 'cmd', text: 'skillkit find react' },
{ type: 'out', text: ' ■ react-patterns ★★★★★' },
{ type: 'out', text: ' ■ react-testing ★★★★☆' },
{ type: 'cmd', text: 'skillkit install anthropics/skills' },
{ type: 'out', text: '→ Installed 3 skills' },
{ type: 'cmd', text: 'skillkit sync --agent cursor,claude' },
{ type: 'out', text: ' ✓ Synced to 2 agents' },
{ type: 'cmd', text: 'skillkit translate my-skill --to codex' },
{ type: 'out', text: '→ Converted to SKILL.md format' },
{ type: 'out', text: '→ 3 skills → 5 agents' },
{ type: 'cmd', text: 'skillkit ui' },
{ type: 'out', text: '→ Launching TUI...' },
{ type: 'cmd', text: 'skillkit check' },
{ type: 'out', text: ' ✓ All skills up to date' },
{ type: 'cmd', text: 'skillkit manifest install' },
{ type: 'out', text: '→ 12 skills from .skills' },
];
const FADE_ANIMATION_STYLES = `
@@ -120,11 +122,11 @@ export function Hero(): React.ReactElement {
</pre>
</div>
<div className="grid grid-cols-1 md:grid-cols-2 gap-6 lg:gap-8 items-start">
<div className="grid grid-cols-1 lg:grid-cols-2 gap-6 lg:gap-8 items-start">
<div className="animate-fade-in">
<div className="inline-flex items-center space-x-2 border border-zinc-800 bg-zinc-900/50 px-2 py-0.5 mb-3 backdrop-blur-sm">
<span className="flex h-1.5 w-1.5 bg-white rounded-full"></span>
<span className="text-xs font-mono text-zinc-400">v1.7.11</span>
<span className="text-xs font-mono text-zinc-400">v1.7.5</span>
</div>
<h1 className="text-2xl sm:text-3xl lg:text-4xl font-bold tracking-tight text-white mb-3 font-mono">
@@ -161,7 +163,7 @@ export function Hero(): React.ReactElement {
</div>
</div>
<div className="hidden md:block relative animate-fade-in-delay w-full">
<div className="hidden lg:block relative animate-fade-in-delay w-full">
<div className="absolute -inset-1 bg-gradient-to-r from-zinc-800 via-zinc-700 to-zinc-800 rounded-lg opacity-20 blur-lg"></div>
<div className="relative border border-zinc-800 bg-black rounded-lg overflow-hidden">
<div className="flex items-center gap-1.5 px-3 py-2 border-b border-zinc-800 bg-zinc-900/50">
@@ -170,7 +172,7 @@ export function Hero(): React.ReactElement {
<div className="w-2.5 h-2.5 rounded-full bg-zinc-700"></div>
<span className="ml-2 text-zinc-500 text-xs font-mono">skillkit</span>
</div>
<div className="p-3 md:p-4 font-mono text-[10px] md:text-xs min-h-[180px] md:min-h-[200px] max-h-[240px] md:max-h-[280px]">
<div className="p-4 font-mono text-xs min-h-[200px] max-h-[280px]">
{TERMINAL_LINES.slice(0, visibleLines).map((line, index) => (
<div key={index} className="mb-1">
{line.type === 'cmd' ? (
+1 -1
View File
@@ -490,7 +490,7 @@ ${skillContent.slice(0, 4000)}${skillContent.length > 4000 ? '\n...(truncated)'
<p className="text-zinc-500 font-mono text-sm mb-3">Install with SkillKit:</p>
<pre className="border border-zinc-800 p-3 sm:p-4 text-sm overflow-x-auto max-w-full" style={{ backgroundColor: '#09090b' }}>
<code className="font-mono text-xs sm:text-sm break-all sm:break-normal" style={{ color: '#d4d4d8' }}>
npx skillkit@latest install {selectedSkill.id.split('/').slice(0, 2).join('/')}
npx skillkit install {selectedSkill.id.split('/').slice(0, 2).join('/')}
</code>
</pre>
</div>
-233
View File
@@ -1,233 +0,0 @@
import React, { useState } from 'react';
import { searchSkills, IndexedSkill, SKILLS_INDEX } from '../data/skills-index';
interface StackItem extends IndexedSkill {
addedAt: number;
}
const POPULAR_STACKS = [
{
name: 'Full Stack TypeScript',
skills: ['react', 'nextjs', 'typescript', 'prisma', 'tailwind'],
icon: '⚡',
},
{
name: 'AI/ML Development',
skills: ['python', 'langchain', 'openai', 'embeddings'],
icon: '🤖',
},
{
name: 'DevOps & Cloud',
skills: ['docker', 'kubernetes', 'terraform', 'github-actions'],
icon: '☁️',
},
{
name: 'Mobile Development',
skills: ['react-native', 'expo', 'ios', 'android'],
icon: '📱',
},
];
export function StackBuilder(): React.ReactElement {
const [stack, setStack] = useState<StackItem[]>([]);
const [searchQuery, setSearchQuery] = useState('');
const [searchResults, setSearchResults] = useState<IndexedSkill[]>([]);
const [copied, setCopied] = useState(false);
function handleSearch(query: string): void {
setSearchQuery(query);
if (query.trim()) {
const results = searchSkills(query).filter(
skill => !stack.some(s => s.id === skill.id)
);
setSearchResults(results);
} else {
setSearchResults([]);
}
}
function addToStack(skill: IndexedSkill): void {
if (!stack.some(s => s.id === skill.id)) {
setStack([...stack, { ...skill, addedAt: Date.now() }]);
setSearchQuery('');
setSearchResults([]);
}
}
function removeFromStack(skillId: string): void {
setStack(stack.filter(s => s.id !== skillId));
}
function loadPresetStack(presetSkills: string[]): void {
const newItems: StackItem[] = [];
presetSkills.forEach(query => {
const results = searchSkills(query);
if (results.length > 0 && !stack.some(s => s.id === results[0].id) && !newItems.some(s => s.id === results[0].id)) {
newItems.push({ ...results[0], addedAt: Date.now() });
}
});
setStack([...stack, ...newItems]);
}
function generateInstallCommand(): string {
if (stack.length === 0) return '';
const skillIds = [...new Set(stack.map(s => s.id.split('/').slice(0, 2).join('/')))];
if (skillIds.length === 1) {
return `npx skillkit@latest install ${skillIds[0]}`;
}
return `npx skillkit@latest install ${skillIds.join(' ')}`;
}
async function copyCommand(): Promise<void> {
const cmd = generateInstallCommand();
if (!cmd) return;
try {
await navigator.clipboard.writeText(cmd);
setCopied(true);
setTimeout(() => setCopied(false), 2000);
} catch {
// Clipboard API failed, silently ignore
}
}
function clearStack(): void {
setStack([]);
}
return (
<section className="py-12 border-b border-zinc-800">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="flex items-center justify-between mb-6">
<div>
<h2 className="text-xl font-bold text-white mb-1 font-mono">Stack Builder</h2>
<p className="text-zinc-500 font-mono text-xs">
Compose your perfect skill stack. Install everything with one command.
</p>
</div>
{stack.length > 0 && (
<button
onClick={clearStack}
className="text-zinc-500 hover:text-red-400 font-mono text-xs transition-colors"
>
Clear All
</button>
)}
</div>
<div className="flex flex-col lg:flex-row gap-6">
<div className="flex-1 space-y-4">
<div className="relative">
<input
type="text"
value={searchQuery}
onChange={(e) => handleSearch(e.target.value)}
placeholder="Search skills to add..."
className="w-full bg-zinc-900 border border-zinc-700 text-white px-4 py-3 focus:ring-2 focus:ring-white focus:border-transparent outline-none font-mono text-sm placeholder-zinc-600"
/>
{searchResults.length > 0 && (
<div className="absolute z-10 w-full mt-1 bg-zinc-900 border border-zinc-700 max-h-60 overflow-y-auto">
{searchResults.slice(0, 8).map(skill => (
<button
key={skill.id}
onClick={() => addToStack(skill)}
className="w-full text-left px-4 py-3 hover:bg-zinc-800 transition-colors border-b border-zinc-800 last:border-b-0"
>
<div className="font-mono text-sm text-white">{skill.name}</div>
<div className="text-xs text-zinc-500 truncate">{skill.description}</div>
</button>
))}
</div>
)}
</div>
<div className="space-y-2">
<span className="text-zinc-500 text-xs font-mono block">Quick add:</span>
<div className="flex flex-wrap gap-2">
{POPULAR_STACKS.map(preset => (
<button
key={preset.name}
onClick={() => loadPresetStack(preset.skills)}
className="text-[10px] sm:text-xs bg-zinc-900 text-zinc-400 px-2 sm:px-3 py-1 sm:py-1.5 border border-zinc-700 hover:border-zinc-500 hover:text-white transition-colors font-mono"
>
{preset.icon} <span className="hidden sm:inline">{preset.name}</span><span className="sm:hidden">{preset.name.split(' ')[0]}</span>
</button>
))}
</div>
</div>
{stack.length > 0 && (
<div className="space-y-2">
<div className="text-xs font-mono text-zinc-500 uppercase tracking-wider">
Your Stack ({stack.length} skills)
</div>
<div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
{stack.map(skill => (
<div
key={skill.id}
className="flex items-center justify-between bg-zinc-900/50 border border-zinc-800 p-3 group"
>
<div className="flex-1 min-w-0">
<div className="font-mono text-sm text-white truncate">{skill.name}</div>
<div className="text-xs text-zinc-600 truncate">{skill.source}</div>
</div>
<button
onClick={() => removeFromStack(skill.id)}
aria-label={`Remove ${skill.name} from stack`}
className="ml-2 text-zinc-600 hover:text-red-400 transition-colors opacity-0 group-hover:opacity-100 focus-visible:opacity-100"
>
<svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
</svg>
</button>
</div>
))}
</div>
</div>
)}
</div>
<div className="lg:w-80 lg:flex-shrink-0">
<div className="lg:sticky lg:top-20 bg-zinc-900/50 border border-zinc-800 p-3 sm:p-4">
<div className="text-xs font-mono text-zinc-500 uppercase tracking-wider mb-3">
Install Command
</div>
{stack.length > 0 ? (
<>
<pre className="bg-black border border-zinc-800 p-3 overflow-x-auto text-xs mb-3">
<code className="font-mono text-green-400 whitespace-pre-wrap break-all">
{generateInstallCommand()}
</code>
</pre>
<button
onClick={copyCommand}
className="w-full bg-white text-black py-2 font-mono text-sm hover:bg-zinc-200 transition-colors flex items-center justify-center gap-2"
>
{copied ? (
<>
<svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
</svg>
COPIED!
</>
) : (
<>
<svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
</svg>
COPY COMMAND
</>
)}
</button>
</>
) : (
<div className="text-zinc-600 text-xs font-mono text-center py-6">
Add skills to generate install command
</div>
)}
</div>
</div>
</div>
</div>
</section>
);
}
-155
View File
@@ -1,155 +0,0 @@
import React, { useState } from 'react';
import { SKILLS_INDEX, IndexedSkill, getSkillsByTag } from '../data/skills-index';
const CATEGORIES = [
{ id: 'all', name: 'All', icon: '◆' },
{ id: 'react', name: 'React', icon: '⚛' },
{ id: 'typescript', name: 'TypeScript', icon: '◈' },
{ id: 'python', name: 'Python', icon: '◉' },
{ id: 'ai', name: 'AI/ML', icon: '◎' },
{ id: 'security', name: 'Security', icon: '◐' },
{ id: 'devops', name: 'DevOps', icon: '◑' },
{ id: 'testing', name: 'Testing', icon: '◒' },
] as const;
const TRENDING_SKILLS = [
'anthropics/skills/claude-code-guide',
'anthropics/skills/claude-code-setup',
'obra/superpowers/tdd',
'vercel-labs/agent-skills/nextjs',
'trailofbits/skills/security-review',
'expo/skills/react-native',
'remotion-dev/skills/video',
'supabase/agent-skills/database',
];
function getTrendingSkills(): IndexedSkill[] {
return TRENDING_SKILLS
.map(id => SKILLS_INDEX.find(s => s.id === id))
.filter((s): s is IndexedSkill => s !== undefined)
.slice(0, 8);
}
function getPopularByCategory(category: string): IndexedSkill[] {
if (category === 'all') {
return SKILLS_INDEX.slice(0, 12);
}
return getSkillsByTag(category).slice(0, 12);
}
export function TrendingSkills(): React.ReactElement {
const [activeCategory, setActiveCategory] = useState('all');
const [hoveredSkill, setHoveredSkill] = useState<string | null>(null);
const trendingSkills = getTrendingSkills();
const categorySkills = getPopularByCategory(activeCategory);
return (
<section className="py-12 border-b border-zinc-800 bg-zinc-950">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="flex flex-col sm:flex-row sm:items-center justify-between gap-2 mb-6">
<div>
<h2 className="text-lg sm:text-xl font-bold text-white mb-1 font-mono">Trending Skills</h2>
<p className="text-zinc-500 font-mono text-[10px] sm:text-xs">
Popular skills used by the community.
</p>
</div>
<div className="flex items-center gap-2">
<span className="w-2 h-2 bg-green-500 rounded-full animate-pulse"></span>
<span className="text-[10px] sm:text-xs font-mono text-zinc-500">Updated weekly</span>
</div>
</div>
<div className="grid grid-cols-2 sm:grid-cols-4 gap-2 sm:gap-3 mb-8">
{trendingSkills.map((skill, index) => (
<div
key={skill.id}
className="relative group bg-zinc-900/50 border border-zinc-800 p-2 sm:p-4 hover:border-zinc-600 transition-all cursor-pointer"
onMouseEnter={() => setHoveredSkill(skill.id)}
onMouseLeave={() => setHoveredSkill(null)}
>
<div className="absolute top-1 sm:top-2 right-1 sm:right-2 text-[10px] sm:text-xs font-mono text-zinc-600">
#{index + 1}
</div>
<div className="font-mono text-[11px] sm:text-sm text-white mb-1 truncate pr-4 sm:pr-6">{skill.name}</div>
<div className="text-[10px] sm:text-xs text-zinc-600 truncate">{skill.source}</div>
{skill.tags.length > 0 && (
<div className="hidden sm:flex flex-wrap gap-1 mt-2">
{skill.tags.slice(0, 2).map((tag, idx) => (
<span key={idx} className="text-[10px] bg-zinc-800 text-zinc-500 px-1.5 py-0.5">
{tag}
</span>
))}
</div>
)}
{hoveredSkill === skill.id && (
<div className="absolute inset-0 bg-white/5 pointer-events-none transition-opacity"></div>
)}
</div>
))}
</div>
<div className="border-t border-zinc-800 pt-6 sm:pt-8">
<div className="mb-3 sm:mb-4">
<h3 className="text-xs sm:text-sm font-mono text-zinc-400 uppercase tracking-wider">Browse by Category</h3>
</div>
<div className="flex flex-wrap gap-1.5 sm:gap-2 mb-4 sm:mb-6 overflow-x-auto pb-2 -mx-4 px-4 sm:mx-0 sm:px-0">
{CATEGORIES.map(cat => (
<button
key={cat.id}
onClick={() => setActiveCategory(cat.id)}
className={`px-2 sm:px-3 py-1 sm:py-1.5 font-mono text-[10px] sm:text-xs transition-all whitespace-nowrap flex-shrink-0 ${
activeCategory === cat.id
? 'bg-white text-black'
: 'bg-zinc-900 text-zinc-400 border border-zinc-800 hover:border-zinc-600 hover:text-white'
}`}
>
<span className="mr-1 sm:mr-1.5">{cat.icon}</span>
{cat.name}
</button>
))}
</div>
<div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-2 sm:gap-3">
{categorySkills.map(skill => (
<div
key={skill.id}
className="bg-zinc-900/30 border border-zinc-800 p-4 hover:border-zinc-700 transition-all group"
>
<div className="flex items-start justify-between">
<div className="flex-1 min-w-0">
<div className="font-mono text-sm text-white mb-1 truncate">{skill.name}</div>
<div className="text-xs text-zinc-600 line-clamp-2">{skill.description || 'No description'}</div>
</div>
<svg
className="w-4 h-4 text-zinc-700 group-hover:text-zinc-400 transition-colors flex-shrink-0 ml-2"
fill="none"
viewBox="0 0 24 24"
stroke="currentColor"
>
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
</svg>
</div>
<div className="flex items-center justify-between mt-3 pt-3 border-t border-zinc-800">
<div className="text-[10px] text-zinc-600 font-mono truncate">{skill.source}</div>
{skill.tags.length > 0 && (
<span className="text-[10px] bg-zinc-800 text-zinc-500 px-1.5 py-0.5 flex-shrink-0 ml-2">
{skill.tags[0]}
</span>
)}
</div>
</div>
))}
</div>
{categorySkills.length === 0 && (
<div className="text-center py-8 text-zinc-600 font-mono text-sm">
No skills found in this category.
</div>
)}
</div>
</div>
</section>
);
}
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "skillkit-monorepo",
"version": "1.7.10",
"version": "1.7.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "skillkit-monorepo",
"version": "1.7.10",
"version": "1.7.2",
"license": "Apache-2.0",
"devDependencies": {
"@types/node": "^22.10.5",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "skillkit-monorepo",
"version": "2.0.0",
"version": "1.7.9",
"private": true,
"description": "Universal skills loader for AI coding agents - Monorepo",
"type": "module",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/agents",
"version": "1.8.0",
"version": "1.7.9",
"description": "Agent adapters for SkillKit - supports 32 AI coding agents",
"type": "module",
"main": "./dist/index.js",
+1 -5
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/cli",
"version": "1.8.0",
"version": "1.7.9",
"description": "CLI commands for SkillKit",
"type": "module",
"main": "./dist/index.js",
@@ -24,11 +24,7 @@
"@clack/prompts": "^0.11.0",
"@skillkit/core": "workspace:*",
"@skillkit/agents": "workspace:*",
"@skillkit/resources": "workspace:*",
"@skillkit/tui": "workspace:*",
"@skillkit/memory": "workspace:*",
"@skillkit/mesh": "workspace:*",
"@skillkit/messaging": "workspace:*",
"chalk": "^5.3.0",
"clipanion": "^4.0.0-rc.4",
"got": "^14.4.1",
-208
View File
@@ -20,14 +20,6 @@ import {
type CustomAgent,
type AgentType,
} from '@skillkit/core';
import {
getBundledAgents,
getBundledAgent,
getAvailableAgents,
installBundledAgent,
isAgentInstalled,
type BundledAgent,
} from '@skillkit/resources';
// Agent discovery uses root directories, not skill directories
export class AgentCommand extends Command {
@@ -637,203 +629,3 @@ function formatAgentName(name: string): string {
.map(word => word.charAt(0).toUpperCase() + word.slice(1))
.join(' ');
}
export class AgentInstallCommand extends Command {
static override paths = [['agent', 'install']];
static override usage = Command.Usage({
description: 'Install a bundled agent template',
details: `
Installs a bundled agent template from @skillkit/resources.
These are battle-tested agent configurations for common tasks.
Use 'agent available' to see agents that can be installed.
`,
examples: [
['Install code-reviewer agent', '$0 agent install code-reviewer'],
['Install globally', '$0 agent install architect --global'],
['Force overwrite existing', '$0 agent install tdd-guide --force'],
['Install all bundled agents', '$0 agent install --all'],
],
});
name = Option.String({ required: false });
global = Option.Boolean('--global,-g', false, {
description: 'Install to global agents directory',
});
force = Option.Boolean('--force,-f', false, {
description: 'Overwrite if agent already exists',
});
all = Option.Boolean('--all,-a', false, {
description: 'Install all bundled agents',
});
async execute(): Promise<number> {
if (this.all) {
return this.installAll();
}
if (!this.name) {
console.log(chalk.yellow('Please specify an agent name or use --all'));
console.log(chalk.dim('Run `skillkit agent available` to see available agents'));
return 1;
}
const agent = getBundledAgent(this.name);
if (!agent) {
console.log(chalk.red(`Bundled agent not found: ${this.name}`));
console.log(chalk.dim('Run `skillkit agent available` to see available agents'));
return 1;
}
const result = installBundledAgent(this.name, {
global: this.global,
force: this.force,
});
if (result.success) {
console.log(chalk.green(`✓ Installed: ${agent.name}`));
console.log(chalk.dim(` Path: ${result.path}`));
console.log(chalk.dim(` Invoke with: @${agent.id}`));
} else {
console.log(chalk.red(`✗ Failed: ${result.message}`));
return 1;
}
return 0;
}
private async installAll(): Promise<number> {
const agents = getBundledAgents();
console.log(chalk.cyan(`Installing ${agents.length} bundled agents...\n`));
let successCount = 0;
let skipCount = 0;
let errorCount = 0;
for (const agent of agents) {
const result = installBundledAgent(agent.id, {
global: this.global,
force: this.force,
});
if (result.success) {
console.log(chalk.green(` ✓ ${agent.name}`));
successCount++;
} else if (result.message.includes('already exists')) {
console.log(chalk.yellow(` ○ ${agent.name} (already installed)`));
skipCount++;
} else {
console.log(chalk.red(` ✗ ${agent.name}: ${result.message}`));
errorCount++;
}
}
console.log();
console.log(
chalk.dim(
`Installed: ${successCount}, Skipped: ${skipCount}, Errors: ${errorCount}`
)
);
return errorCount > 0 ? 1 : 0;
}
}
export class AgentAvailableCommand extends Command {
static override paths = [['agent', 'available'], ['agent', 'bundled']];
static override usage = Command.Usage({
description: 'List bundled agents available for installation',
examples: [
['List available agents', '$0 agent available'],
['Show JSON output', '$0 agent available --json'],
['Filter by category', '$0 agent available --category testing'],
],
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
category = Option.String('--category,-c', {
description: 'Filter by category (planning, development, testing, review, documentation, security, refactoring)',
});
installed = Option.Boolean('--installed,-i', false, {
description: 'Show only installed bundled agents',
});
async execute(): Promise<number> {
let agents: BundledAgent[];
if (this.installed) {
agents = getBundledAgents().filter(a => isAgentInstalled(a.id));
} else {
agents = getAvailableAgents();
}
if (this.category) {
agents = agents.filter(a => a.category === this.category);
}
if (this.json) {
console.log(JSON.stringify(agents, null, 2));
return 0;
}
if (agents.length === 0) {
if (this.installed) {
console.log(chalk.yellow('No bundled agents installed'));
console.log(chalk.dim('Run `skillkit agent install <name>` to install'));
} else {
console.log(chalk.green('All bundled agents are already installed!'));
}
return 0;
}
const title = this.installed
? 'Installed Bundled Agents'
: 'Available Bundled Agents';
console.log(chalk.cyan(`${title} (${agents.length}):\n`));
const categories = new Map<string, BundledAgent[]>();
for (const agent of agents) {
const cat = agent.category;
if (!categories.has(cat)) {
categories.set(cat, []);
}
categories.get(cat)!.push(agent);
}
for (const [category, catAgents] of categories) {
console.log(chalk.blue(` ${formatCategoryName(category)}`));
for (const agent of catAgents) {
const installed = isAgentInstalled(agent.id);
const status = installed ? chalk.green('✓') : chalk.dim('○');
const model = agent.model ? chalk.blue(`[${agent.model}]`) : '';
console.log(` ${status} ${chalk.bold(agent.id)} ${model}`);
console.log(` ${chalk.dim(agent.description)}`);
}
console.log();
}
if (!this.installed) {
console.log(chalk.dim('Install with: skillkit agent install <name>'));
console.log(chalk.dim('Install all: skillkit agent install --all'));
}
return 0;
}
}
function formatCategoryName(category: string): string {
return category
.split('-')
.map(word => word.charAt(0).toUpperCase() + word.slice(1))
.join(' ');
}
-136
View File
@@ -17,13 +17,6 @@ import {
supportsSlashCommands,
} from '@skillkit/core';
import type { SlashCommand, AgentType } from '@skillkit/core';
import {
getCommandTemplates,
getCommandTemplate,
getCommandTemplatesByCategory,
type CommandTemplate,
type CommandCategory,
} from '@skillkit/resources';
export class CommandCmd extends Command {
static paths = [['command']];
@@ -506,132 +499,3 @@ export class CommandCmd extends Command {
}
}
}
export class CommandAvailableCommand extends Command {
static override paths = [['command', 'available']];
static override usage = Command.Usage({
category: 'Commands',
description: 'List available bundled command templates',
examples: [
['List all available', '$0 command available'],
['Filter by category', '$0 command available --category testing'],
],
});
category = Option.String('--category,-c', {
description: 'Filter by category (testing, planning, development, review, workflow, learning)',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const templates = this.category
? getCommandTemplatesByCategory(this.category as CommandCategory)
: getCommandTemplates();
if (this.json) {
this.context.stdout.write(JSON.stringify(templates, null, 2) + '\n');
return 0;
}
this.context.stdout.write(`Available Command Templates (${templates.length}):\n\n`);
const byCategory = new Map<string, CommandTemplate[]>();
for (const template of templates) {
const cat = template.category || 'general';
if (!byCategory.has(cat)) {
byCategory.set(cat, []);
}
byCategory.get(cat)!.push(template);
}
for (const [category, catTemplates] of byCategory) {
this.context.stdout.write(` ${category.toUpperCase()}\n`);
for (const template of catTemplates) {
const agent = template.agent ? ` [${template.agent}]` : '';
this.context.stdout.write(` ${template.trigger}${agent}\n`);
this.context.stdout.write(` ${template.description}\n`);
}
this.context.stdout.write('\n');
}
this.context.stdout.write('Install with: skillkit command install <id>\n');
return 0;
}
}
export class CommandInstallCommand extends Command {
static override paths = [['command', 'install']];
static override usage = Command.Usage({
category: 'Commands',
description: 'Install a bundled command template',
examples: [
['Install TDD command', '$0 command install tdd'],
['Install code review', '$0 command install code-review'],
],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const template = getCommandTemplate(this.id);
if (!template) {
this.context.stderr.write(`Command template not found: ${this.id}\n`);
this.context.stderr.write('Run "skillkit command available" to see available templates.\n');
return 1;
}
const command: SlashCommand = {
name: template.id,
description: template.description,
skill: `template:${template.id}`,
category: template.category,
examples: template.examples,
metadata: {
templateId: template.id,
trigger: template.trigger,
agent: template.agent,
prompt: template.prompt,
},
};
const configPath = resolve(process.cwd(), '.skillkit', 'commands.json');
let commands: SlashCommand[] = [];
if (existsSync(configPath)) {
const content = await readFile(configPath, 'utf-8');
const config = JSON.parse(content);
commands = config.commands || [];
}
const existing = commands.findIndex((c) => c.name === template.id);
if (existing >= 0) {
commands[existing] = command;
this.context.stdout.write(`Updated command: ${template.trigger}\n`);
} else {
commands.push(command);
this.context.stdout.write(`Installed command: ${template.trigger}\n`);
}
await mkdir(dirname(configPath), { recursive: true });
await writeFile(
configPath,
JSON.stringify({ version: '1.0.0', commands }, null, 2)
);
this.context.stdout.write(` Name: ${template.name}\n`);
this.context.stdout.write(` Description: ${template.description}\n`);
if (template.agent) {
this.context.stdout.write(` Agent: ${template.agent}\n`);
}
this.context.stdout.write(`\nSaved to: ${configPath}\n`);
return 0;
}
}
-277
View File
@@ -1,277 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import {
getAllGuidelines,
getEnabledGuidelines,
getGuideline,
enableGuideline,
disableGuideline,
isGuidelineEnabled,
isBuiltinGuideline,
addCustomGuideline,
removeCustomGuideline,
type Guideline,
type GuidelineCategory,
} from '@skillkit/core';
export class GuidelineCommand extends Command {
static override paths = [['guideline'], ['guide']];
static override usage = Command.Usage({
description: 'Manage coding guidelines (always-on rules)',
details: `
Guidelines are always-on coding standards that guide agent behavior.
Enable or disable guidelines based on your project needs.
`,
examples: [
['List guidelines', '$0 guideline list'],
['Enable guideline', '$0 guideline enable security'],
['Disable guideline', '$0 guideline disable performance'],
],
});
async execute(): Promise<number> {
console.log(chalk.cyan('Guideline commands:\n'));
console.log(' guideline list List all guidelines');
console.log(' guideline show <id> Show guideline content');
console.log(' guideline enable Enable a guideline');
console.log(' guideline disable Disable a guideline');
console.log(' guideline create Create custom guideline');
console.log();
return 0;
}
}
export class GuidelineListCommand extends Command {
static override paths = [['guideline', 'list'], ['guideline', 'ls']];
static override usage = Command.Usage({
description: 'List all guidelines',
examples: [
['List all', '$0 guideline list'],
['Show only enabled', '$0 guideline list --enabled'],
],
});
enabled = Option.Boolean('--enabled,-e', false, {
description: 'Show only enabled guidelines',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const guidelines = this.enabled ? getEnabledGuidelines() : getAllGuidelines();
if (this.json) {
console.log(JSON.stringify(guidelines, null, 2));
return 0;
}
const title = this.enabled ? 'Enabled Guidelines' : 'All Guidelines';
console.log(chalk.cyan(`${title} (${guidelines.length}):\n`));
const byCategory = new Map<GuidelineCategory, Guideline[]>();
for (const guideline of guidelines) {
if (!byCategory.has(guideline.category)) {
byCategory.set(guideline.category, []);
}
byCategory.get(guideline.category)!.push(guideline);
}
for (const [category, catGuidelines] of byCategory) {
console.log(chalk.blue(` ${formatCategoryName(category)}`));
for (const guideline of catGuidelines) {
const enabled = isGuidelineEnabled(guideline.id);
const status = enabled ? chalk.green('●') : chalk.dim('○');
const custom = isBuiltinGuideline(guideline.id) ? '' : chalk.dim(' (custom)');
const priority = chalk.dim(`[${guideline.priority}]`);
console.log(` ${status} ${chalk.bold(guideline.id)} ${priority}${custom}`);
console.log(` ${chalk.dim(guideline.description)}`);
}
console.log();
}
console.log(chalk.dim('Enable with: skillkit guideline enable <id>'));
console.log(chalk.dim('Show content: skillkit guideline show <id>'));
return 0;
}
}
export class GuidelineShowCommand extends Command {
static override paths = [['guideline', 'show']];
static override usage = Command.Usage({
description: 'Show guideline content',
examples: [['Show guideline', '$0 guideline show security']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const guideline = getGuideline(this.id);
if (!guideline) {
console.log(chalk.red(`Guideline not found: ${this.id}`));
return 1;
}
const enabled = isGuidelineEnabled(this.id);
const status = enabled ? chalk.green('enabled') : chalk.dim('disabled');
console.log(chalk.cyan(`Guideline: ${guideline.name}\n`));
console.log(`ID: ${guideline.id}`);
console.log(`Category: ${guideline.category}`);
console.log(`Priority: ${guideline.priority}`);
console.log(`Status: ${status}`);
console.log();
console.log(chalk.bold('Content:'));
console.log(guideline.content);
return 0;
}
}
export class GuidelineEnableCommand extends Command {
static override paths = [['guideline', 'enable']];
static override usage = Command.Usage({
description: 'Enable a guideline',
examples: [['Enable security', '$0 guideline enable security']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const success = enableGuideline(this.id);
if (!success) {
console.log(chalk.red(`Guideline not found: ${this.id}`));
return 1;
}
console.log(chalk.green(`✓ Enabled guideline: ${this.id}`));
return 0;
}
}
export class GuidelineDisableCommand extends Command {
static override paths = [['guideline', 'disable']];
static override usage = Command.Usage({
description: 'Disable a guideline',
examples: [['Disable performance', '$0 guideline disable performance']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const success = disableGuideline(this.id);
if (!success) {
console.log(chalk.yellow(`Guideline not found or already disabled: ${this.id}`));
return 0;
}
console.log(chalk.green(`✓ Disabled guideline: ${this.id}`));
return 0;
}
}
export class GuidelineCreateCommand extends Command {
static override paths = [['guideline', 'create']];
static override usage = Command.Usage({
description: 'Create a custom guideline',
examples: [
['Create guideline', '$0 guideline create --id my-rules --name "My Rules" --category custom'],
],
});
id = Option.String('--id', {
description: 'Guideline ID',
required: true,
});
name = Option.String('--name,-n', {
description: 'Guideline name',
required: true,
});
description = Option.String('--description,-d', {
description: 'Guideline description',
});
category = Option.String('--category,-c', {
description: 'Category (security, code-style, testing, git, performance, custom)',
});
priority = Option.String('--priority,-p', {
description: 'Priority (1-10, higher = more important)',
});
async execute(): Promise<number> {
if (isBuiltinGuideline(this.id)) {
console.log(chalk.red(`Cannot create: ${this.id} is a built-in guideline`));
return 1;
}
const guideline: Guideline = {
id: this.id,
name: this.name,
description: this.description || this.name,
category: (this.category as GuidelineCategory) || 'custom',
priority: this.priority ? parseInt(this.priority) : 5,
enabled: true,
scope: 'global',
content: `## ${this.name}\n\nAdd your guidelines here.`,
};
addCustomGuideline(guideline);
enableGuideline(this.id);
console.log(chalk.green(`✓ Created guideline: ${this.id}`));
console.log(chalk.dim('Edit ~/.skillkit/guidelines.yaml to customize content'));
return 0;
}
}
export class GuidelineRemoveCommand extends Command {
static override paths = [['guideline', 'remove'], ['guideline', 'rm']];
static override usage = Command.Usage({
description: 'Remove a custom guideline',
examples: [['Remove guideline', '$0 guideline remove my-rules']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
if (isBuiltinGuideline(this.id)) {
console.log(chalk.red(`Cannot remove built-in guideline: ${this.id}`));
return 1;
}
const removed = removeCustomGuideline(this.id);
if (!removed) {
console.log(chalk.yellow(`Guideline not found: ${this.id}`));
return 1;
}
console.log(chalk.green(`✓ Removed guideline: ${this.id}`));
return 0;
}
}
function formatCategoryName(category: string): string {
return category
.split('-')
.map(word => word.charAt(0).toUpperCase() + word.slice(1))
.join(' ');
}
-156
View File
@@ -7,13 +7,6 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import { createHookManager, type HookEvent, type InjectionMode } from '@skillkit/core';
import {
getHookTemplates,
getHookTemplate,
getHookTemplatesByCategory,
type HookTemplate,
type HookTemplateCategory,
} from '@skillkit/resources';
export class HookCommand extends Command {
static override paths = [['hook']];
@@ -287,152 +280,3 @@ export class HookCommand extends Command {
return 0;
}
}
export class HookTemplateListCommand extends Command {
static override paths = [['hook', 'template', 'list']];
static override usage = Command.Usage({
description: 'List available hook templates',
examples: [
['List all templates', '$0 hook template list'],
['Filter by category', '$0 hook template list --category quality'],
],
});
category = Option.String('--category,-c', {
description: 'Filter by category (security, quality, workflow, productivity)',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
let templates = this.category
? getHookTemplatesByCategory(this.category as HookTemplateCategory)
: getHookTemplates();
if (this.json) {
console.log(JSON.stringify(templates, null, 2));
return 0;
}
console.log(chalk.cyan(`Hook Templates (${templates.length}):\n`));
const byCategory = new Map<HookTemplateCategory, HookTemplate[]>();
for (const template of templates) {
if (!byCategory.has(template.category)) {
byCategory.set(template.category, []);
}
byCategory.get(template.category)!.push(template);
}
for (const [category, catTemplates] of byCategory) {
console.log(chalk.blue(` ${formatCategory(category)}`));
for (const template of catTemplates) {
const blocking = template.blocking ? chalk.yellow(' [blocking]') : '';
console.log(` ${chalk.bold(template.id)}${blocking}`);
console.log(` ${chalk.dim(template.description)}`);
console.log(` Event: ${template.event}`);
}
console.log();
}
console.log(chalk.dim('Apply with: skillkit hook template apply <id>'));
return 0;
}
}
export class HookTemplateApplyCommand extends Command {
static override paths = [['hook', 'template', 'apply']];
static override usage = Command.Usage({
description: 'Apply a hook template',
examples: [
['Apply typescript-check', '$0 hook template apply typescript-check'],
['Apply security-scan', '$0 hook template apply security-scan'],
],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const template = getHookTemplate(this.id);
if (!template) {
console.log(chalk.red(`Template not found: ${this.id}`));
console.log(chalk.dim('Run `skillkit hook template list` to see available templates'));
return 1;
}
const projectPath = process.cwd();
const manager = createHookManager({ projectPath });
const hook = manager.registerHook({
event: template.event as HookEvent,
skills: [`template:${template.id}`],
inject: 'content',
matcher: template.matcher,
enabled: true,
metadata: {
templateId: template.id,
command: template.command,
timeout: template.timeout,
blocking: template.blocking,
},
});
manager.save();
console.log(chalk.green(`✓ Applied template: ${template.name}`));
console.log(` Hook ID: ${hook.id.slice(0, 8)}`);
console.log(` Event: ${template.event}`);
console.log(` Command: ${chalk.dim(template.command)}`);
if (template.blocking) {
console.log(chalk.yellow(` Blocking: yes`));
}
return 0;
}
}
export class HookTemplateShowCommand extends Command {
static override paths = [['hook', 'template', 'show']];
static override usage = Command.Usage({
description: 'Show hook template details',
examples: [['Show template', '$0 hook template show typescript-check']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const template = getHookTemplate(this.id);
if (!template) {
console.log(chalk.red(`Template not found: ${this.id}`));
return 1;
}
console.log(chalk.cyan(`Template: ${template.name}\n`));
console.log(`ID: ${template.id}`);
console.log(`Category: ${template.category}`);
console.log(`Description: ${template.description}`);
console.log(`Event: ${template.event}`);
if (template.matcher) {
console.log(`Matcher: ${template.matcher}`);
}
console.log(`Blocking: ${template.blocking ? 'yes' : 'no'}`);
console.log(`Timeout: ${template.timeout || 30000}ms`);
console.log();
console.log(chalk.bold('Command:'));
console.log(` ${template.command}`);
return 0;
}
}
function formatCategory(category: string): string {
return category.charAt(0).toUpperCase() + category.slice(1);
}
+3 -53
View File
@@ -17,13 +17,7 @@ export { RecommendCommand } from './recommend.js';
export { StatusCommand } from './status.js';
export { PauseCommand } from './pause.js';
export { ResumeCommand } from './resume.js';
export {
WorkflowRunCommand,
WorkflowListCommand,
WorkflowCreateCommand,
WorkflowPipelineCommand,
WorkflowPipelineListCommand,
} from './workflow/index.js';
export { WorkflowRunCommand, WorkflowListCommand, WorkflowCreateCommand } from './workflow/index.js';
export { RunCommand } from './run.js';
export { TestCommand } from './test.js';
export { MarketplaceCommand } from './marketplace.js';
@@ -33,14 +27,9 @@ export { CICDCommand } from './cicd.js';
export { TeamCommand } from './team.js';
export { PluginCommand } from './plugin.js';
export { MethodologyCommand } from './methodology.js';
export {
HookCommand,
HookTemplateListCommand,
HookTemplateApplyCommand,
HookTemplateShowCommand,
} from './hook.js';
export { HookCommand } from './hook.js';
export { PlanCommand } from './plan.js';
export { CommandCmd, CommandAvailableCommand, CommandInstallCommand } from './command.js';
export { CommandCmd } from './command.js';
export { AICommand } from './ai.js';
export { AuditCommand } from './audit.js';
export { PublishCommand } from './publish.js';
@@ -52,8 +41,6 @@ export {
AgentTranslateCommand,
AgentSyncCommand,
AgentValidateCommand,
AgentInstallCommand,
AgentAvailableCommand,
} from './agent.js';
export { CheckCommand } from './check.js';
@@ -67,40 +54,3 @@ export {
ManifestGenerateCommand,
} from './manifest.js';
export { PrimerCommand } from './primer.js';
export { MeshCommand } from './mesh.js';
export { MessageCommand } from './message.js';
export {
LearnCommand,
PatternStatusCommand,
PatternFeedbackCommand,
PatternApproveCommand,
PatternRejectCommand,
PatternExportCommand,
PatternImportCommand,
PatternClusterCommand,
} from './learn.js';
export {
SessionCommand,
SessionStatusCommand,
SessionStartCommand,
SessionLoadCommand,
SessionListCommand,
SessionNoteCommand,
SessionCompleteCommand,
SessionInProgressCommand,
} from './session.js';
export {
ProfileCommand,
ProfileListCommand,
ProfileCreateCommand,
ProfileRemoveCommand,
} from './profile.js';
export {
GuidelineCommand,
GuidelineListCommand,
GuidelineShowCommand,
GuidelineEnableCommand,
GuidelineDisableCommand,
GuidelineCreateCommand,
GuidelineRemoveCommand,
} from './guideline.js';
+1 -1
View File
@@ -34,7 +34,7 @@ import {
} from '../onboarding/index.js';
export class InstallCommand extends Command {
static override paths = [['install'], ['i'], ['add']];
static override paths = [['install'], ['i']];
static override usage = Command.Usage({
description: 'Install skills from GitHub, GitLab, Bitbucket, or local path',
-491
View File
@@ -1,491 +0,0 @@
import { Command, Option } from 'clipanion';
import { resolve } from 'node:path';
import chalk from 'chalk';
import {
analyzeGitHistory,
loadPatternStore,
addPattern,
getAllPatterns,
getApprovedPatterns,
generateSkillFromPatterns,
saveGeneratedSkill,
generatePatternReport,
exportPatternsAsJson,
importPatternsFromJson,
recordSuccess,
recordFailure,
approvePattern,
rejectPattern,
getPatternStats,
clusterPatterns,
type LearnedPattern,
type GitAnalysisResult,
} from '@skillkit/core';
import { writeFileSync, readFileSync, existsSync } from 'node:fs';
export class LearnCommand extends Command {
static override paths = [['learn']];
static override usage = Command.Usage({
description: 'Extract learnable patterns from git history or sessions',
details: `
Analyzes git commit history to extract reusable patterns for error fixes,
workarounds, debugging techniques, and project conventions.
Patterns are stored locally and can be converted into skills.
`,
examples: [
['Analyze git history', '$0 learn'],
['Analyze specific number of commits', '$0 learn --commits 50'],
['Auto-approve patterns', '$0 learn --approve'],
['Show extracted patterns', '$0 learn --show'],
],
});
commits = Option.String('--commits,-c', {
description: 'Number of commits to analyze (default: 100)',
});
since = Option.String('--since,-s', {
description: 'Analyze commits since date (e.g., "2 weeks ago")',
});
approve = Option.Boolean('--approve,-a', false, {
description: 'Auto-approve extracted patterns',
});
show = Option.Boolean('--show', false, {
description: 'Show existing patterns without analyzing',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
directory = Option.String('--dir,-d', {
description: 'Project directory to analyze (default: current directory)',
});
async execute(): Promise<number> {
const projectPath = resolve(this.directory || process.cwd());
if (this.show) {
return this.showPatterns();
}
console.log(chalk.cyan('Analyzing git history for learnable patterns...\n'));
const result = analyzeGitHistory(projectPath, {
commits: this.commits ? parseInt(this.commits) : 100,
since: this.since,
});
if (this.json) {
console.log(JSON.stringify(result, null, 2));
return 0;
}
this.printAnalysisResult(result);
if (result.patterns.length === 0) {
console.log(chalk.yellow('\nNo learnable patterns found.'));
console.log(chalk.dim('Try analyzing more commits or a different date range.'));
return 0;
}
loadPatternStore();
let added = 0;
for (const pattern of result.patterns) {
if (this.approve) {
pattern.approved = true;
}
addPattern(pattern);
added++;
}
console.log();
console.log(chalk.green(`✓ Extracted ${added} patterns`));
if (!this.approve) {
console.log(chalk.dim('Patterns are pending approval. Use:'));
console.log(chalk.dim(' skillkit pattern approve <id> - to approve'));
console.log(chalk.dim(' skillkit pattern status - to view all'));
}
return 0;
}
private printAnalysisResult(result: GitAnalysisResult): void {
const { summary, dateRange, languages, frameworks } = result;
console.log(chalk.bold('Analysis Summary'));
console.log(` Commits analyzed: ${summary.totalCommits}`);
console.log(` Files changed: ${summary.totalFilesChanged}`);
console.log(` Date range: ${dateRange.from || 'N/A'} to ${dateRange.to || 'N/A'}`);
console.log();
if (languages.length > 0) {
console.log(` Languages: ${chalk.cyan(languages.join(', '))}`);
}
if (frameworks.length > 0) {
console.log(` Frameworks: ${chalk.cyan(frameworks.join(', '))}`);
}
console.log();
console.log(chalk.bold('Commit Categories'));
console.log(` Error fixes: ${summary.errorFixes}`);
console.log(` Refactors: ${summary.refactors}`);
console.log(` Features: ${summary.features}`);
console.log(` Documentation: ${summary.documentation}`);
console.log(` Tests: ${summary.tests}`);
console.log();
console.log(chalk.bold(`Patterns Extracted: ${result.patterns.length}`));
for (const pattern of result.patterns.slice(0, 5)) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} [${pattern.category}] ${confidence}`);
}
if (result.patterns.length > 5) {
console.log(chalk.dim(` ... and ${result.patterns.length - 5} more`));
}
}
private showPatterns(): number {
const patterns = getAllPatterns();
if (this.json) {
console.log(JSON.stringify(patterns, null, 2));
return 0;
}
if (patterns.length === 0) {
console.log(chalk.yellow('No patterns stored yet.'));
console.log(chalk.dim('Run `skillkit learn` to extract patterns from git history.'));
return 0;
}
console.log(chalk.cyan(`Stored Patterns (${patterns.length}):\n`));
const approved = patterns.filter(p => p.approved);
const pending = patterns.filter(p => !p.approved);
if (approved.length > 0) {
console.log(chalk.green('Approved:'));
for (const pattern of approved) {
this.printPattern(pattern);
}
console.log();
}
if (pending.length > 0) {
console.log(chalk.yellow('Pending Approval:'));
for (const pattern of pending) {
this.printPattern(pattern);
}
}
return 0;
}
private printPattern(pattern: LearnedPattern): void {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`);
const status = pattern.approved ? chalk.green('✓') : chalk.yellow('○');
console.log(` ${status} ${chalk.bold(pattern.id)}`);
console.log(` ${pattern.title} [${pattern.category}] ${confidence}`);
console.log(chalk.dim(` ${truncate(pattern.problem, 60)}`));
}
}
export class PatternStatusCommand extends Command {
static override paths = [['pattern', 'status'], ['pattern', 'list']];
static override usage = Command.Usage({
description: 'Show status of learned patterns',
examples: [
['Show all patterns', '$0 pattern status'],
['Show by category', '$0 pattern status --category error_fix'],
],
});
category = Option.String('--category,-c', {
description: 'Filter by category (error_fix, refactor, workaround, debugging, convention)',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const stats = getPatternStats();
if (this.json) {
console.log(JSON.stringify(stats, null, 2));
return 0;
}
console.log(chalk.cyan('Pattern Statistics\n'));
console.log(`Total patterns: ${stats.total}`);
console.log();
console.log(chalk.bold('By Confidence:'));
console.log(` High (>70%): ${stats.byConfidenceRange.high}`);
console.log(` Medium (40-70%): ${stats.byConfidenceRange.medium}`);
console.log(` Low (<40%): ${stats.byConfidenceRange.low}`);
console.log();
if (stats.byDomain.size > 0) {
console.log(chalk.bold('By Domain:'));
for (const [domain, count] of stats.byDomain) {
console.log(` ${domain}: ${count}`);
}
console.log();
}
if (stats.mostUsed) {
console.log(chalk.bold('Most Used Pattern:'));
console.log(` ${stats.mostUsed.title} (${stats.mostUsed.useCount} uses)`);
}
return 0;
}
}
export class PatternFeedbackCommand extends Command {
static override paths = [['pattern', 'feedback']];
static override usage = Command.Usage({
description: 'Provide feedback on a pattern to evolve its confidence',
examples: [
['Mark pattern as successful', '$0 pattern feedback <id> --success'],
['Mark pattern as failed', '$0 pattern feedback <id> --failure'],
],
});
id = Option.String({ required: true });
success = Option.Boolean('--success,-s', false, {
description: 'Pattern was helpful',
});
failure = Option.Boolean('--failure,-f', false, {
description: 'Pattern was not helpful',
});
async execute(): Promise<number> {
if (!this.success && !this.failure) {
console.log(chalk.yellow('Please specify --success or --failure'));
return 1;
}
const result = this.success
? recordSuccess(this.id)
: recordFailure(this.id);
if (!result) {
console.log(chalk.red(`Pattern not found: ${this.id}`));
return 1;
}
const change = result.change === 'increased' ? chalk.green('↑') : chalk.red('↓');
console.log(chalk.green(`✓ Feedback recorded`));
console.log(` Confidence: ${(result.previousConfidence * 100).toFixed(0)}% ${change} ${(result.newConfidence * 100).toFixed(0)}%`);
console.log(` Total uses: ${result.pattern.useCount}`);
return 0;
}
}
export class PatternApproveCommand extends Command {
static override paths = [['pattern', 'approve']];
static override usage = Command.Usage({
description: 'Approve a pending pattern',
examples: [['Approve pattern', '$0 pattern approve <id>']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const pattern = approvePattern(this.id);
if (!pattern) {
console.log(chalk.red(`Pattern not found: ${this.id}`));
return 1;
}
console.log(chalk.green(`✓ Approved: ${pattern.title}`));
return 0;
}
}
export class PatternRejectCommand extends Command {
static override paths = [['pattern', 'reject']];
static override usage = Command.Usage({
description: 'Reject and remove a pattern',
examples: [['Reject pattern', '$0 pattern reject <id>']],
});
id = Option.String({ required: true });
async execute(): Promise<number> {
const removed = rejectPattern(this.id);
if (!removed) {
console.log(chalk.red(`Pattern not found: ${this.id}`));
return 1;
}
console.log(chalk.green(`✓ Removed pattern: ${this.id}`));
return 0;
}
}
export class PatternExportCommand extends Command {
static override paths = [['pattern', 'export']];
static override usage = Command.Usage({
description: 'Export patterns to a file',
examples: [
['Export as JSON', '$0 pattern export --output patterns.json'],
['Export as markdown report', '$0 pattern export --format report'],
],
});
output = Option.String('--output,-o', {
description: 'Output file path',
});
format = Option.String('--format,-f', {
description: 'Format: json or report (default: json)',
});
approvedOnly = Option.Boolean('--approved', false, {
description: 'Export only approved patterns',
});
async execute(): Promise<number> {
const patterns = this.approvedOnly ? getApprovedPatterns() : getAllPatterns();
if (patterns.length === 0) {
console.log(chalk.yellow('No patterns to export'));
return 0;
}
const format = this.format || 'json';
let content: string;
if (format === 'report') {
content = generatePatternReport(patterns);
} else {
content = exportPatternsAsJson(patterns);
}
if (this.output) {
writeFileSync(this.output, content);
console.log(chalk.green(`✓ Exported ${patterns.length} patterns to ${this.output}`));
} else {
console.log(content);
}
return 0;
}
}
export class PatternImportCommand extends Command {
static override paths = [['pattern', 'import']];
static override usage = Command.Usage({
description: 'Import patterns from a file',
examples: [['Import patterns', '$0 pattern import patterns.json']],
});
file = Option.String({ required: true });
async execute(): Promise<number> {
if (!existsSync(this.file)) {
console.log(chalk.red(`File not found: ${this.file}`));
return 1;
}
const content = readFileSync(this.file, 'utf-8');
const patterns = importPatternsFromJson(content);
if (patterns.length === 0) {
console.log(chalk.yellow('No patterns found in file'));
return 1;
}
for (const pattern of patterns) {
addPattern(pattern);
}
console.log(chalk.green(`✓ Imported ${patterns.length} patterns`));
return 0;
}
}
export class PatternClusterCommand extends Command {
static override paths = [['pattern', 'cluster']];
static override usage = Command.Usage({
description: 'Cluster similar patterns and generate skills',
examples: [
['Cluster patterns', '$0 pattern cluster'],
['Cluster and generate skills', '$0 pattern cluster --generate'],
],
});
generate = Option.Boolean('--generate,-g', false, {
description: 'Generate skills from clusters',
});
minConfidence = Option.String('--min-confidence', {
description: 'Minimum confidence for clustering (default: 0.5)',
});
async execute(): Promise<number> {
const patterns = getApprovedPatterns();
if (patterns.length === 0) {
console.log(chalk.yellow('No approved patterns to cluster'));
console.log(chalk.dim('Approve patterns first with: skillkit pattern approve <id>'));
return 0;
}
const clusters = clusterPatterns(patterns);
console.log(chalk.cyan(`Pattern Clusters (${clusters.size}):\n`));
for (const [category, categoryPatterns] of clusters) {
console.log(chalk.bold(`${category.replace('_', ' ')} (${categoryPatterns.length}):`));
for (const pattern of categoryPatterns) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} ${confidence}`);
}
console.log();
if (this.generate && categoryPatterns.length >= 1) {
const skill = generateSkillFromPatterns(categoryPatterns, {
minConfidence: this.minConfidence ? parseFloat(this.minConfidence) : 0.5,
});
if (skill) {
const filepath = saveGeneratedSkill(skill);
console.log(chalk.green(` → Generated skill: ${filepath}`));
}
}
}
return 0;
}
}
function truncate(str: string, maxLen: number): string {
if (str.length <= maxLen) return str;
return str.slice(0, maxLen - 3) + '...';
}
-661
View File
@@ -1,661 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
export class MeshCommand extends Command {
static override paths = [['mesh']];
static override usage = Command.Usage({
description: 'Manage peer mesh network for multi-machine agent distribution',
details: `
The mesh command helps you manage a peer-to-peer network of hosts
running SkillKit agents across multiple machines.
Subcommands:
- init: Initialize local host for mesh networking
- add: Add a peer host to the network
- remove: Remove a host from the network
- list: List all known hosts and peers
- health: Check health of all hosts
- discover: Discover hosts on local network
- status: Show mesh network status
- security: Security management (init, status)
- peer: Peer trust management (trust, revoke, list)
`,
examples: [
['Initialize mesh', '$0 mesh init'],
['Add a host', '$0 mesh add 192.168.1.100:9876'],
['Add with name', '$0 mesh add 192.168.1.100 --name workstation'],
['Remove a host', '$0 mesh remove <hostId>'],
['List all hosts', '$0 mesh list'],
['Check health', '$0 mesh health'],
['Discover hosts', '$0 mesh discover'],
['Initialize security', '$0 mesh security init'],
['Show security status', '$0 mesh security status'],
['Trust a peer', '$0 mesh peer trust <fingerprint>'],
['Revoke a peer', '$0 mesh peer revoke <fingerprint>'],
['List trusted peers', '$0 mesh peer list --trusted'],
],
});
action = Option.String({ required: false });
arg = Option.String({ required: false });
subArg = Option.String({ required: false });
name = Option.String('--name,-n', { description: 'Name for the host' });
port = Option.String('--port,-p', { description: 'Port number' });
tailscale = Option.Boolean('--tailscale,-t', false, { description: 'Include Tailscale peers' });
timeout = Option.String('--timeout', { description: 'Timeout in milliseconds' });
json = Option.Boolean('--json,-j', false, { description: 'Output in JSON format' });
verbose = Option.Boolean('--verbose,-v', false, { description: 'Show detailed output' });
trusted = Option.Boolean('--trusted', false, { description: 'Show only trusted peers' });
securityLevel = Option.String('--security', { description: 'Security level: development, signed, secure, strict' });
async execute(): Promise<number> {
const action = this.action || 'status';
switch (action) {
case 'init':
return this.initMesh();
case 'add':
return this.addHost();
case 'remove':
return this.removeHost();
case 'list':
return this.listHosts();
case 'health':
return this.checkHealth();
case 'discover':
return this.discoverHosts();
case 'status':
return this.showStatus();
case 'security':
return this.handleSecurity();
case 'peer':
return this.handlePeer();
default:
console.error(chalk.red(`Unknown action: ${action}`));
console.log(chalk.gray('Available actions: init, add, remove, list, health, discover, status, security, peer'));
return 1;
}
}
private async initMesh(): Promise<number> {
try {
const { initializeHostsFile, getLocalIPAddress, isTailscaleAvailable, getTailscaleIP } = await import('@skillkit/mesh');
const hostsFile = await initializeHostsFile();
const localConfig = hostsFile.localHost;
const localIP = getLocalIPAddress();
console.log(chalk.green('✓ Mesh network initialized\n'));
console.log(chalk.bold('Local Host Configuration:'));
console.log(` ID: ${chalk.cyan(localConfig.id.slice(0, 8))}`);
console.log(` Name: ${localConfig.name}`);
console.log(` Address: ${localIP}:${localConfig.port}`);
const hasTailscale = await isTailscaleAvailable();
if (hasTailscale) {
const tailscaleIP = await getTailscaleIP();
if (tailscaleIP) {
console.log(` Tailscale: ${tailscaleIP}:${localConfig.port}`);
}
}
console.log();
console.log(chalk.gray('Other hosts can connect to this machine using:'));
console.log(chalk.gray(` skillkit mesh add ${localIP}:${localConfig.port}`));
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to initialize mesh: ${err.message}`));
return 1;
}
}
private async addHost(): Promise<number> {
if (!this.arg) {
console.error(chalk.red('Error: Host address is required'));
console.log(chalk.gray('Usage: skillkit mesh add <address>[:port]'));
return 1;
}
try {
const { addKnownHost, DEFAULT_PORT } = await import('@skillkit/mesh');
const { randomUUID } = await import('node:crypto');
const [address, portStr] = this.arg.split(':');
const portValue = portStr ?? this.port;
const port = portValue ? Number(portValue) : DEFAULT_PORT;
if (!Number.isInteger(port) || port < 1 || port > 65535) {
console.error(chalk.red(`Invalid port: ${portValue}`));
return 1;
}
const host = {
id: randomUUID(),
name: this.name || address,
address,
port,
status: 'unknown' as const,
lastSeen: new Date().toISOString(),
};
await addKnownHost(host);
console.log(chalk.green(`✓ Added host: ${host.name}`));
console.log(` ID: ${chalk.gray(host.id.slice(0, 8))}`);
console.log(` Address: ${host.address}:${host.port}`);
console.log(chalk.gray('\nRun "skillkit mesh health" to verify connectivity.'));
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to add host: ${err.message}`));
return 1;
}
}
private async removeHost(): Promise<number> {
if (!this.arg) {
console.error(chalk.red('Error: Host ID is required'));
console.log(chalk.gray('Usage: skillkit mesh remove <hostId>'));
return 1;
}
try {
const { removeKnownHost, getKnownHosts } = await import('@skillkit/mesh');
const hosts = await getKnownHosts();
const host = hosts.find(h => h.id === this.arg || h.id.startsWith(this.arg!) || h.name === this.arg);
if (!host) {
console.error(chalk.red(`Host not found: ${this.arg}`));
return 1;
}
const removed = await removeKnownHost(host.id);
if (removed) {
console.log(chalk.green(`✓ Removed host: ${host.name}`));
} else {
console.error(chalk.red('Failed to remove host'));
return 1;
}
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to remove host: ${err.message}`));
return 1;
}
}
private async listHosts(): Promise<number> {
try {
const { getKnownHosts, getLocalHostConfig, getLocalIPAddress, discoverTailscaleHosts, isTailscaleAvailable } = await import('@skillkit/mesh');
const localConfig = await getLocalHostConfig();
const localIP = getLocalIPAddress();
const hosts = await getKnownHosts();
if (this.json) {
console.log(JSON.stringify({ localHost: { ...localConfig, address: localIP }, hosts }, null, 2));
return 0;
}
console.log(chalk.bold('\nLocal Host:\n'));
console.log(` ${chalk.cyan('●')} ${localConfig.name} ${chalk.green('[local]')}`);
console.log(` ID: ${chalk.gray(localConfig.id.slice(0, 8))}`);
console.log(` Address: ${localIP}:${localConfig.port}`);
console.log(chalk.bold('\nKnown Hosts:\n'));
if (hosts.length === 0) {
console.log(chalk.gray(' No hosts configured.'));
console.log(chalk.gray(' Add hosts with: skillkit mesh add <address>'));
} else {
for (const host of hosts) {
const statusIcon = host.status === 'online' ? chalk.green('●') : host.status === 'offline' ? chalk.red('●') : chalk.gray('○');
const statusLabel = host.status === 'online' ? chalk.green('[online]') : host.status === 'offline' ? chalk.red('[offline]') : chalk.gray('[unknown]');
console.log(` ${statusIcon} ${host.name} ${statusLabel}`);
console.log(` ID: ${chalk.gray(host.id.slice(0, 8))}`);
console.log(` Address: ${host.address}:${host.port}`);
if (host.tailscaleIP) {
console.log(` Tailscale: ${host.tailscaleIP}`);
}
if (this.verbose) {
console.log(` Last seen: ${new Date(host.lastSeen).toLocaleString()}`);
}
}
}
if (this.tailscale) {
const hasTailscale = await isTailscaleAvailable();
if (hasTailscale) {
const tailscaleHosts = await discoverTailscaleHosts(localConfig.port);
if (tailscaleHosts.length > 0) {
console.log(chalk.bold('\nTailscale Peers:\n'));
for (const host of tailscaleHosts) {
console.log(` ${chalk.blue('◆')} ${host.name}`);
console.log(` IP: ${host.tailscaleIP}`);
}
}
}
}
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to list hosts: ${err.message}`));
return 1;
}
}
private async checkHealth(): Promise<number> {
try {
const { checkAllHostsHealth, getKnownHosts } = await import('@skillkit/mesh');
const hosts = await getKnownHosts();
if (hosts.length === 0) {
console.log(chalk.yellow('No hosts configured.'));
console.log(chalk.gray('Add hosts with: skillkit mesh add <address>'));
return 0;
}
console.log(chalk.bold('\nChecking host health...\n'));
const timeout = this.timeout ? parseInt(this.timeout, 10) : undefined;
const results = await checkAllHostsHealth({ timeout });
if (this.json) {
console.log(JSON.stringify(results, null, 2));
return 0;
}
let hasFailures = false;
for (const result of results) {
const host = hosts.find(h => h.id === result.hostId);
const name = host?.name || result.hostId.slice(0, 8);
if (result.status === 'online') {
console.log(` ${chalk.green('✓')} ${name} - ${chalk.green('online')} (${result.latencyMs}ms)`);
} else {
hasFailures = true;
console.log(` ${chalk.red('✗')} ${name} - ${chalk.red('offline')} ${result.error ? `(${result.error})` : ''}`);
}
}
console.log();
const online = results.filter(r => r.status === 'online').length;
const total = results.length;
console.log(`${online}/${total} hosts online`);
return hasFailures ? 1 : 0;
} catch (err: any) {
console.error(chalk.red(`Failed to check health: ${err.message}`));
return 1;
}
}
private async discoverHosts(): Promise<number> {
try {
const { discoverOnce, isTailscaleAvailable, discoverTailscaleHosts, getLocalHostConfig } = await import('@skillkit/mesh');
console.log(chalk.bold('\nDiscovering hosts on local network...\n'));
const timeout = this.timeout ? parseInt(this.timeout, 10) : 5000;
const localHosts = await discoverOnce(timeout);
if (localHosts.length === 0) {
console.log(chalk.gray(' No hosts discovered on local network.'));
} else {
console.log(chalk.cyan('Local Network:'));
for (const host of localHosts) {
console.log(` ${chalk.green('●')} ${host.name}`);
console.log(` Address: ${host.address}:${host.port}`);
}
}
if (this.tailscale) {
const hasTailscale = await isTailscaleAvailable();
if (hasTailscale) {
const localConfig = await getLocalHostConfig();
const tailscaleHosts = await discoverTailscaleHosts(localConfig.port);
if (tailscaleHosts.length > 0) {
console.log(chalk.cyan('\nTailscale Network:'));
for (const host of tailscaleHosts) {
console.log(` ${chalk.blue('◆')} ${host.name}`);
console.log(` Tailscale IP: ${host.tailscaleIP}`);
}
} else {
console.log(chalk.gray('\n No Tailscale peers found.'));
}
} else {
console.log(chalk.gray('\n Tailscale not available.'));
}
}
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to discover hosts: ${err.message}`));
return 1;
}
}
private async showStatus(): Promise<number> {
try {
const { getKnownHosts, getLocalHostConfig, getLocalIPAddress, isTailscaleAvailable, getTailscaleIP, getPeerRegistry } = await import('@skillkit/mesh');
const localConfig = await getLocalHostConfig();
const localIP = getLocalIPAddress();
const hosts = await getKnownHosts();
const registry = await getPeerRegistry();
const localPeers = registry.getLocalPeers();
const onlineHosts = hosts.filter(h => h.status === 'online').length;
const hasTailscale = await isTailscaleAvailable();
if (this.json) {
console.log(JSON.stringify({
localHost: { ...localConfig, address: localIP },
hosts: hosts.length,
onlineHosts,
localPeers: localPeers.length,
tailscaleAvailable: hasTailscale,
}, null, 2));
return 0;
}
console.log(chalk.bold('\nMesh Network Status\n'));
console.log(chalk.cyan('Local Host:'));
console.log(` Name: ${localConfig.name}`);
console.log(` ID: ${chalk.gray(localConfig.id.slice(0, 8))}`);
console.log(` Address: ${localIP}:${localConfig.port}`);
if (hasTailscale) {
const tailscaleIP = await getTailscaleIP();
if (tailscaleIP) {
console.log(` Tailscale: ${chalk.blue(tailscaleIP)}`);
}
}
console.log();
console.log(chalk.cyan('Network:'));
console.log(` Known hosts: ${hosts.length}`);
console.log(` Online: ${onlineHosts}`);
console.log(` Local peers: ${localPeers.length}`);
console.log(` Tailscale: ${hasTailscale ? chalk.green('available') : chalk.gray('not available')}`);
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to get status: ${err.message}`));
return 1;
}
}
private async handleSecurity(): Promise<number> {
const subAction = this.arg || 'status';
switch (subAction) {
case 'init':
return this.initSecurity();
case 'status':
return this.showSecurityStatus();
default:
console.error(chalk.red(`Unknown security action: ${subAction}`));
console.log(chalk.gray('Available actions: init, status'));
return 1;
}
}
private async initSecurity(): Promise<number> {
try {
const { SecureKeystore, TLSManager, getLocalHostConfig, describeSecurityLevel, DEFAULT_SECURITY_CONFIG } = await import('@skillkit/mesh');
console.log(chalk.bold('\nInitializing mesh security...\n'));
const keystore = new SecureKeystore();
const identity = await keystore.loadOrCreateIdentity();
console.log(chalk.green('✓ Identity created/loaded'));
console.log(` Fingerprint: ${chalk.cyan(identity.fingerprint)}`);
console.log(` Public Key: ${chalk.gray(identity.publicKeyHex.slice(0, 32))}...`);
const localConfig = await getLocalHostConfig();
const tlsManager = new TLSManager();
const certInfo = await tlsManager.loadOrCreateCertificate(localConfig.id, 'localhost');
console.log(chalk.green('\n✓ TLS certificate generated'));
console.log(` Fingerprint: ${chalk.gray(certInfo.fingerprint.slice(0, 16))}...`);
console.log(` Valid until: ${certInfo.notAfter.toLocaleDateString()}`);
console.log(chalk.green('\n✓ Security initialized'));
console.log(` Mode: ${chalk.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`);
console.log(chalk.gray('\nOther hosts can trust this peer using:'));
console.log(chalk.gray(` skillkit mesh peer trust ${identity.fingerprint}`));
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to initialize security: ${err.message}`));
return 1;
}
}
private async showSecurityStatus(): Promise<number> {
try {
const {
SecureKeystore,
TLSManager,
getLocalHostConfig,
describeSecurityLevel,
DEFAULT_SECURITY_CONFIG,
isSecurityEnabled,
} = await import('@skillkit/mesh');
const keystore = new SecureKeystore();
console.log(chalk.bold('\nMesh Security Status\n'));
const hasIdentity = await keystore.hasIdentity();
if (hasIdentity) {
const identity = await keystore.loadOrCreateIdentity();
const trustedPeers = await keystore.getTrustedPeers();
const revokedPeers = await keystore.getRevokedFingerprints();
console.log(chalk.cyan('Identity:'));
console.log(` Fingerprint: ${chalk.green(identity.fingerprint)}`);
console.log(` Public Key: ${chalk.gray(identity.publicKeyHex.slice(0, 32))}...`);
console.log(chalk.cyan('\nTrust:'));
console.log(` Trusted peers: ${trustedPeers.length}`);
console.log(` Revoked peers: ${revokedPeers.length}`);
if (this.verbose && trustedPeers.length > 0) {
console.log(chalk.cyan('\nTrusted Peers:'));
for (const peer of trustedPeers) {
console.log(` ${chalk.green('●')} ${peer.name || peer.fingerprint.slice(0, 16)}`);
console.log(` Fingerprint: ${chalk.gray(peer.fingerprint)}`);
console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`);
}
}
} else {
console.log(chalk.yellow('Identity: Not initialized'));
console.log(chalk.gray('Run "skillkit mesh security init" to initialize.'));
}
const localConfig = await getLocalHostConfig();
const tlsManager = new TLSManager();
const hasCert = await tlsManager.hasCertificate(localConfig.id);
console.log(chalk.cyan('\nTLS:'));
if (hasCert) {
const certInfo = await tlsManager.loadCertificate(localConfig.id);
console.log(` Certificate: ${chalk.green('Available')}`);
if (certInfo) {
console.log(` Fingerprint: ${chalk.gray(certInfo.fingerprint.slice(0, 16))}...`);
}
} else {
console.log(` Certificate: ${chalk.yellow('Not generated')}`);
}
console.log(chalk.cyan('\nConfiguration:'));
console.log(` Security level: ${chalk.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`);
console.log(` Discovery mode: ${DEFAULT_SECURITY_CONFIG.discovery.mode}`);
console.log(` Transport encryption: ${DEFAULT_SECURITY_CONFIG.transport.encryption}`);
console.log(` Auth required: ${DEFAULT_SECURITY_CONFIG.transport.requireAuth ? chalk.green('yes') : chalk.gray('no')}`);
if (this.json) {
const identity = hasIdentity ? await keystore.loadOrCreateIdentity() : null;
console.log(JSON.stringify({
hasIdentity,
fingerprint: identity?.fingerprint,
hasCertificate: hasCert,
securityEnabled: isSecurityEnabled(DEFAULT_SECURITY_CONFIG),
config: DEFAULT_SECURITY_CONFIG,
}, null, 2));
}
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to get security status: ${err.message}`));
return 1;
}
}
private async handlePeer(): Promise<number> {
const subAction = this.arg;
if (!subAction) {
console.error(chalk.red('Error: Peer action is required'));
console.log(chalk.gray('Usage: skillkit mesh peer <trust|revoke|list> [fingerprint]'));
return 1;
}
switch (subAction) {
case 'trust':
return this.trustPeer();
case 'revoke':
return this.revokePeer();
case 'list':
return this.listPeers();
default:
console.error(chalk.red(`Unknown peer action: ${subAction}`));
console.log(chalk.gray('Available actions: trust, revoke, list'));
return 1;
}
}
private async trustPeer(): Promise<number> {
const fingerprint = this.subArg;
if (!fingerprint) {
console.error(chalk.red('Error: Fingerprint is required'));
console.log(chalk.gray('Usage: skillkit mesh peer trust <fingerprint> [--name <name>]'));
return 1;
}
try {
const { SecureKeystore } = await import('@skillkit/mesh');
const keystore = new SecureKeystore();
const isRevoked = await keystore.isRevoked(fingerprint);
if (isRevoked) {
console.log(chalk.yellow(`Peer ${fingerprint.slice(0, 8)} was previously revoked. Removing from revoked list...`));
}
await keystore.addTrustedPeer(fingerprint, '', this.name);
console.log(chalk.green(`✓ Trusted peer: ${this.name || fingerprint.slice(0, 16)}`));
console.log(` Fingerprint: ${chalk.gray(fingerprint)}`);
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to trust peer: ${err.message}`));
return 1;
}
}
private async revokePeer(): Promise<number> {
const fingerprint = this.subArg;
if (!fingerprint) {
console.error(chalk.red('Error: Fingerprint is required'));
console.log(chalk.gray('Usage: skillkit mesh peer revoke <fingerprint>'));
return 1;
}
try {
const { SecureKeystore } = await import('@skillkit/mesh');
const keystore = new SecureKeystore();
await keystore.revokePeer(fingerprint);
console.log(chalk.green(`✓ Revoked peer: ${fingerprint.slice(0, 16)}`));
console.log(chalk.gray('This peer will no longer be trusted for mesh communication.'));
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to revoke peer: ${err.message}`));
return 1;
}
}
private async listPeers(): Promise<number> {
try {
const { SecureKeystore } = await import('@skillkit/mesh');
const keystore = new SecureKeystore();
const trustedPeers = await keystore.getTrustedPeers();
const revokedFingerprints = await keystore.getRevokedFingerprints();
if (this.json) {
console.log(JSON.stringify({ trusted: trustedPeers, revoked: revokedFingerprints }, null, 2));
return 0;
}
console.log(chalk.bold('\nPeer Trust Status\n'));
if (this.trusted || trustedPeers.length > 0) {
console.log(chalk.cyan('Trusted Peers:'));
if (trustedPeers.length === 0) {
console.log(chalk.gray(' No trusted peers.'));
} else {
for (const peer of trustedPeers) {
console.log(` ${chalk.green('●')} ${peer.name || 'Unknown'}`);
console.log(` Fingerprint: ${chalk.gray(peer.fingerprint)}`);
console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`);
}
}
}
if (!this.trusted && revokedFingerprints.length > 0) {
console.log(chalk.cyan('\nRevoked Peers:'));
for (const fp of revokedFingerprints) {
console.log(` ${chalk.red('●')} ${chalk.gray(fp)}`);
}
}
console.log(chalk.gray(`\nTotal: ${trustedPeers.length} trusted, ${revokedFingerprints.length} revoked`));
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to list peers: ${err.message}`));
return 1;
}
}
}
-519
View File
@@ -1,519 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
export class MessageCommand extends Command {
static override paths = [['message'], ['msg']];
static override usage = Command.Usage({
description: 'Inter-agent messaging system',
details: `
The message command enables communication between AI agents
across the mesh network.
Subcommands:
- send: Send a message to an agent
- inbox: View inbox messages
- read: Read a specific message
- reply: Reply to a message
- archive: Archive a message
- forward: Forward a message
- sent: View sent messages
- status: Show messaging status
`,
examples: [
['Send a message', '$0 message send backend-agent --body "API ready"'],
['Send with priority', '$0 message send agent --body "Urgent!" --priority high'],
['View inbox', '$0 message inbox'],
['View unread', '$0 message inbox --unread'],
['Read a message', '$0 message read <id>'],
['Reply to message', '$0 message reply <id> --body "Thanks!"'],
['Archive a message', '$0 message archive <id>'],
['Forward a message', '$0 message forward <id> other-agent'],
],
});
action = Option.String({ required: false });
arg = Option.String({ required: false });
arg2 = Option.String({ required: false });
body = Option.String('--body,-b', { description: 'Message body' });
subject = Option.String('--subject,-s', { description: 'Message subject' });
priority = Option.String('--priority,-p', { description: 'Priority: low, normal, high, urgent' });
type = Option.String('--type,-t', { description: 'Type: request, response, notification, update' });
unread = Option.Boolean('--unread,-u', false, { description: 'Show only unread messages' });
limit = Option.String('--limit,-l', { description: 'Maximum number of results' });
agent = Option.String('--agent,-a', { description: 'Agent ID (defaults to current agent)' });
json = Option.Boolean('--json,-j', false, { description: 'Output in JSON format' });
verbose = Option.Boolean('--verbose,-v', false, { description: 'Show detailed output' });
async execute(): Promise<number> {
const action = this.action || 'inbox';
switch (action) {
case 'send':
return this.sendMessage();
case 'inbox':
return this.showInbox();
case 'read':
return this.readMessage();
case 'reply':
return this.replyMessage();
case 'archive':
return this.archiveMessage();
case 'forward':
return this.forwardMessage();
case 'sent':
return this.showSent();
case 'status':
return this.showStatus();
default:
console.error(chalk.red(`Unknown action: ${action}`));
console.log(chalk.gray('Available actions: send, inbox, read, reply, archive, forward, sent, status'));
return 1;
}
}
private getAgentId(): string {
return this.agent || process.env.SKILLKIT_AGENT_ID || 'default-agent';
}
private async sendMessage(): Promise<number> {
const to = this.arg;
if (!to) {
console.error(chalk.red('Error: Recipient is required'));
console.log(chalk.gray('Usage: skillkit message send <to> --body "..."'));
return 1;
}
if (!this.body) {
console.error(chalk.red('Error: Message body is required'));
console.log(chalk.gray('Usage: skillkit message send <to> --body "..."'));
return 1;
}
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
const result = await service.send({
to,
subject: this.subject || 'Message from SkillKit',
body: this.body,
priority: (this.priority as any) || 'normal',
type: (this.type as any) || 'notification',
});
if (result.delivered) {
console.log(chalk.green(`✓ Message sent to ${to}`));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`);
console.log(` Via: ${result.via}`);
} else {
console.error(chalk.red(`✗ Failed to deliver message`));
if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`));
}
return 1;
}
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to send message: ${err.message}`));
return 1;
}
}
private async showInbox(): Promise<number> {
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
const filter: any = {};
if (this.unread) {
filter.status = 'unread';
}
if (this.limit) {
filter.limit = parseInt(this.limit, 10);
}
const messages = await service.getInbox(filter);
if (this.json) {
console.log(JSON.stringify(messages, null, 2));
return 0;
}
const summary = await service.getInboxSummary();
console.log(chalk.bold(`\nInbox (${summary.unread} unread / ${summary.total} total)\n`));
if (messages.length === 0) {
console.log(chalk.gray(' No messages.'));
return 0;
}
for (const message of messages) {
const isUnread = message.status === 'unread';
const priorityIcon = this.getPriorityIcon(message.priority);
const statusIcon = isUnread ? chalk.cyan('●') : chalk.gray('○');
console.log(`${statusIcon} ${priorityIcon} ${isUnread ? chalk.bold(message.subject) : message.subject}`);
console.log(` ID: ${chalk.gray(message.id.slice(0, 8))} | From: ${message.from} | ${this.formatDate(message.createdAt)}`);
if (this.verbose) {
const bodyPreview = typeof message.body === 'string'
? message.body.slice(0, 80)
: JSON.stringify(message.body).slice(0, 80);
console.log(` ${chalk.gray(bodyPreview)}${bodyPreview.length >= 80 ? '...' : ''}`);
}
}
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to show inbox: ${err.message}`));
return 1;
}
}
private async readMessage(): Promise<number> {
const id = this.arg;
if (!id) {
console.error(chalk.red('Error: Message ID is required'));
console.log(chalk.gray('Usage: skillkit message read <id>'));
return 1;
}
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
const message = await service.markAsRead(id);
if (!message) {
const messages = await service.getInbox();
const found = messages.find(m => m.id.startsWith(id));
if (found) {
const marked = await service.markAsRead(found.id);
if (marked) {
return this.displayMessage(marked);
}
}
console.error(chalk.red(`Message not found: ${id}`));
return 1;
}
return this.displayMessage(message);
} catch (err: any) {
console.error(chalk.red(`Failed to read message: ${err.message}`));
return 1;
}
}
private displayMessage(message: any): number {
if (this.json) {
console.log(JSON.stringify(message, null, 2));
return 0;
}
console.log(chalk.bold(`\n${message.subject}\n`));
console.log(`From: ${message.from}`);
console.log(`To: ${message.to}`);
console.log(`Date: ${new Date(message.createdAt).toLocaleString()}`);
console.log(`Priority: ${message.priority}`);
console.log(`Type: ${message.type}`);
console.log(`ID: ${chalk.gray(message.id)}`);
if (message.replyTo) {
console.log(`Reply to: ${chalk.gray(message.replyTo)}`);
}
if (message.threadId) {
console.log(`Thread: ${chalk.gray(message.threadId)}`);
}
console.log(chalk.bold('\nBody:\n'));
if (typeof message.body === 'string') {
console.log(message.body);
} else {
console.log(JSON.stringify(message.body, null, 2));
}
console.log();
return 0;
}
private async replyMessage(): Promise<number> {
const id = this.arg;
if (!id) {
console.error(chalk.red('Error: Message ID is required'));
console.log(chalk.gray('Usage: skillkit message reply <id> --body "..."'));
return 1;
}
if (!this.body) {
console.error(chalk.red('Error: Reply body is required'));
console.log(chalk.gray('Usage: skillkit message reply <id> --body "..."'));
return 1;
}
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
let messageId = id;
const message = await service.getMessage(id);
if (!message) {
const messages = await service.getInbox();
const found = messages.find(m => m.id.startsWith(id));
if (found) {
messageId = found.id;
} else {
console.error(chalk.red(`Message not found: ${id}`));
return 1;
}
}
const result = await service.reply(messageId, this.body);
if (result.delivered) {
console.log(chalk.green('✓ Reply sent'));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`);
} else {
console.error(chalk.red('✗ Failed to send reply'));
if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`));
}
return 1;
}
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to reply: ${err.message}`));
return 1;
}
}
private async archiveMessage(): Promise<number> {
const id = this.arg;
if (!id) {
console.error(chalk.red('Error: Message ID is required'));
console.log(chalk.gray('Usage: skillkit message archive <id>'));
return 1;
}
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
let messageId = id;
const message = await service.getMessage(id);
if (!message) {
const messages = await service.getInbox();
const found = messages.find(m => m.id.startsWith(id));
if (found) {
messageId = found.id;
} else {
console.error(chalk.red(`Message not found: ${id}`));
return 1;
}
}
const archived = await service.archive(messageId);
if (archived) {
console.log(chalk.green('✓ Message archived'));
} else {
console.error(chalk.red('✗ Failed to archive message'));
return 1;
}
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to archive: ${err.message}`));
return 1;
}
}
private async forwardMessage(): Promise<number> {
const id = this.arg;
const to = this.arg2;
if (!id) {
console.error(chalk.red('Error: Message ID is required'));
console.log(chalk.gray('Usage: skillkit message forward <id> <to>'));
return 1;
}
if (!to) {
console.error(chalk.red('Error: Recipient is required'));
console.log(chalk.gray('Usage: skillkit message forward <id> <to>'));
return 1;
}
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
let messageId = id;
const message = await service.getMessage(id);
if (!message) {
const messages = await service.getInbox();
const found = messages.find(m => m.id.startsWith(id));
if (found) {
messageId = found.id;
} else {
console.error(chalk.red(`Message not found: ${id}`));
return 1;
}
}
const result = await service.forward(messageId, to, this.body);
if (result.delivered) {
console.log(chalk.green(`✓ Message forwarded to ${to}`));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`);
} else {
console.error(chalk.red('✗ Failed to forward message'));
if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`));
}
return 1;
}
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to forward: ${err.message}`));
return 1;
}
}
private async showSent(): Promise<number> {
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
const filter: any = {};
if (this.limit) {
filter.limit = parseInt(this.limit, 10);
}
const messages = await service.getSent(filter);
if (this.json) {
console.log(JSON.stringify(messages, null, 2));
return 0;
}
console.log(chalk.bold(`\nSent Messages (${messages.length})\n`));
if (messages.length === 0) {
console.log(chalk.gray(' No sent messages.'));
return 0;
}
for (const message of messages) {
const priorityIcon = this.getPriorityIcon(message.priority);
console.log(`${chalk.gray('○')} ${priorityIcon} ${message.subject}`);
console.log(` ID: ${chalk.gray(message.id.slice(0, 8))} | To: ${message.to} | ${this.formatDate(message.createdAt)}`);
}
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to show sent: ${err.message}`));
return 1;
}
}
private async showStatus(): Promise<number> {
try {
const { createMessagingService } = await import('@skillkit/messaging');
const agentId = this.getAgentId();
const service = await createMessagingService(agentId);
const summary = await service.getInboxSummary();
const sent = await service.getSent({ limit: 1000 });
const archived = await service.getArchived({ limit: 1000 });
if (this.json) {
console.log(JSON.stringify({
agentId,
inbox: summary,
sentCount: sent.length,
archivedCount: archived.length,
}, null, 2));
return 0;
}
console.log(chalk.bold('\nMessaging Status\n'));
console.log(chalk.cyan('Agent:'));
console.log(` ID: ${agentId}`);
console.log();
console.log(chalk.cyan('Inbox:'));
console.log(` Total: ${summary.total}`);
console.log(` Unread: ${summary.unread}`);
console.log(` By priority: urgent=${summary.byPriority.urgent}, high=${summary.byPriority.high}, normal=${summary.byPriority.normal}, low=${summary.byPriority.low}`);
console.log();
console.log(chalk.cyan('Storage:'));
console.log(` Sent: ${sent.length}`);
console.log(` Archived: ${archived.length}`);
console.log();
return 0;
} catch (err: any) {
console.error(chalk.red(`Failed to get status: ${err.message}`));
return 1;
}
}
private getPriorityIcon(priority: string): string {
switch (priority) {
case 'urgent':
return chalk.red('!!!!');
case 'high':
return chalk.yellow('!!!');
case 'normal':
return chalk.gray('!');
case 'low':
return chalk.gray('·');
default:
return '';
}
}
private formatDate(dateStr: string): string {
const date = new Date(dateStr);
const now = new Date();
const diffMs = now.getTime() - date.getTime();
const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
if (diffDays === 0) {
return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
} else if (diffDays === 1) {
return 'Yesterday';
} else if (diffDays < 7) {
return `${diffDays} days ago`;
} else {
return date.toLocaleDateString();
}
}
}
-62
View File
@@ -6,8 +6,6 @@ import {
AgentType as AgentTypeSchema,
generatePrimer,
analyzePrimer,
analyzeGitHistory,
addPattern,
AGENT_CONFIG,
} from '@skillkit/core';
@@ -73,14 +71,6 @@ export class PrimerCommand extends Command {
description: 'Project directory to analyze (default: current directory)',
});
learn = Option.Boolean('--learn,-l', false, {
description: 'Extract learnable patterns from git history',
});
commits = Option.String('--commits', {
description: 'Number of commits to analyze for learning (default: 100)',
});
async execute(): Promise<number> {
const projectPath = resolve(this.directory || process.cwd());
@@ -88,61 +78,9 @@ export class PrimerCommand extends Command {
return this.runAnalysis(projectPath);
}
if (this.learn) {
return this.runLearn(projectPath);
}
return this.runGenerate(projectPath);
}
private async runLearn(projectPath: string): Promise<number> {
console.log(chalk.cyan('Analyzing codebase and extracting patterns...\n'));
const analysis = analyzePrimer(projectPath);
if (this.verbose) {
this.printAnalysis(analysis);
console.log();
}
console.log(chalk.bold('Analyzing git history for patterns...\n'));
const gitResult = analyzeGitHistory(projectPath, {
commits: this.commits ? parseInt(this.commits) : 100,
});
console.log(` Commits analyzed: ${gitResult.commitCount}`);
console.log(` Languages: ${gitResult.languages.join(', ') || 'N/A'}`);
console.log(` Frameworks: ${gitResult.frameworks.join(', ') || 'N/A'}`);
console.log();
if (gitResult.patterns.length === 0) {
console.log(chalk.yellow('No learnable patterns found.'));
return 0;
}
console.log(chalk.bold(`Extracted ${gitResult.patterns.length} patterns:\n`));
for (const pattern of gitResult.patterns.slice(0, 10)) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} [${pattern.category}] ${confidence}`);
addPattern(pattern);
}
if (gitResult.patterns.length > 10) {
console.log(chalk.dim(` ... and ${gitResult.patterns.length - 10} more saved`));
for (const pattern of gitResult.patterns.slice(10)) {
addPattern(pattern);
}
}
console.log();
console.log(chalk.green(`✓ Saved ${gitResult.patterns.length} patterns`));
console.log(chalk.dim('View with: skillkit learn --show'));
console.log(chalk.dim('Approve with: skillkit pattern approve <id>'));
return 0;
}
private async runAnalysis(projectPath: string): Promise<number> {
console.log(chalk.cyan('Analyzing codebase...\n'));
-200
View File
@@ -1,200 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import {
getActiveProfile,
setActiveProfile,
getProfile,
getAllProfiles,
addCustomProfile,
removeCustomProfile,
isBuiltinProfile,
type ProfileName,
type OperationalProfile,
} from '@skillkit/core';
export class ProfileCommand extends Command {
static override paths = [['profile']];
static override usage = Command.Usage({
description: 'Manage operational profiles (dev, review, research modes)',
details: `
Profiles adjust agent behavior for different tasks.
Switch between modes like development, code review, or research.
`,
examples: [
['Show current profile', '$0 profile'],
['Switch to review mode', '$0 profile review'],
['List all profiles', '$0 profile list'],
],
});
name = Option.String({ required: false });
async execute(): Promise<number> {
if (this.name) {
const profile = getProfile(this.name as ProfileName);
if (!profile) {
console.log(chalk.red(`Profile not found: ${this.name}`));
console.log(chalk.dim('Run `skillkit profile list` to see available profiles'));
return 1;
}
setActiveProfile(this.name as ProfileName);
console.log(chalk.green(`✓ Switched to ${profile.name} mode`));
console.log(chalk.dim(` Focus: ${profile.focus}`));
return 0;
}
const active = getActiveProfile();
const profile = getProfile(active);
console.log(chalk.cyan(`Current Profile: ${active}\n`));
if (profile) {
console.log(`Description: ${profile.description}`);
console.log(`Focus: ${profile.focus}`);
console.log();
console.log(chalk.bold('Behaviors:'));
for (const behavior of profile.behaviors) {
console.log(` • ${behavior}`);
}
console.log();
console.log(chalk.bold('Priorities:'));
console.log(` ${profile.priorities.join(' > ')}`);
if (profile.preferredTools?.length) {
console.log();
console.log(chalk.bold('Preferred Tools:'));
console.log(` ${profile.preferredTools.join(', ')}`);
}
if (profile.avoidTools?.length) {
console.log(chalk.bold('Avoid Tools:'));
console.log(` ${profile.avoidTools.join(', ')}`);
}
}
console.log();
console.log(chalk.dim('Switch with: skillkit profile <name>'));
return 0;
}
}
export class ProfileListCommand extends Command {
static override paths = [['profile', 'list'], ['profile', 'ls']];
static override usage = Command.Usage({
description: 'List available profiles',
examples: [['List profiles', '$0 profile list']],
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const profiles = getAllProfiles();
const active = getActiveProfile();
if (this.json) {
console.log(JSON.stringify({ active, profiles }, null, 2));
return 0;
}
console.log(chalk.cyan('Available Profiles:\n'));
for (const profile of profiles) {
const isActive = profile.name === active;
const marker = isActive ? chalk.green('●') : chalk.dim('○');
const name = isActive ? chalk.bold(profile.name) : profile.name;
const type = isBuiltinProfile(profile.name) ? '' : chalk.dim(' (custom)');
console.log(` ${marker} ${name}${type}`);
console.log(` ${chalk.dim(profile.description)}`);
console.log(` Focus: ${profile.focus}`);
console.log();
}
console.log(chalk.dim('Switch with: skillkit profile <name>'));
return 0;
}
}
export class ProfileCreateCommand extends Command {
static override paths = [['profile', 'create']];
static override usage = Command.Usage({
description: 'Create a custom profile',
examples: [
['Create profile', '$0 profile create --name my-profile --description "My custom profile"'],
],
});
name = Option.String('--name,-n', {
description: 'Profile name',
required: true,
});
description = Option.String('--description,-d', {
description: 'Profile description',
required: true,
});
focus = Option.String('--focus,-f', {
description: 'Profile focus',
});
async execute(): Promise<number> {
if (isBuiltinProfile(this.name as ProfileName)) {
console.log(chalk.red(`Cannot create profile: ${this.name} is a built-in profile`));
return 1;
}
const profile: OperationalProfile = {
name: this.name as ProfileName,
description: this.description,
focus: this.focus || this.description,
behaviors: [],
priorities: [],
};
addCustomProfile(profile);
console.log(chalk.green(`✓ Created profile: ${this.name}`));
console.log(chalk.dim('Edit ~/.skillkit/profiles.yaml to customize'));
return 0;
}
}
export class ProfileRemoveCommand extends Command {
static override paths = [['profile', 'remove'], ['profile', 'rm']];
static override usage = Command.Usage({
description: 'Remove a custom profile',
examples: [['Remove profile', '$0 profile remove my-profile']],
});
name = Option.String({ required: true });
async execute(): Promise<number> {
if (isBuiltinProfile(this.name as ProfileName)) {
console.log(chalk.red(`Cannot remove built-in profile: ${this.name}`));
return 1;
}
const removed = removeCustomProfile(this.name as ProfileName);
if (!removed) {
console.log(chalk.yellow(`Profile not found: ${this.name}`));
return 1;
}
console.log(chalk.green(`✓ Removed profile: ${this.name}`));
return 0;
}
}
-321
View File
@@ -1,321 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import {
loadSessionFile,
saveSessionFile,
createSessionFile,
updateSessionFile,
listSessions,
getMostRecentSession,
type SessionFile,
} from '@skillkit/core';
export class SessionCommand extends Command {
static override paths = [['session']];
static override usage = Command.Usage({
description: 'Manage session state for context preservation',
details: `
Sessions track context across coding sessions, allowing you to
preserve state across compactions and session restarts.
`,
examples: [
['Show current session', '$0 session'],
['Start new session', '$0 session start'],
['Load specific date', '$0 session load 2026-01-30'],
],
});
async execute(): Promise<number> {
console.log(chalk.cyan('Session commands:\n'));
console.log(' session status Show current session state');
console.log(' session start Start a new session');
console.log(' session load Load session from specific date');
console.log(' session list List recent sessions');
console.log(' session note Add note to current session');
console.log(' session complete Mark task as completed');
console.log();
return 0;
}
}
export class SessionStatusCommand extends Command {
static override paths = [['session', 'status']];
static override usage = Command.Usage({
description: 'Show current session state',
examples: [['Show status', '$0 session status']],
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const session = getMostRecentSession();
if (!session) {
console.log(chalk.yellow('No active session found'));
console.log(chalk.dim('Start one with: skillkit session start'));
return 0;
}
if (this.json) {
console.log(JSON.stringify(session, null, 2));
return 0;
}
this.printSession(session);
return 0;
}
private printSession(session: SessionFile): void {
console.log(chalk.cyan(`Session: ${session.date}\n`));
console.log(`Agent: ${session.agent}`);
console.log(`Project: ${session.projectPath}`);
console.log(`Started: ${session.startedAt}`);
console.log(`Last Updated: ${session.lastUpdated}`);
console.log();
if (session.completed.length > 0) {
console.log(chalk.green('Completed:'));
for (const task of session.completed) {
console.log(` ${chalk.green('✓')} ${task}`);
}
console.log();
}
if (session.inProgress.length > 0) {
console.log(chalk.yellow('In Progress:'));
for (const task of session.inProgress) {
console.log(` ${chalk.yellow('○')} ${task}`);
}
console.log();
}
if (session.notes.length > 0) {
console.log(chalk.blue('Notes for Next Session:'));
for (const note of session.notes) {
console.log(` ${chalk.dim('•')} ${note}`);
}
console.log();
}
if (session.contextToLoad.length > 0) {
console.log(chalk.dim('Context to Load:'));
for (const ctx of session.contextToLoad) {
console.log(` ${chalk.dim('•')} ${ctx}`);
}
}
}
}
export class SessionStartCommand extends Command {
static override paths = [['session', 'start']];
static override usage = Command.Usage({
description: 'Start a new session',
examples: [
['Start session', '$0 session start'],
['Start with agent', '$0 session start --agent claude-code'],
],
});
agent = Option.String('--agent,-a', {
description: 'AI agent being used',
});
async execute(): Promise<number> {
const agent = this.agent || 'claude-code';
const projectPath = process.cwd();
const session = createSessionFile(agent, projectPath);
const filepath = saveSessionFile(session);
console.log(chalk.green(`✓ Session started: ${session.date}`));
console.log(chalk.dim(` Saved to: ${filepath}`));
return 0;
}
}
export class SessionLoadCommand extends Command {
static override paths = [['session', 'load']];
static override usage = Command.Usage({
description: 'Load session from specific date',
examples: [['Load session', '$0 session load 2026-01-30']],
});
date = Option.String({ required: false });
async execute(): Promise<number> {
const session = this.date ? loadSessionFile(this.date) : getMostRecentSession();
if (!session) {
console.log(chalk.yellow('Session not found'));
return 1;
}
console.log(chalk.green(`✓ Loaded session: ${session.date}`));
console.log();
if (session.notes.length > 0) {
console.log(chalk.cyan('Notes from previous session:'));
for (const note of session.notes) {
console.log(` ${chalk.dim('•')} ${note}`);
}
console.log();
}
if (session.inProgress.length > 0) {
console.log(chalk.yellow('Tasks still in progress:'));
for (const task of session.inProgress) {
console.log(` ${chalk.yellow('○')} ${task}`);
}
console.log();
}
if (session.contextToLoad.length > 0) {
console.log(chalk.dim('Context to load:'));
for (const ctx of session.contextToLoad) {
console.log(` ${ctx}`);
}
}
return 0;
}
}
export class SessionListCommand extends Command {
static override paths = [['session', 'list'], ['session', 'ls']];
static override usage = Command.Usage({
description: 'List recent sessions',
examples: [['List sessions', '$0 session list']],
});
limit = Option.String('--limit,-l', {
description: 'Number of sessions to show (default: 10)',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const limit = this.limit ? parseInt(this.limit) : 10;
const sessions = listSessions(limit);
if (sessions.length === 0) {
console.log(chalk.yellow('No sessions found'));
return 0;
}
if (this.json) {
console.log(JSON.stringify(sessions, null, 2));
return 0;
}
console.log(chalk.cyan(`Recent Sessions (${sessions.length}):\n`));
for (const session of sessions) {
const progress = `${session.completedCount}/${session.taskCount}`;
const notesIndicator = session.hasNotes ? chalk.blue(' [notes]') : '';
console.log(` ${chalk.bold(session.date)} - ${session.agent}`);
console.log(` ${chalk.dim(session.projectPath)}`);
console.log(` Tasks: ${progress}${notesIndicator}`);
console.log();
}
return 0;
}
}
export class SessionNoteCommand extends Command {
static override paths = [['session', 'note']];
static override usage = Command.Usage({
description: 'Add note to current session',
examples: [['Add note', '$0 session note "Remember to test edge cases"']],
});
note = Option.String({ required: true });
async execute(): Promise<number> {
let session = getMostRecentSession();
if (!session) {
session = createSessionFile('claude-code', process.cwd());
}
const updated = updateSessionFile(session, {
notes: [this.note],
});
saveSessionFile(updated);
console.log(chalk.green('✓ Note added'));
return 0;
}
}
export class SessionCompleteCommand extends Command {
static override paths = [['session', 'complete']];
static override usage = Command.Usage({
description: 'Mark task as completed',
examples: [['Mark completed', '$0 session complete "Implemented user auth"']],
});
task = Option.String({ required: true });
async execute(): Promise<number> {
let session = getMostRecentSession();
if (!session) {
session = createSessionFile('claude-code', process.cwd());
}
const updated = updateSessionFile(session, {
completed: [this.task],
});
if (session.inProgress.includes(this.task)) {
updated.inProgress = session.inProgress.filter(t => t !== this.task);
}
saveSessionFile(updated);
console.log(chalk.green(`✓ Completed: ${this.task}`));
return 0;
}
}
export class SessionInProgressCommand extends Command {
static override paths = [['session', 'wip'], ['session', 'progress']];
static override usage = Command.Usage({
description: 'Mark task as in progress',
examples: [['Mark in progress', '$0 session wip "Working on auth flow"']],
});
task = Option.String({ required: true });
async execute(): Promise<number> {
let session = getMostRecentSession();
if (!session) {
session = createSessionFile('claude-code', process.cwd());
}
const updated = updateSessionFile(session, {
inProgress: [...session.inProgress, this.task],
});
saveSessionFile(updated);
console.log(chalk.yellow(`○ In progress: ${this.task}`));
return 0;
}
}
@@ -2,4 +2,3 @@
export { WorkflowRunCommand } from './run.js';
export { WorkflowListCommand } from './list.js';
export { WorkflowCreateCommand } from './create.js';
export { WorkflowPipelineCommand, WorkflowPipelineListCommand } from './pipeline.js';
@@ -1,138 +0,0 @@
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import {
BUILTIN_PIPELINES,
getBuiltinPipeline,
getBuiltinPipelines,
type AgentPipeline,
} from '@skillkit/core';
export class WorkflowPipelineCommand extends Command {
static override paths = [['workflow', 'pipeline']];
static override usage = Command.Usage({
description: 'Run a built-in agent pipeline',
details: `
Pipelines are sequential multi-agent workflows for common development tasks.
Each pipeline runs agents in order, passing context between stages.
`,
examples: [
['Run feature pipeline', '$0 workflow pipeline feature'],
['Run bugfix pipeline', '$0 workflow pipeline bugfix'],
['List available pipelines', '$0 workflow pipeline list'],
],
});
pipeline = Option.String({ required: false });
dryRun = Option.Boolean('--dry-run,-n', false, {
description: 'Show what would be done without executing',
});
async execute(): Promise<number> {
if (!this.pipeline) {
console.log(chalk.cyan('Usage: skillkit workflow pipeline <name>\n'));
console.log('Available pipelines:');
for (const p of BUILTIN_PIPELINES) {
console.log(` ${chalk.bold(p.id)} - ${p.description}`);
}
console.log();
console.log(chalk.dim('Run: skillkit workflow pipeline list for details'));
return 0;
}
const pipeline = getBuiltinPipeline(this.pipeline);
if (!pipeline) {
console.log(chalk.red(`Pipeline not found: ${this.pipeline}`));
console.log(chalk.dim('Run `skillkit workflow pipeline list` to see available pipelines'));
return 1;
}
if (this.dryRun) {
return this.showPipeline(pipeline);
}
return this.runPipeline(pipeline);
}
private showPipeline(pipeline: AgentPipeline): number {
console.log(chalk.cyan(`Pipeline: ${pipeline.name}\n`));
console.log(`Description: ${pipeline.description}`);
console.log();
console.log(chalk.bold('Stages:'));
for (let i = 0; i < pipeline.stages.length; i++) {
const stage = pipeline.stages[i];
const arrow = i < pipeline.stages.length - 1 ? '→' : '';
console.log(` ${i + 1}. ${chalk.bold(stage.name)} (@${stage.agent})`);
console.log(` ${chalk.dim(stage.description)}`);
if (arrow) {
console.log(` ${chalk.dim(arrow)}`);
}
}
console.log();
console.log(chalk.dim('(dry-run mode - no execution)'));
return 0;
}
private async runPipeline(pipeline: AgentPipeline): Promise<number> {
console.log(chalk.cyan(`Starting Pipeline: ${pipeline.name}\n`));
for (let i = 0; i < pipeline.stages.length; i++) {
const stage = pipeline.stages[i];
const stageNum = `[${i + 1}/${pipeline.stages.length}]`;
console.log(`${chalk.blue(stageNum)} ${chalk.bold(stage.name)}`);
console.log(` Agent: @${stage.agent}`);
console.log(` ${chalk.dim(stage.description)}`);
console.log();
console.log(chalk.yellow(` → Invoke @${stage.agent} for: ${stage.description}`));
console.log(chalk.dim(' (Manual agent invocation required in current implementation)'));
console.log();
}
console.log(chalk.green('✓ Pipeline stages displayed'));
console.log(chalk.dim('Execute each stage by invoking the agents in order'));
return 0;
}
}
export class WorkflowPipelineListCommand extends Command {
static override paths = [['workflow', 'pipeline', 'list']];
static override usage = Command.Usage({
description: 'List available pipelines',
examples: [['List pipelines', '$0 workflow pipeline list']],
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
const pipelines = getBuiltinPipelines();
if (this.json) {
console.log(JSON.stringify(pipelines, null, 2));
return 0;
}
console.log(chalk.cyan(`Available Pipelines (${pipelines.length}):\n`));
for (const pipeline of pipelines) {
console.log(chalk.bold(` ${pipeline.id}`));
console.log(` ${pipeline.name}: ${pipeline.description}`);
console.log(` Stages: ${pipeline.stages.map(s => s.name).join(' → ')}`);
console.log();
}
console.log(chalk.dim('Run with: skillkit workflow pipeline <name>'));
return 0;
}
}
+1 -5
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/core",
"version": "1.8.0",
"version": "1.7.9",
"description": "Core functionality for SkillKit - skill discovery, parsing, and translation",
"type": "module",
"main": "./dist/index.js",
@@ -33,10 +33,6 @@
"./recommend": {
"import": "./dist/recommend/index.js",
"types": "./dist/recommend/index.d.ts"
},
"./learning": {
"import": "./dist/learning/index.js",
"types": "./dist/learning/index.d.ts"
}
},
"files": [
-2
View File
@@ -1,2 +0,0 @@
export * from './types.js';
export * from './manager.js';
-309
View File
@@ -1,309 +0,0 @@
import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { homedir } from 'node:os';
import yaml from 'yaml';
import type { Guideline, GuidelineCategory, GuidelineConfig } from './types.js';
import { DEFAULT_GUIDELINE_CONFIG } from './types.js';
const BUILTIN_GUIDELINES: Guideline[] = [
{
id: 'security',
name: 'Security Guidelines',
description: 'Security best practices and vulnerability prevention',
category: 'security',
priority: 10,
enabled: true,
scope: 'global',
content: `## Security Guidelines
### Input Validation
- Validate all user input on the server side
- Use allowlists over denylists when possible
- Sanitize data before use in queries, commands, or output
### Authentication & Authorization
- Never store passwords in plain text
- Use secure session management
- Implement proper authorization checks on every endpoint
- Use HTTPS for all communications
### Data Protection
- Encrypt sensitive data at rest and in transit
- Never log sensitive information
- Use environment variables for secrets
- Implement proper access controls
### Common Vulnerabilities to Prevent
- SQL Injection: Use parameterized queries
- XSS: Encode output, use CSP headers
- CSRF: Use anti-CSRF tokens
- Command Injection: Avoid shell commands with user input`,
},
{
id: 'code-style',
name: 'Code Style Guidelines',
description: 'Code formatting and style conventions',
category: 'code-style',
priority: 7,
enabled: true,
scope: 'global',
content: `## Code Style Guidelines
### Naming Conventions
- Use descriptive, meaningful names
- camelCase for variables and functions
- PascalCase for classes and types
- SCREAMING_SNAKE_CASE for constants
### Code Organization
- One concept per file
- Group related code together
- Keep files under 300 lines when practical
- Use barrel exports (index.ts) for public APIs
### Functions
- Single responsibility principle
- Keep functions under 30 lines when practical
- Use early returns to reduce nesting
- Avoid side effects in pure functions
### Comments
- Don't comment obvious code
- Explain "why" not "what"
- Keep comments up to date
- Use JSDoc for public APIs`,
},
{
id: 'testing',
name: 'Testing Guidelines',
description: 'Testing best practices and coverage requirements',
category: 'testing',
priority: 8,
enabled: true,
scope: 'global',
content: `## Testing Guidelines
### Test Coverage
- Aim for 80%+ code coverage
- 100% coverage for critical paths
- Don't sacrifice quality for coverage metrics
### Test Structure
- Arrange, Act, Assert (AAA) pattern
- One concept per test
- Descriptive test names that explain behavior
- Independent tests (no shared state)
### Test Types
- Unit tests for business logic
- Integration tests for component interactions
- E2E tests for critical user flows
### Test Quality
- Tests should be deterministic
- Fast execution (< 100ms for unit tests)
- Easy to understand and maintain
- Test behavior, not implementation`,
},
{
id: 'git',
name: 'Git Workflow Guidelines',
description: 'Version control best practices',
category: 'git',
priority: 6,
enabled: true,
scope: 'global',
content: `## Git Workflow Guidelines
### Commits
- Write clear, concise commit messages
- Use conventional commits format
- One logical change per commit
- Don't commit generated files or secrets
### Branches
- Use feature branches
- Keep branches short-lived
- Delete branches after merge
- Protect main/master branch
### Pull Requests
- Keep PRs focused and small
- Write meaningful descriptions
- Request reviews from appropriate people
- Address all review comments
### Commit Message Format
\`\`\`
<type>(<scope>): <description>
[optional body]
[optional footer]
\`\`\`
Types: feat, fix, docs, style, refactor, test, chore`,
},
{
id: 'performance',
name: 'Performance Guidelines',
description: 'Performance optimization best practices',
category: 'performance',
priority: 5,
enabled: false,
scope: 'global',
content: `## Performance Guidelines
### General Principles
- Measure before optimizing
- Optimize critical paths first
- Consider time/space tradeoffs
- Profile in production-like environments
### Database
- Use indexes appropriately
- Avoid N+1 queries
- Paginate large result sets
- Cache frequently accessed data
### Frontend
- Minimize bundle size
- Lazy load when appropriate
- Optimize images and assets
- Use efficient rendering patterns
### Backend
- Use connection pooling
- Implement appropriate caching
- Async operations where beneficial
- Monitor and alert on performance`,
},
];
function getConfigPath(): string {
return join(homedir(), '.skillkit', 'guidelines.yaml');
}
export function loadGuidelineConfig(): GuidelineConfig {
const path = getConfigPath();
if (!existsSync(path)) {
return DEFAULT_GUIDELINE_CONFIG;
}
try {
const content = readFileSync(path, 'utf-8');
return { ...DEFAULT_GUIDELINE_CONFIG, ...yaml.parse(content) };
} catch {
return DEFAULT_GUIDELINE_CONFIG;
}
}
export function saveGuidelineConfig(config: GuidelineConfig): void {
const path = getConfigPath();
const dir = dirname(path);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
writeFileSync(path, yaml.stringify(config));
}
export function getGuideline(id: string): Guideline | null {
const builtin = BUILTIN_GUIDELINES.find(g => g.id === id);
if (builtin) return builtin;
const config = loadGuidelineConfig();
return config.customGuidelines.find(g => g.id === id) || null;
}
export function getAllGuidelines(): Guideline[] {
const config = loadGuidelineConfig();
return [...BUILTIN_GUIDELINES, ...config.customGuidelines];
}
export function getBuiltinGuidelines(): Guideline[] {
return BUILTIN_GUIDELINES;
}
export function getEnabledGuidelines(): Guideline[] {
const config = loadGuidelineConfig();
const all = getAllGuidelines();
return all.filter(g => config.enabledGuidelines.includes(g.id));
}
export function getGuidelinesByCategory(category: GuidelineCategory): Guideline[] {
return getAllGuidelines().filter(g => g.category === category);
}
export function enableGuideline(id: string): boolean {
const guideline = getGuideline(id);
if (!guideline) return false;
const config = loadGuidelineConfig();
if (!config.enabledGuidelines.includes(id)) {
config.enabledGuidelines.push(id);
saveGuidelineConfig(config);
}
return true;
}
export function disableGuideline(id: string): boolean {
const config = loadGuidelineConfig();
const index = config.enabledGuidelines.indexOf(id);
if (index < 0) return false;
config.enabledGuidelines.splice(index, 1);
saveGuidelineConfig(config);
return true;
}
export function isGuidelineEnabled(id: string): boolean {
const config = loadGuidelineConfig();
return config.enabledGuidelines.includes(id);
}
export function addCustomGuideline(guideline: Guideline): void {
const config = loadGuidelineConfig();
const existing = config.customGuidelines.findIndex(g => g.id === guideline.id);
if (existing >= 0) {
config.customGuidelines[existing] = guideline;
} else {
config.customGuidelines.push(guideline);
}
saveGuidelineConfig(config);
}
export function removeCustomGuideline(id: string): boolean {
const config = loadGuidelineConfig();
const index = config.customGuidelines.findIndex(g => g.id === id);
if (index < 0) return false;
config.customGuidelines.splice(index, 1);
config.enabledGuidelines = config.enabledGuidelines.filter(g => g !== id);
saveGuidelineConfig(config);
return true;
}
export function getGuidelineContent(id: string): string | null {
const guideline = getGuideline(id);
return guideline?.content || null;
}
export function getEnabledGuidelineContent(): string {
const enabled = getEnabledGuidelines();
return enabled.map(g => g.content).join('\n\n---\n\n');
}
export function isBuiltinGuideline(id: string): boolean {
return BUILTIN_GUIDELINES.some(g => g.id === id);
}
-22
View File
@@ -1,22 +0,0 @@
export type GuidelineCategory = 'security' | 'code-style' | 'testing' | 'git' | 'performance' | 'custom';
export interface Guideline {
id: string;
name: string;
description: string;
category: GuidelineCategory;
content: string;
priority: number;
enabled: boolean;
scope: 'global' | 'project';
}
export interface GuidelineConfig {
enabledGuidelines: string[];
customGuidelines: Guideline[];
}
export const DEFAULT_GUIDELINE_CONFIG: GuidelineConfig = {
enabledGuidelines: ['security', 'code-style', 'testing', 'git'],
customGuidelines: [],
};
-9
View File
@@ -80,12 +80,3 @@ export * from './quality/index.js';
// Primer (AI Instruction Generator)
export * from './primer/index.js';
// Pattern Learning System
export * from './learning/index.js';
// Operational Profiles
export * from './profiles/index.js';
// Coding Guidelines System
export * from './guidelines/index.js';
-134
View File
@@ -1,134 +0,0 @@
import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { homedir } from 'node:os';
import yaml from 'yaml';
import type { LearningConfig, PatternStore, LearnedPattern, EvolvingPattern } from './types.js';
import { DEFAULT_LEARNING_CONFIG } from './types.js';
export function getDefaultConfigPath(): string {
return join(homedir(), '.skillkit', 'learning.yaml');
}
export function getDefaultStorePath(): string {
return join(homedir(), '.skillkit', 'learned', 'patterns.json');
}
export function loadLearningConfig(configPath?: string): LearningConfig {
const path = configPath || getDefaultConfigPath();
if (!existsSync(path)) {
return DEFAULT_LEARNING_CONFIG;
}
try {
const content = readFileSync(path, 'utf-8');
const config = yaml.parse(content);
return { ...DEFAULT_LEARNING_CONFIG, ...config };
} catch {
return DEFAULT_LEARNING_CONFIG;
}
}
export function saveLearningConfig(config: LearningConfig, configPath?: string): void {
const path = configPath || getDefaultConfigPath();
const dir = dirname(path);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
const content = yaml.stringify(config);
writeFileSync(path, content);
}
export function loadPatternStore(storePath?: string): PatternStore {
const path = storePath || getDefaultStorePath();
if (!existsSync(path)) {
return {
version: 1,
updatedAt: new Date().toISOString(),
patterns: [],
evolvingPatterns: [],
};
}
try {
const content = readFileSync(path, 'utf-8');
return JSON.parse(content);
} catch {
return {
version: 1,
updatedAt: new Date().toISOString(),
patterns: [],
evolvingPatterns: [],
};
}
}
export function savePatternStore(store: PatternStore, storePath?: string): void {
const path = storePath || getDefaultStorePath();
const dir = dirname(path);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
store.updatedAt = new Date().toISOString();
const content = JSON.stringify(store, null, 2);
writeFileSync(path, content);
}
export function addPattern(
pattern: LearnedPattern,
storePath?: string
): PatternStore {
const store = loadPatternStore(storePath);
const existingIndex = store.patterns.findIndex(p => p.id === pattern.id);
if (existingIndex >= 0) {
store.patterns[existingIndex] = pattern;
} else {
store.patterns.push(pattern);
}
savePatternStore(store, storePath);
return store;
}
export function removePattern(patternId: string, storePath?: string): PatternStore {
const store = loadPatternStore(storePath);
store.patterns = store.patterns.filter(p => p.id !== patternId);
store.evolvingPatterns = store.evolvingPatterns.filter(p => p.id !== patternId);
savePatternStore(store, storePath);
return store;
}
export function getPattern(patternId: string, storePath?: string): LearnedPattern | null {
const store = loadPatternStore(storePath);
return store.patterns.find(p => p.id === patternId) || null;
}
export function getEvolvingPattern(patternId: string, storePath?: string): EvolvingPattern | null {
const store = loadPatternStore(storePath);
return store.evolvingPatterns.find(p => p.id === patternId) || null;
}
export function getAllPatterns(storePath?: string): LearnedPattern[] {
const store = loadPatternStore(storePath);
return store.patterns;
}
export function getPatternsByCategory(
category: string,
storePath?: string
): LearnedPattern[] {
const store = loadPatternStore(storePath);
return store.patterns.filter(p => p.category === category);
}
export function getApprovedPatterns(storePath?: string): LearnedPattern[] {
const store = loadPatternStore(storePath);
return store.patterns.filter(p => p.approved);
}
-336
View File
@@ -1,336 +0,0 @@
import type {
LearnedPattern,
PatternCategory,
PatternExtractionResult,
} from './types.js';
export interface SessionMessage {
role: 'user' | 'assistant' | 'system';
content: string;
timestamp?: string;
}
export interface SessionContext {
messages: SessionMessage[];
projectPath: string;
startTime: string;
endTime?: string;
}
export function extractPatternsFromSession(
session: SessionContext
): PatternExtractionResult {
const patterns: LearnedPattern[] = [];
const skipped: { reason: string; commit?: string }[] = [];
const errors: string[] = [];
if (session.messages.length < 5) {
skipped.push({ reason: 'Session too short for pattern extraction' });
return { patterns, skipped, errors };
}
try {
const errorFixPatterns = findErrorFixPatterns(session);
patterns.push(...errorFixPatterns);
const workaroundPatterns = findWorkaroundPatterns(session);
patterns.push(...workaroundPatterns);
const conventionPatterns = findConventionPatterns(session);
patterns.push(...conventionPatterns);
const debuggingPatterns = findDebuggingPatterns(session);
patterns.push(...debuggingPatterns);
} catch (error) {
errors.push(error instanceof Error ? error.message : 'Unknown extraction error');
}
return { patterns, skipped, errors };
}
function findErrorFixPatterns(session: SessionContext): LearnedPattern[] {
const patterns: LearnedPattern[] = [];
const messages = session.messages;
for (let i = 0; i < messages.length - 1; i++) {
const current = messages[i];
const next = messages[i + 1];
if (isErrorDescription(current.content) && isSolution(next.content)) {
const pattern = createPatternFromErrorFix(
current.content,
next.content,
session,
i
);
if (pattern) {
patterns.push(pattern);
}
}
}
return patterns;
}
function findWorkaroundPatterns(session: SessionContext): LearnedPattern[] {
const patterns: LearnedPattern[] = [];
const messages = session.messages;
const workaroundKeywords = [
'workaround',
'instead of',
'alternative',
'hack',
'temporary fix',
'for now',
'until',
];
for (let i = 0; i < messages.length; i++) {
const message = messages[i];
if (message.role !== 'assistant') continue;
const content = message.content.toLowerCase();
if (workaroundKeywords.some(kw => content.includes(kw))) {
const problem = findPrecedingProblem(messages, i);
if (problem) {
const pattern = createPattern(
'workaround',
problem,
message.content,
session,
i
);
if (pattern) {
patterns.push(pattern);
}
}
}
}
return patterns;
}
function findConventionPatterns(session: SessionContext): LearnedPattern[] {
const patterns: LearnedPattern[] = [];
const messages = session.messages;
const conventionKeywords = [
'naming convention',
'pattern we use',
'standard',
'best practice',
'we always',
'convention',
'style guide',
];
for (let i = 0; i < messages.length; i++) {
const message = messages[i];
if (message.role !== 'assistant') continue;
const content = message.content.toLowerCase();
if (conventionKeywords.some(kw => content.includes(kw))) {
const pattern = createPattern(
'convention',
'Project convention discovered',
message.content,
session,
i
);
if (pattern) {
patterns.push(pattern);
}
}
}
return patterns;
}
function findDebuggingPatterns(session: SessionContext): LearnedPattern[] {
const patterns: LearnedPattern[] = [];
const messages = session.messages;
const debugKeywords = [
'to debug this',
'debugging',
'to find the issue',
'trace',
'breakpoint',
'logging',
'to diagnose',
];
for (let i = 0; i < messages.length; i++) {
const message = messages[i];
if (message.role !== 'assistant') continue;
const content = message.content.toLowerCase();
if (debugKeywords.some(kw => content.includes(kw))) {
const problem = findPrecedingProblem(messages, i);
if (problem) {
const pattern = createPattern(
'debugging',
problem,
message.content,
session,
i
);
if (pattern) {
patterns.push(pattern);
}
}
}
}
return patterns;
}
function isErrorDescription(content: string): boolean {
const errorKeywords = [
'error',
'fail',
'exception',
'crash',
'not working',
'broken',
'bug',
'issue',
'problem',
'does not',
"doesn't",
"can't",
'cannot',
];
const lower = content.toLowerCase();
return errorKeywords.some(kw => lower.includes(kw));
}
function isSolution(content: string): boolean {
const solutionKeywords = [
'fix',
'solution',
'resolve',
'change',
'update',
'modify',
'replace',
'should be',
'try this',
'use instead',
];
const lower = content.toLowerCase();
return solutionKeywords.some(kw => lower.includes(kw));
}
function findPrecedingProblem(
messages: SessionMessage[],
currentIndex: number
): string | null {
for (let i = currentIndex - 1; i >= 0 && i > currentIndex - 5; i--) {
const message = messages[i];
if (message.role === 'user' && message.content.length > 20) {
return message.content;
}
}
return null;
}
function createPatternFromErrorFix(
errorDescription: string,
solution: string,
session: SessionContext,
messageIndex: number
): LearnedPattern | null {
return createPattern('error_fix', errorDescription, solution, session, messageIndex);
}
function createPattern(
category: PatternCategory,
problem: string,
solution: string,
session: SessionContext,
messageIndex: number
): LearnedPattern | null {
if (problem.length < 20 || solution.length < 20) {
return null;
}
const id = `session-${Date.now()}-${messageIndex}`;
const title = extractTitle(problem, category);
return {
id,
category,
title,
problem: truncate(problem, 500),
solution: truncate(solution, 1000),
context: session.projectPath,
extractedAt: new Date().toISOString(),
source: 'session',
approved: false,
confidence: calculateSessionConfidence(problem, solution, session),
};
}
function extractTitle(problem: string, category: PatternCategory): string {
const firstSentence = problem.split(/[.!?]/)[0].trim();
if (firstSentence.length > 80) {
return `${category.charAt(0).toUpperCase() + category.slice(1).replace('_', ' ')} pattern`;
}
return firstSentence;
}
function truncate(str: string, maxLen: number): string {
if (str.length <= maxLen) return str;
return str.slice(0, maxLen - 3) + '...';
}
function calculateSessionConfidence(
problem: string,
solution: string,
_session: SessionContext
): number {
let confidence = 0.4;
if (problem.length > 50 && problem.length < 500) {
confidence += 0.1;
}
if (solution.length > 100 && solution.length < 1000) {
confidence += 0.1;
}
if (solution.includes('```')) {
confidence += 0.15;
}
return Math.min(0.85, confidence);
}
export function mergePatterns(
existing: LearnedPattern[],
newPatterns: LearnedPattern[]
): LearnedPattern[] {
const merged = [...existing];
for (const pattern of newPatterns) {
const existingIndex = merged.findIndex(p =>
p.problem === pattern.problem || p.id === pattern.id
);
if (existingIndex >= 0) {
if (pattern.confidence > merged[existingIndex].confidence) {
merged[existingIndex] = pattern;
}
} else {
merged.push(pattern);
}
}
return merged;
}
-248
View File
@@ -1,248 +0,0 @@
import type { LearnedPattern, EvolvingPattern, PatternStore, PatternDomain } from './types.js';
import { loadPatternStore, savePatternStore } from './config.js';
export interface FeedbackResult {
pattern: EvolvingPattern;
previousConfidence: number;
newConfidence: number;
change: 'increased' | 'decreased' | 'unchanged';
}
export function recordSuccess(
patternId: string,
storePath?: string
): FeedbackResult | null {
const store = loadPatternStore(storePath);
const evolving = findOrCreateEvolvingPattern(store, patternId);
if (!evolving) return null;
const previousConfidence = evolving.confidence;
evolving.useCount++;
evolving.successCount++;
evolving.lastUsed = new Date().toISOString();
evolving.confidence = Math.min(0.95, evolving.confidence + 0.05);
updateEvolvingPattern(store, evolving);
savePatternStore(store, storePath);
return {
pattern: evolving,
previousConfidence,
newConfidence: evolving.confidence,
change: 'increased',
};
}
export function recordFailure(
patternId: string,
storePath?: string
): FeedbackResult | null {
const store = loadPatternStore(storePath);
const evolving = findOrCreateEvolvingPattern(store, patternId);
if (!evolving) return null;
const previousConfidence = evolving.confidence;
evolving.useCount++;
evolving.failureCount++;
evolving.lastUsed = new Date().toISOString();
evolving.confidence = Math.max(0.1, evolving.confidence - 0.1);
updateEvolvingPattern(store, evolving);
savePatternStore(store, storePath);
return {
pattern: evolving,
previousConfidence,
newConfidence: evolving.confidence,
change: 'decreased',
};
}
function findOrCreateEvolvingPattern(
store: PatternStore,
patternId: string
): EvolvingPattern | null {
let evolving = store.evolvingPatterns.find(p => p.id === patternId);
if (!evolving) {
const basePattern = store.patterns.find(p => p.id === patternId);
if (!basePattern) return null;
evolving = {
...basePattern,
trigger: inferTrigger(basePattern),
action: inferAction(basePattern),
useCount: 0,
successCount: 0,
failureCount: 0,
};
store.evolvingPatterns.push(evolving);
}
return evolving;
}
function updateEvolvingPattern(
store: PatternStore,
evolving: EvolvingPattern
): void {
const index = store.evolvingPatterns.findIndex(p => p.id === evolving.id);
if (index >= 0) {
store.evolvingPatterns[index] = evolving;
} else {
store.evolvingPatterns.push(evolving);
}
}
function inferTrigger(pattern: LearnedPattern): string {
const problem = pattern.problem.toLowerCase();
if (problem.includes('error') || problem.includes('exception')) {
return 'When encountering similar errors';
}
if (problem.includes('build') || problem.includes('compile')) {
return 'During build/compilation issues';
}
if (problem.includes('test')) {
return 'When tests fail in similar ways';
}
return `When facing: ${pattern.title}`;
}
function inferAction(pattern: LearnedPattern): string {
return pattern.solution.split('\n')[0] || 'Apply learned solution';
}
export function getEvolvingPatternsByDomain(
domain: PatternDomain,
storePath?: string
): EvolvingPattern[] {
const store = loadPatternStore(storePath);
return store.evolvingPatterns.filter(p => p.domain === domain);
}
export function getHighConfidencePatterns(
minConfidence = 0.7,
storePath?: string
): EvolvingPattern[] {
const store = loadPatternStore(storePath);
return store.evolvingPatterns
.filter(p => p.confidence >= minConfidence)
.sort((a, b) => b.confidence - a.confidence);
}
export function getLowConfidencePatterns(
maxConfidence = 0.3,
storePath?: string
): EvolvingPattern[] {
const store = loadPatternStore(storePath);
return store.evolvingPatterns
.filter(p => p.confidence <= maxConfidence)
.sort((a, b) => a.confidence - b.confidence);
}
export function getMostUsedPatterns(
limit = 10,
storePath?: string
): EvolvingPattern[] {
const store = loadPatternStore(storePath);
return store.evolvingPatterns
.sort((a, b) => b.useCount - a.useCount)
.slice(0, limit);
}
export function getPatternStats(storePath?: string): {
total: number;
byDomain: Map<string, number>;
byConfidenceRange: { high: number; medium: number; low: number };
mostUsed: EvolvingPattern | null;
leastConfident: EvolvingPattern | null;
} {
const store = loadPatternStore(storePath);
const patterns = store.evolvingPatterns;
const byDomain = new Map<string, number>();
let high = 0, medium = 0, low = 0;
for (const pattern of patterns) {
const domain = pattern.domain || 'unknown';
byDomain.set(domain, (byDomain.get(domain) || 0) + 1);
if (pattern.confidence >= 0.7) high++;
else if (pattern.confidence >= 0.4) medium++;
else low++;
}
const mostUsed = patterns.length > 0
? patterns.reduce((max, p) => p.useCount > max.useCount ? p : max)
: null;
const leastConfident = patterns.length > 0
? patterns.reduce((min, p) => p.confidence < min.confidence ? p : min)
: null;
return {
total: patterns.length,
byDomain,
byConfidenceRange: { high, medium, low },
mostUsed,
leastConfident,
};
}
export function approvePattern(
patternId: string,
storePath?: string
): LearnedPattern | null {
const store = loadPatternStore(storePath);
const pattern = store.patterns.find(p => p.id === patternId);
if (!pattern) return null;
pattern.approved = true;
savePatternStore(store, storePath);
return pattern;
}
export function rejectPattern(
patternId: string,
storePath?: string
): boolean {
const store = loadPatternStore(storePath);
const index = store.patterns.findIndex(p => p.id === patternId);
if (index < 0) return false;
store.patterns.splice(index, 1);
const evolvingIndex = store.evolvingPatterns.findIndex(p => p.id === patternId);
if (evolvingIndex >= 0) {
store.evolvingPatterns.splice(evolvingIndex, 1);
}
savePatternStore(store, storePath);
return true;
}
export function clusterPatterns(
patterns: LearnedPattern[]
): Map<string, LearnedPattern[]> {
const clusters = new Map<string, LearnedPattern[]>();
for (const pattern of patterns) {
const key = pattern.category;
if (!clusters.has(key)) {
clusters.set(key, []);
}
clusters.get(key)!.push(pattern);
}
return clusters;
}
-237
View File
@@ -1,237 +0,0 @@
import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { LearnedPattern, PatternCategory } from './types.js';
export interface LearnedSkillOutput {
id: string;
name: string;
filename: string;
content: string;
patterns: LearnedPattern[];
}
export interface PatternGenerateOptions {
outputDir?: string;
minConfidence?: number;
minPatterns?: number;
format?: 'skill' | 'markdown' | 'json';
}
export function generateSkillFromPatterns(
patterns: LearnedPattern[],
options: PatternGenerateOptions = {}
): LearnedSkillOutput | null {
const minConfidence = options.minConfidence ?? 0.5;
const minPatterns = options.minPatterns ?? 1;
const eligiblePatterns = patterns.filter(p => p.confidence >= minConfidence);
if (eligiblePatterns.length < minPatterns) {
return null;
}
const category = getMostCommonCategory(eligiblePatterns);
const id = `learned-${category}-${Date.now()}`;
const name = formatSkillName(category, eligiblePatterns);
const content = generateSkillContent(name, eligiblePatterns, category);
const filename = `${id}.md`;
return {
id,
name,
filename,
content,
patterns: eligiblePatterns,
};
}
function getMostCommonCategory(patterns: LearnedPattern[]): PatternCategory {
const counts = new Map<PatternCategory, number>();
for (const pattern of patterns) {
counts.set(pattern.category, (counts.get(pattern.category) || 0) + 1);
}
let maxCategory: PatternCategory = 'error_fix';
let maxCount = 0;
for (const [category, count] of counts) {
if (count > maxCount) {
maxCount = count;
maxCategory = category;
}
}
return maxCategory;
}
function formatSkillName(
category: PatternCategory,
patterns: LearnedPattern[]
): string {
const categoryNames: Record<PatternCategory, string> = {
error_fix: 'Error Fixes',
refactor: 'Refactoring Patterns',
workaround: 'Workarounds',
debugging: 'Debugging Techniques',
convention: 'Project Conventions',
};
const baseName = categoryNames[category];
const context = patterns[0]?.context || 'Project';
return `${baseName} - ${context}`;
}
function generateSkillContent(
name: string,
patterns: LearnedPattern[],
category: PatternCategory
): string {
const lines: string[] = [];
lines.push('---');
lines.push(`name: ${name.toLowerCase().replace(/\s+/g, '-')}`);
lines.push(`description: Learned ${category.replace('_', ' ')} patterns from project history`);
lines.push(`category: learned`);
lines.push(`source: automated`);
lines.push(`generated: ${new Date().toISOString()}`);
lines.push(`pattern_count: ${patterns.length}`);
lines.push('---');
lines.push('');
lines.push(`# ${name}`);
lines.push('');
lines.push('> This skill was automatically generated from learned patterns.');
lines.push('');
lines.push('## Patterns');
lines.push('');
for (const pattern of patterns) {
lines.push(`### ${pattern.title}`);
lines.push('');
lines.push(`**Category:** ${pattern.category.replace('_', ' ')}`);
lines.push(`**Confidence:** ${(pattern.confidence * 100).toFixed(0)}%`);
lines.push('');
lines.push('**Problem:**');
lines.push(pattern.problem);
lines.push('');
lines.push('**Solution:**');
lines.push(pattern.solution);
lines.push('');
if (pattern.example) {
lines.push('**Example:**');
lines.push('```');
lines.push(pattern.example);
lines.push('```');
lines.push('');
}
lines.push('---');
lines.push('');
}
return lines.join('\n');
}
export function saveGeneratedSkill(
skill: LearnedSkillOutput,
outputDir?: string
): string {
const dir = outputDir || join(homedir(), '.skillkit', 'skills', 'learned');
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
const filepath = join(dir, skill.filename);
writeFileSync(filepath, skill.content);
return filepath;
}
export function generatePatternReport(patterns: LearnedPattern[]): string {
const lines: string[] = [];
lines.push('# Learned Patterns Report');
lines.push('');
lines.push(`Generated: ${new Date().toISOString()}`);
lines.push(`Total Patterns: ${patterns.length}`);
lines.push('');
const byCategory = new Map<PatternCategory, LearnedPattern[]>();
for (const pattern of patterns) {
if (!byCategory.has(pattern.category)) {
byCategory.set(pattern.category, []);
}
byCategory.get(pattern.category)!.push(pattern);
}
lines.push('## Summary by Category');
lines.push('');
lines.push('| Category | Count | Avg Confidence |');
lines.push('|----------|-------|----------------|');
for (const [category, catPatterns] of byCategory) {
const avgConfidence = catPatterns.reduce((sum, p) => sum + p.confidence, 0) / catPatterns.length;
lines.push(`| ${category.replace('_', ' ')} | ${catPatterns.length} | ${(avgConfidence * 100).toFixed(0)}% |`);
}
lines.push('');
lines.push('## Patterns');
lines.push('');
const approved = patterns.filter(p => p.approved);
const pending = patterns.filter(p => !p.approved);
if (approved.length > 0) {
lines.push('### Approved Patterns');
lines.push('');
for (const pattern of approved) {
lines.push(`- **${pattern.title}** (${pattern.category}, ${(pattern.confidence * 100).toFixed(0)}%)`);
}
lines.push('');
}
if (pending.length > 0) {
lines.push('### Pending Approval');
lines.push('');
for (const pattern of pending) {
lines.push(`- **${pattern.title}** (${pattern.category}, ${(pattern.confidence * 100).toFixed(0)}%)`);
}
lines.push('');
}
return lines.join('\n');
}
export function exportPatternsAsJson(patterns: LearnedPattern[]): string {
return JSON.stringify(
{
version: 1,
exportedAt: new Date().toISOString(),
count: patterns.length,
patterns,
},
null,
2
);
}
export function importPatternsFromJson(jsonContent: string): LearnedPattern[] {
try {
const data = JSON.parse(jsonContent);
if (Array.isArray(data.patterns)) {
return data.patterns;
}
if (Array.isArray(data)) {
return data;
}
return [];
} catch {
return [];
}
}
-356
View File
@@ -1,356 +0,0 @@
import { execSync } from 'node:child_process';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import type {
GitCommit,
GitFileChange,
GitAnalysisResult,
GitAnalysisSummary,
LearnedPattern,
PatternCategory,
} from './types.js';
export interface GitAnalysisOptions {
commits?: number;
since?: string;
until?: string;
branch?: string;
author?: string;
}
function runGitCommand(command: string, cwd: string): string {
try {
return execSync(command, { cwd, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
} catch {
return '';
}
}
function isGitRepository(path: string): boolean {
return existsSync(join(path, '.git'));
}
export function getGitCommits(
repoPath: string,
options: GitAnalysisOptions = {}
): GitCommit[] {
if (!isGitRepository(repoPath)) {
return [];
}
const limit = options.commits || 100;
const args: string[] = [
'log',
`--max-count=${limit}`,
'--format=%H|||%h|||%an|||%aI|||%s|||%b|||END_COMMIT',
'--name-status',
];
if (options.since) {
args.push(`--since="${options.since}"`);
}
if (options.until) {
args.push(`--until="${options.until}"`);
}
if (options.branch) {
args.push(options.branch);
}
if (options.author) {
args.push(`--author="${options.author}"`);
}
const output = runGitCommand(`git ${args.join(' ')}`, repoPath);
if (!output) return [];
const commits: GitCommit[] = [];
const commitBlocks = output.split('END_COMMIT').filter(b => b.trim());
for (const block of commitBlocks) {
const lines = block.trim().split('\n');
if (lines.length === 0) continue;
const headerLine = lines[0];
const parts = headerLine.split('|||');
if (parts.length < 5) continue;
const [hash, shortHash, author, date, message, body] = parts;
const files: GitFileChange[] = [];
for (let i = 1; i < lines.length; i++) {
const line = lines[i].trim();
if (!line) continue;
const match = line.match(/^([AMDRT])\d*\t(.+?)(?:\t(.+))?$/);
if (match) {
const [, status, path, oldPath] = match;
files.push({
path,
status: parseFileStatus(status),
additions: 0,
deletions: 0,
oldPath: oldPath || undefined,
});
}
}
commits.push({
hash,
shortHash,
author,
date,
message,
body: body || undefined,
files,
});
}
return commits;
}
function parseFileStatus(status: string): GitFileChange['status'] {
switch (status) {
case 'A': return 'added';
case 'D': return 'deleted';
case 'R': return 'renamed';
default: return 'modified';
}
}
function categorizeCommit(message: string, body?: string): PatternCategory | null {
const text = `${message} ${body || ''}`.toLowerCase();
if (text.includes('fix') || text.includes('bug') || text.includes('error') || text.includes('issue')) {
return 'error_fix';
}
if (text.includes('refactor') || text.includes('clean') || text.includes('simplify')) {
return 'refactor';
}
if (text.includes('workaround') || text.includes('hack') || text.includes('temporary')) {
return 'workaround';
}
if (text.includes('debug') || text.includes('log') || text.includes('trace')) {
return 'debugging';
}
return null;
}
function shouldSkipCommit(commit: GitCommit, ignorePatterns: string[]): boolean {
const message = commit.message.toLowerCase();
for (const pattern of ignorePatterns) {
if (message.includes(pattern.toLowerCase())) {
return true;
}
}
if (message.startsWith('merge ') || message.startsWith('wip')) {
return true;
}
if (commit.files.length === 0) {
return true;
}
return false;
}
function extractPatternFromCommit(commit: GitCommit): LearnedPattern | null {
const category = categorizeCommit(commit.message, commit.body);
if (!category) return null;
const id = `git-${commit.shortHash}`;
const title = formatTitle(commit.message);
const problem = extractProblem(commit);
const solution = extractSolution(commit);
const context = extractContext(commit);
if (!problem || !solution) return null;
return {
id,
category,
title,
problem,
solution,
context,
extractedAt: new Date().toISOString(),
source: 'git',
commitRange: { from: commit.hash, to: commit.hash },
approved: false,
confidence: calculateConfidence(commit, category),
};
}
function formatTitle(message: string): string {
return message.charAt(0).toUpperCase() + message.slice(1);
}
function extractProblem(commit: GitCommit): string {
const message = commit.message.toLowerCase();
if (message.includes('fix:') || message.includes('fix(')) {
const match = commit.message.match(/fix[:(]\s*([^)]+)/i);
if (match) {
return `Issue: ${match[1]}`;
}
}
if (commit.body) {
const problemMatch = commit.body.match(/problem:?\s*(.+)/i);
if (problemMatch) {
return problemMatch[1].trim();
}
}
return `${commit.message} (from commit ${commit.shortHash})`;
}
function extractSolution(commit: GitCommit): string {
if (commit.body) {
const solutionMatch = commit.body.match(/solution:?\s*(.+)/i);
if (solutionMatch) {
return solutionMatch[1].trim();
}
}
const files = commit.files.map(f => f.path).join(', ');
return `Modified: ${files}`;
}
function extractContext(commit: GitCommit): string {
const files = commit.files;
const extensions = new Set(files.map(f => f.path.split('.').pop() || ''));
const directories = new Set(files.map(f => f.path.split('/')[0]));
const parts: string[] = [];
if (extensions.size > 0) {
parts.push(`Files: ${Array.from(extensions).filter(e => e).join(', ')}`);
}
if (directories.size > 0 && directories.size <= 3) {
parts.push(`Areas: ${Array.from(directories).join(', ')}`);
}
return parts.join('. ') || 'General codebase';
}
function calculateConfidence(commit: GitCommit, category: PatternCategory): number {
let confidence = 0.5;
if (commit.body && commit.body.length > 50) {
confidence += 0.1;
}
if (commit.message.match(/^(fix|feat|refactor|docs|test|chore)(\(.+\))?:/)) {
confidence += 0.1;
}
if (commit.files.length > 0 && commit.files.length < 10) {
confidence += 0.1;
}
if (category === 'error_fix' || category === 'workaround') {
confidence += 0.05;
}
return Math.min(0.9, confidence);
}
export function analyzeGitHistory(
repoPath: string,
options: GitAnalysisOptions = {}
): GitAnalysisResult {
const commits = getGitCommits(repoPath, options);
const ignorePatterns = ['merge', 'wip', 'typo'];
const patterns: LearnedPattern[] = [];
const summary: GitAnalysisSummary = {
totalCommits: commits.length,
totalFilesChanged: 0,
errorFixes: 0,
refactors: 0,
features: 0,
documentation: 0,
tests: 0,
};
const languages = new Set<string>();
const frameworks = new Set<string>();
for (const commit of commits) {
if (shouldSkipCommit(commit, ignorePatterns)) {
continue;
}
summary.totalFilesChanged += commit.files.length;
for (const file of commit.files) {
const ext = file.path.split('.').pop()?.toLowerCase();
if (ext) {
if (['ts', 'tsx'].includes(ext)) languages.add('TypeScript');
else if (['js', 'jsx'].includes(ext)) languages.add('JavaScript');
else if (ext === 'py') languages.add('Python');
else if (ext === 'go') languages.add('Go');
else if (ext === 'rs') languages.add('Rust');
else if (ext === 'java') languages.add('Java');
}
if (file.path.includes('next')) frameworks.add('Next.js');
if (file.path.includes('react')) frameworks.add('React');
if (file.path.includes('vue')) frameworks.add('Vue');
}
const category = categorizeCommit(commit.message, commit.body);
if (category === 'error_fix') summary.errorFixes++;
else if (category === 'refactor') summary.refactors++;
if (commit.message.toLowerCase().includes('feat')) summary.features++;
if (commit.message.toLowerCase().includes('doc')) summary.documentation++;
if (commit.message.toLowerCase().includes('test')) summary.tests++;
const pattern = extractPatternFromCommit(commit);
if (pattern) {
patterns.push(pattern);
}
}
const dates = commits.map(c => c.date).sort();
return {
patterns,
commitCount: commits.length,
dateRange: {
from: dates[0] || '',
to: dates[dates.length - 1] || '',
},
languages: Array.from(languages),
frameworks: Array.from(frameworks),
summary,
};
}
export function getRecentBugFixes(
repoPath: string,
limit = 20
): LearnedPattern[] {
const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
return result.patterns
.filter(p => p.category === 'error_fix')
.slice(0, limit);
}
export function getRecentRefactors(
repoPath: string,
limit = 20
): LearnedPattern[] {
const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
return result.patterns
.filter(p => p.category === 'refactor')
.slice(0, limit);
}
-6
View File
@@ -1,6 +0,0 @@
export * from './types.js';
export * from './config.js';
export * from './git-analyzer.js';
export * from './extractor.js';
export * from './generator.js';
export * from './feedback.js';
-108
View File
@@ -1,108 +0,0 @@
export type PatternCategory =
| 'error_fix'
| 'refactor'
| 'workaround'
| 'debugging'
| 'convention';
export type PatternDomain =
| 'code-style'
| 'testing'
| 'git'
| 'debugging'
| 'workflow'
| 'security'
| 'performance';
export interface LearnedPattern {
id: string;
category: PatternCategory;
domain?: PatternDomain;
title: string;
problem: string;
solution: string;
example?: string;
context: string;
extractedAt: string;
source: 'git' | 'session' | 'manual';
commitRange?: { from: string; to: string };
approved: boolean;
confidence: number;
}
export interface EvolvingPattern extends LearnedPattern {
trigger: string;
action: string;
useCount: number;
successCount: number;
failureCount: number;
lastUsed?: string;
}
export interface LearningConfig {
minSessionLength: number;
sensitivity: 'low' | 'medium' | 'high';
autoApprove: boolean;
outputPath: string;
categories: PatternCategory[];
ignorePatterns: string[];
}
export interface GitCommit {
hash: string;
shortHash: string;
author: string;
date: string;
message: string;
body?: string;
files: GitFileChange[];
}
export interface GitFileChange {
path: string;
status: 'added' | 'modified' | 'deleted' | 'renamed';
additions: number;
deletions: number;
oldPath?: string;
}
export interface GitAnalysisResult {
patterns: LearnedPattern[];
commitCount: number;
dateRange: { from: string; to: string };
languages: string[];
frameworks: string[];
summary: GitAnalysisSummary;
}
export interface GitAnalysisSummary {
totalCommits: number;
totalFilesChanged: number;
errorFixes: number;
refactors: number;
features: number;
documentation: number;
tests: number;
}
export interface PatternExtractionResult {
patterns: LearnedPattern[];
skipped: { reason: string; commit?: string }[];
errors: string[];
}
export interface PatternStore {
version: number;
updatedAt: string;
patterns: LearnedPattern[];
evolvingPatterns: EvolvingPattern[];
}
export const DEFAULT_LEARNING_CONFIG: LearningConfig = {
minSessionLength: 10,
sensitivity: 'medium',
autoApprove: false,
outputPath: '~/.skillkit/learned/',
categories: ['error_fix', 'refactor', 'workaround', 'debugging', 'convention'],
ignorePatterns: ['trivial_typo', 'one_off_fix', 'wip', 'merge'],
};
-2
View File
@@ -1,2 +0,0 @@
export * from './types.js';
export * from './manager.js';
-189
View File
@@ -1,189 +0,0 @@
import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { homedir } from 'node:os';
import yaml from 'yaml';
import type { OperationalProfile, ProfileName, ProfileConfig } from './types.js';
import { DEFAULT_PROFILE_CONFIG } from './types.js';
const BUILTIN_PROFILES: OperationalProfile[] = [
{
name: 'dev',
description: 'Active development mode',
focus: 'Implementation speed and working solutions',
behaviors: [
'Prefer working code over perfect code',
'Quick iterations with frequent testing',
'Minimize context switching',
'Focus on the current task',
],
priorities: ['Functionality', 'Simplicity', 'Testability', 'Speed'],
preferredTools: ['Edit', 'Write', 'Bash', 'Read'],
injectedContext: `You are in DEVELOPMENT mode. Focus on:
- Getting working code quickly
- Writing minimal tests for new functionality
- Keeping changes small and focused
- Committing frequently`,
},
{
name: 'review',
description: 'Code review mode',
focus: 'Quality, security, and maintainability',
behaviors: [
'Thorough analysis before suggesting changes',
'Security-first mindset',
'Consider edge cases and failure modes',
'Provide constructive feedback',
],
priorities: ['Security', 'Code quality', 'Best practices', 'Maintainability'],
preferredTools: ['Read', 'Grep', 'Glob'],
avoidTools: ['Edit', 'Write'],
injectedContext: `You are in REVIEW mode. Focus on:
- Identifying potential bugs and security issues
- Checking code against best practices
- Verifying test coverage
- Suggesting improvements without making changes`,
},
{
name: 'research',
description: 'Exploration and discovery mode',
focus: 'Understanding and analysis',
behaviors: [
'Deep exploration of codebase',
'Document findings thoroughly',
'Consider multiple approaches',
'Ask clarifying questions',
],
priorities: ['Understanding', 'Documentation', 'Options analysis', 'Learning'],
preferredTools: ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'],
avoidTools: ['Edit', 'Write'],
injectedContext: `You are in RESEARCH mode. Focus on:
- Understanding the codebase structure
- Finding relevant documentation
- Exploring different approaches
- Creating summaries of findings`,
},
{
name: 'security',
description: 'Security audit mode',
focus: 'Vulnerability detection and hardening',
behaviors: [
'Assume hostile input',
'Check all authentication and authorization',
'Look for common vulnerability patterns',
'Verify encryption and data protection',
],
priorities: ['Security', 'Data protection', 'Authentication', 'Authorization'],
preferredTools: ['Read', 'Grep', 'Glob', 'Bash'],
injectedContext: `You are in SECURITY AUDIT mode. Focus on:
- OWASP Top 10 vulnerabilities
- Authentication and authorization flaws
- Data exposure risks
- Injection vulnerabilities
- Secrets and credentials in code`,
},
];
function getConfigPath(): string {
return join(homedir(), '.skillkit', 'profiles.yaml');
}
export function loadProfileConfig(): ProfileConfig {
const path = getConfigPath();
if (!existsSync(path)) {
return DEFAULT_PROFILE_CONFIG;
}
try {
const content = readFileSync(path, 'utf-8');
return { ...DEFAULT_PROFILE_CONFIG, ...yaml.parse(content) };
} catch {
return DEFAULT_PROFILE_CONFIG;
}
}
export function saveProfileConfig(config: ProfileConfig): void {
const path = getConfigPath();
const dir = dirname(path);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
writeFileSync(path, yaml.stringify(config));
}
export function getActiveProfile(): ProfileName {
const config = loadProfileConfig();
return config.activeProfile;
}
export function setActiveProfile(name: ProfileName): void {
const config = loadProfileConfig();
config.activeProfile = name;
saveProfileConfig(config);
}
export function getProfile(name: ProfileName): OperationalProfile | null {
const builtin = BUILTIN_PROFILES.find(p => p.name === name);
if (builtin) return builtin;
const config = loadProfileConfig();
return config.customProfiles.find(p => p.name === name) || null;
}
export function getAllProfiles(): OperationalProfile[] {
const config = loadProfileConfig();
return [...BUILTIN_PROFILES, ...config.customProfiles];
}
export function getBuiltinProfiles(): OperationalProfile[] {
return BUILTIN_PROFILES;
}
export function getProfileNames(): ProfileName[] {
const config = loadProfileConfig();
const builtinNames = BUILTIN_PROFILES.map(p => p.name);
const customNames = config.customProfiles.map(p => p.name);
return [...builtinNames, ...customNames];
}
export function addCustomProfile(profile: OperationalProfile): void {
const config = loadProfileConfig();
const existing = config.customProfiles.findIndex(p => p.name === profile.name);
if (existing >= 0) {
config.customProfiles[existing] = profile;
} else {
config.customProfiles.push(profile);
}
saveProfileConfig(config);
}
export function removeCustomProfile(name: ProfileName): boolean {
const config = loadProfileConfig();
const index = config.customProfiles.findIndex(p => p.name === name);
if (index < 0) return false;
config.customProfiles.splice(index, 1);
if (config.activeProfile === name) {
config.activeProfile = 'dev';
}
saveProfileConfig(config);
return true;
}
export function getProfileContext(name?: ProfileName): string | null {
const profileName = name || getActiveProfile();
const profile = getProfile(profileName);
return profile?.injectedContext || null;
}
export function isBuiltinProfile(name: ProfileName): boolean {
return BUILTIN_PROFILES.some(p => p.name === name);
}
-22
View File
@@ -1,22 +0,0 @@
export type ProfileName = 'dev' | 'review' | 'research' | 'security' | 'custom';
export interface OperationalProfile {
name: ProfileName;
description: string;
focus: string;
behaviors: string[];
priorities: string[];
preferredTools?: string[];
avoidTools?: string[];
injectedContext?: string;
}
export interface ProfileConfig {
activeProfile: ProfileName;
customProfiles: OperationalProfile[];
}
export const DEFAULT_PROFILE_CONFIG: ProfileConfig = {
activeProfile: 'dev',
customProfiles: [],
};
-1
View File
@@ -6,5 +6,4 @@
export * from './types.js';
export * from './manager.js';
export * from './state-file.js';
export { SessionManager, createSessionManager } from './manager.js';
-251
View File
@@ -1,251 +0,0 @@
import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
export interface SessionFile {
date: string;
agent: string;
projectPath: string;
startedAt: string;
lastUpdated: string;
completed: string[];
inProgress: string[];
notes: string[];
contextToLoad: string[];
}
export interface SessionSummary {
date: string;
projectPath: string;
agent: string;
taskCount: number;
completedCount: number;
hasNotes: boolean;
}
function getSessionsDir(): string {
return join(homedir(), '.skillkit', 'sessions');
}
function getSessionFilePath(date?: string): string {
const d = date || new Date().toISOString().split('T')[0];
return join(getSessionsDir(), `${d}-session.md`);
}
export function loadSessionFile(date?: string): SessionFile | null {
const filepath = getSessionFilePath(date);
if (!existsSync(filepath)) {
return null;
}
try {
const content = readFileSync(filepath, 'utf-8');
return parseSessionFile(content);
} catch {
return null;
}
}
export function saveSessionFile(session: SessionFile): string {
const dir = getSessionsDir();
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
const filepath = getSessionFilePath(session.date);
const content = formatSessionFile(session);
writeFileSync(filepath, content);
return filepath;
}
export function createSessionFile(
agent: string,
projectPath: string
): SessionFile {
const now = new Date();
return {
date: now.toISOString().split('T')[0],
agent,
projectPath,
startedAt: now.toISOString(),
lastUpdated: now.toISOString(),
completed: [],
inProgress: [],
notes: [],
contextToLoad: [],
};
}
export function updateSessionFile(
session: SessionFile,
updates: Partial<Pick<SessionFile, 'completed' | 'inProgress' | 'notes' | 'contextToLoad'>>
): SessionFile {
const updated: SessionFile = {
...session,
lastUpdated: new Date().toISOString(),
};
if (updates.completed) {
updated.completed = [...new Set([...session.completed, ...updates.completed])];
}
if (updates.inProgress) {
updated.inProgress = updates.inProgress;
}
if (updates.notes) {
updated.notes = [...session.notes, ...updates.notes];
}
if (updates.contextToLoad) {
updated.contextToLoad = [...new Set([...session.contextToLoad, ...updates.contextToLoad])];
}
return updated;
}
function parseSessionFile(content: string): SessionFile {
const lines = content.split('\n');
const session: SessionFile = {
date: '',
agent: '',
projectPath: '',
startedAt: '',
lastUpdated: '',
completed: [],
inProgress: [],
notes: [],
contextToLoad: [],
};
let currentSection = '';
for (const line of lines) {
const trimmed = line.trim();
if (trimmed.startsWith('# Session:')) {
session.date = trimmed.replace('# Session:', '').trim();
} else if (trimmed.startsWith('**Date:**')) {
session.date = trimmed.replace('**Date:**', '').trim();
} else if (trimmed.startsWith('**Started:**')) {
session.startedAt = trimmed.replace('**Started:**', '').trim();
} else if (trimmed.startsWith('**Last Updated:**')) {
session.lastUpdated = trimmed.replace('**Last Updated:**', '').trim();
} else if (trimmed.startsWith('**Agent:**')) {
session.agent = trimmed.replace('**Agent:**', '').trim();
} else if (trimmed.startsWith('**Project:**')) {
session.projectPath = trimmed.replace('**Project:**', '').trim();
} else if (trimmed === '### Completed') {
currentSection = 'completed';
} else if (trimmed === '### In Progress') {
currentSection = 'inProgress';
} else if (trimmed === '### Notes for Next Session') {
currentSection = 'notes';
} else if (trimmed === '### Context to Load') {
currentSection = 'contextToLoad';
} else if (trimmed.startsWith('- [x]')) {
if (currentSection === 'completed') {
session.completed.push(trimmed.replace('- [x]', '').trim());
}
} else if (trimmed.startsWith('- [ ]')) {
if (currentSection === 'inProgress') {
session.inProgress.push(trimmed.replace('- [ ]', '').trim());
}
} else if (trimmed.startsWith('- ')) {
const item = trimmed.replace('- ', '').trim();
if (currentSection === 'notes') {
session.notes.push(item);
} else if (currentSection === 'contextToLoad') {
session.contextToLoad.push(item);
}
}
}
return session;
}
function formatSessionFile(session: SessionFile): string {
const lines: string[] = [];
lines.push(`# Session: ${session.date}`);
lines.push(`**Date:** ${session.date}`);
lines.push(`**Started:** ${session.startedAt}`);
lines.push(`**Last Updated:** ${session.lastUpdated}`);
lines.push(`**Agent:** ${session.agent}`);
lines.push(`**Project:** ${session.projectPath}`);
lines.push('');
lines.push('## Current State');
lines.push('');
lines.push('### Completed');
for (const task of session.completed) {
lines.push(`- [x] ${task}`);
}
lines.push('');
lines.push('### In Progress');
for (const task of session.inProgress) {
lines.push(`- [ ] ${task}`);
}
lines.push('');
lines.push('### Notes for Next Session');
for (const note of session.notes) {
lines.push(`- ${note}`);
}
lines.push('');
lines.push('### Context to Load');
for (const ctx of session.contextToLoad) {
lines.push(`- ${ctx}`);
}
lines.push('');
return lines.join('\n');
}
export function listSessions(limit = 10): SessionSummary[] {
const dir = getSessionsDir();
if (!existsSync(dir)) {
return [];
}
const files = readdirSync(dir)
.filter(f => f.endsWith('-session.md'))
.sort()
.reverse()
.slice(0, limit);
const summaries: SessionSummary[] = [];
for (const file of files) {
const date = file.replace('-session.md', '');
const session = loadSessionFile(date);
if (session) {
summaries.push({
date: session.date,
projectPath: session.projectPath,
agent: session.agent,
taskCount: session.completed.length + session.inProgress.length,
completedCount: session.completed.length,
hasNotes: session.notes.length > 0,
});
}
}
return summaries;
}
export function getMostRecentSession(): SessionFile | null {
const summaries = listSessions(1);
if (summaries.length === 0) {
return null;
}
return loadSessionFile(summaries[0].date);
}
-90
View File
@@ -110,93 +110,3 @@ export interface WorkflowExecution {
*/
export const WORKFLOWS_DIR = 'workflows';
export const WORKFLOW_EXTENSION = '.yaml';
/**
* Pipeline stage - a step in an agent pipeline
*/
export interface PipelineStage {
agent: string;
name: string;
description: string;
condition?: string;
timeout?: number;
}
/**
* Agent Pipeline - sequential multi-agent workflow
*/
export interface AgentPipeline {
id: string;
name: string;
description: string;
stages: PipelineStage[];
}
/**
* Built-in pipelines for common workflows
*/
export const BUILTIN_PIPELINES: AgentPipeline[] = [
{
id: 'feature',
name: 'Feature Development',
description: 'Plan → TDD → Review → Security',
stages: [
{ agent: 'planner', name: 'Planning', description: 'Design implementation approach' },
{ agent: 'tdd-guide', name: 'TDD', description: 'Write tests first, then implement' },
{ agent: 'code-reviewer', name: 'Review', description: 'Quality and best practices check' },
{ agent: 'security-reviewer', name: 'Security', description: 'Security audit' },
],
},
{
id: 'bugfix',
name: 'Bug Fix',
description: 'TDD → Review',
stages: [
{ agent: 'tdd-guide', name: 'Fix', description: 'Test-first bug fix' },
{ agent: 'code-reviewer', name: 'Review', description: 'Verify fix quality' },
],
},
{
id: 'refactor',
name: 'Refactoring',
description: 'Architect → Review → TDD',
stages: [
{ agent: 'architect', name: 'Design', description: 'Plan refactoring approach' },
{ agent: 'code-reviewer', name: 'Review', description: 'Review proposed changes' },
{ agent: 'tdd-guide', name: 'Verify', description: 'Ensure tests pass after refactor' },
],
},
{
id: 'security-audit',
name: 'Security Audit',
description: 'Security → Review → Fix',
stages: [
{ agent: 'security-reviewer', name: 'Audit', description: 'Identify vulnerabilities' },
{ agent: 'code-reviewer', name: 'Review', description: 'Review security findings' },
{ agent: 'build-error-resolver', name: 'Fix', description: 'Apply security fixes' },
],
},
{
id: 'documentation',
name: 'Documentation',
description: 'Planner → Doc Updater',
stages: [
{ agent: 'planner', name: 'Plan', description: 'Identify documentation needs' },
{ agent: 'doc-updater', name: 'Update', description: 'Update documentation' },
],
},
];
/**
* Get a built-in pipeline by ID
*/
export function getBuiltinPipeline(id: string): AgentPipeline | null {
return BUILTIN_PIPELINES.find(p => p.id === id) || null;
}
/**
* Get all built-in pipelines
*/
export function getBuiltinPipelines(): AgentPipeline[] {
return BUILTIN_PIPELINES;
}
-157
View File
@@ -1,157 +0,0 @@
# @skillkit/mcp-memory
MCP (Model Context Protocol) server for SkillKit persistent memory. Enables Claude, Cursor, and other MCP-compatible tools to store, search, and recall memories with semantic embeddings.
## Installation
```bash
npm install @skillkit/mcp-memory
# or
pnpm add @skillkit/mcp-memory
```
## Usage with Claude Desktop
Add to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"skillkit-memory": {
"command": "npx",
"args": ["@skillkit/mcp-memory"],
"env": {
"SKILLKIT_AGENT_ID": "claude-desktop"
}
}
}
}
```
## Usage with Cursor
Add to your Cursor MCP settings:
```json
{
"mcpServers": {
"skillkit-memory": {
"command": "npx",
"args": ["@skillkit/mcp-memory"],
"env": {
"SKILLKIT_AGENT_ID": "cursor"
}
}
}
}
```
## Environment Variables
- `SKILLKIT_AGENT_ID` - Agent identifier for memory isolation (default: `mcp-memory-server`)
- `SKILLKIT_MEMORY_DB_PATH` - Custom database path (default: `~/.skillkit/memory.db`)
## Available Tools
### memory_store
Store a new memory with semantic embedding.
```js
memory_store({
content: "User prefers TypeScript over JavaScript",
category: "preference",
tags: ["language", "coding"]
})
```
### memory_search
Semantic search through stored memories.
```js
memory_search({
query: "What programming languages does the user prefer?",
limit: 5,
threshold: 0.5
})
```
### memory_recall
Recall memories by category, tier, or tags.
```js
memory_recall({
category: "decision",
tier: "long",
limit: 10
})
```
### memory_get
Get a specific memory by ID.
```js
memory_get({ id: "memory-uuid" })
```
### memory_forget
Delete a memory.
```js
memory_forget({ id: "memory-uuid" })
```
### memory_link
Create relationships between memories.
```js
memory_link({
sourceId: "memory-1",
targetId: "memory-2",
relationshipType: "supports",
strength: 0.8
})
```
### memory_reinforce
Strengthen or weaken a memory. Strong memories get promoted to long-term tier.
```js
memory_reinforce({
id: "memory-uuid",
amount: 0.1 // positive to strengthen, negative to weaken
})
```
### memory_stats
Get memory statistics.
```js
memory_stats({})
```
## Memory Categories
- `fact` - Factual information
- `decision` - Decisions made
- `preference` - User preferences
- `pattern` - Observed patterns
- `insight` - Derived insights
- `reasoning` - Reasoning chains
## Memory Tiers
- `warm` - Recent, frequently accessed memories
- `long` - Consolidated long-term memories
Memories are automatically promoted from `warm` to `long` based on access count, reinforcement score, and age.
## Resources
The server exposes two resources:
- `memory://stats` - Current memory statistics (JSON)
- `memory://recent` - 10 most recent memories (JSON)
## License
Apache-2.0
-50
View File
@@ -1,50 +0,0 @@
{
"name": "@skillkit/mcp-memory",
"version": "1.8.0",
"description": "MCP (Model Context Protocol) server for SkillKit persistent memory",
"type": "module",
"main": "./dist/index.js",
"types": "./dist/index.d.ts",
"bin": {
"skillkit-memory-server": "./dist/index.js"
},
"exports": {
".": {
"import": "./dist/index.js",
"types": "./dist/index.d.ts"
}
},
"files": [
"dist"
],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
"typecheck": "tsc --noEmit",
"test": "vitest run",
"start": "node dist/index.js"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.0.0",
"@skillkit/memory": "workspace:*",
"zod": "^3.24.0"
},
"devDependencies": {
"@types/node": "^22.10.5",
"tsup": "^8.3.5",
"typescript": "^5.7.2",
"vitest": "^2.1.8"
},
"engines": {
"node": ">=18.0.0"
},
"license": "Apache-2.0",
"keywords": [
"mcp",
"model-context-protocol",
"memory",
"ai",
"claude",
"skillkit"
]
}
-83
View File
@@ -1,83 +0,0 @@
import { describe, it, expect } from 'vitest';
import {
StoreMemoryInputSchema,
SearchMemoryInputSchema,
RecallMemoryInputSchema,
ForgetMemoryInputSchema,
LinkMemoriesInputSchema,
GetMemoryInputSchema,
ReinforceMemoryInputSchema,
} from './types.js';
describe('@skillkit/mcp-memory', () => {
describe('input schemas', () => {
it('validates StoreMemoryInput', () => {
const valid = {
content: 'Test memory',
category: 'fact',
tags: ['test'],
};
expect(() => StoreMemoryInputSchema.parse(valid)).not.toThrow();
});
it('validates SearchMemoryInput', () => {
const valid = {
query: 'test query',
limit: 10,
threshold: 0.5,
};
expect(() => SearchMemoryInputSchema.parse(valid)).not.toThrow();
});
it('validates RecallMemoryInput', () => {
const valid = {
category: 'decision',
tier: 'warm',
limit: 20,
};
expect(() => RecallMemoryInputSchema.parse(valid)).not.toThrow();
});
it('validates ForgetMemoryInput', () => {
const valid = { id: 'test-id' };
expect(() => ForgetMemoryInputSchema.parse(valid)).not.toThrow();
});
it('validates LinkMemoriesInput', () => {
const valid = {
sourceId: 'source-id',
targetId: 'target-id',
relationshipType: 'related',
strength: 0.5,
};
expect(() => LinkMemoriesInputSchema.parse(valid)).not.toThrow();
});
it('validates GetMemoryInput', () => {
const valid = { id: 'test-id' };
expect(() => GetMemoryInputSchema.parse(valid)).not.toThrow();
});
it('validates ReinforceMemoryInput', () => {
const valid = { id: 'test-id', amount: 0.1 };
expect(() => ReinforceMemoryInputSchema.parse(valid)).not.toThrow();
});
it('rejects invalid category', () => {
const invalid = {
content: 'Test',
category: 'invalid',
};
expect(() => StoreMemoryInputSchema.parse(invalid)).toThrow();
});
it('rejects invalid relationship type', () => {
const invalid = {
sourceId: 'a',
targetId: 'b',
relationshipType: 'invalid',
};
expect(() => LinkMemoriesInputSchema.parse(invalid)).toThrow();
});
});
});
-509
View File
@@ -1,509 +0,0 @@
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { fileURLToPath } from 'node:url';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
ListResourcesRequestSchema,
ReadResourceRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
import { createMemoryStore, type MemoryStore } from '@skillkit/memory';
import {
StoreMemoryInputSchema,
SearchMemoryInputSchema,
RecallMemoryInputSchema,
ForgetMemoryInputSchema,
LinkMemoriesInputSchema,
GetMemoryInputSchema,
ReinforceMemoryInputSchema,
} from './types.js';
const AGENT_ID = process.env.SKILLKIT_AGENT_ID || 'mcp-memory-server';
const DB_PATH = process.env.SKILLKIT_MEMORY_DB_PATH;
let memoryStore: MemoryStore | null = null;
let memoryStoreInit: Promise<MemoryStore> | null = null;
async function getMemoryStore(): Promise<MemoryStore> {
if (memoryStore) {
return memoryStore;
}
if (!memoryStoreInit) {
memoryStoreInit = createMemoryStore(AGENT_ID, DB_PATH);
}
try {
memoryStore = await memoryStoreInit;
return memoryStore;
} catch (error) {
memoryStoreInit = null;
throw error;
}
}
const server = new Server(
{
name: 'skillkit-memory-server',
version: '1.7.11',
},
{
capabilities: {
tools: {},
resources: {},
},
}
);
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: 'memory_store',
description: 'Store a new memory with semantic embedding for later retrieval. Memories are categorized and can be tagged for organization.',
inputSchema: {
type: 'object',
properties: {
content: { type: 'string', description: 'The memory content to store' },
category: {
type: 'string',
enum: ['fact', 'decision', 'preference', 'pattern', 'insight', 'reasoning'],
description: 'Category of the memory',
},
tags: {
type: 'array',
items: { type: 'string' },
description: 'Optional tags for organization',
},
metadata: {
type: 'object',
description: 'Optional metadata',
},
},
required: ['content', 'category'],
},
},
{
name: 'memory_search',
description: 'Semantic search through stored memories. Returns memories most similar to the query.',
inputSchema: {
type: 'object',
properties: {
query: { type: 'string', description: 'Semantic search query' },
category: {
type: 'string',
enum: ['fact', 'decision', 'preference', 'pattern', 'insight', 'reasoning'],
description: 'Filter by category',
},
tier: {
type: 'string',
enum: ['warm', 'long'],
description: 'Filter by tier',
},
tags: {
type: 'array',
items: { type: 'string' },
description: 'Filter by tags',
},
limit: {
type: 'number',
minimum: 1,
maximum: 50,
default: 10,
description: 'Maximum results',
},
threshold: {
type: 'number',
minimum: 0,
maximum: 1,
default: 0.5,
description: 'Minimum similarity threshold',
},
},
required: ['query'],
},
},
{
name: 'memory_recall',
description: 'Recall memories by category, tier, or tags without semantic search.',
inputSchema: {
type: 'object',
properties: {
category: {
type: 'string',
enum: ['fact', 'decision', 'preference', 'pattern', 'insight', 'reasoning'],
description: 'Filter by category',
},
tier: {
type: 'string',
enum: ['warm', 'long'],
description: 'Filter by tier',
},
tags: {
type: 'array',
items: { type: 'string' },
description: 'Filter by tags',
},
limit: {
type: 'number',
minimum: 1,
maximum: 100,
default: 20,
description: 'Maximum results',
},
},
},
},
{
name: 'memory_get',
description: 'Get a specific memory by its ID.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Memory ID' },
},
required: ['id'],
},
},
{
name: 'memory_forget',
description: 'Delete a memory by its ID.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Memory ID to delete' },
},
required: ['id'],
},
},
{
name: 'memory_link',
description: 'Create a relationship link between two memories.',
inputSchema: {
type: 'object',
properties: {
sourceId: { type: 'string', description: 'Source memory ID' },
targetId: { type: 'string', description: 'Target memory ID' },
relationshipType: {
type: 'string',
enum: ['related', 'derived', 'contradicts', 'supports'],
description: 'Type of relationship',
},
strength: {
type: 'number',
minimum: 0,
maximum: 1,
default: 0.5,
description: 'Relationship strength',
},
},
required: ['sourceId', 'targetId', 'relationshipType'],
},
},
{
name: 'memory_reinforce',
description: 'Reinforce or weaken a memory. Positive values strengthen, negative weaken. Strong memories get promoted to long-term tier.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Memory ID' },
amount: {
type: 'number',
minimum: -1,
maximum: 1,
default: 0.1,
description: 'Reinforcement amount',
},
},
required: ['id'],
},
},
{
name: 'memory_stats',
description: 'Get statistics about stored memories.',
inputSchema: {
type: 'object',
properties: {},
},
},
],
};
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
const store = await getMemoryStore();
try {
switch (name) {
case 'memory_store': {
const input = StoreMemoryInputSchema.parse(args);
const memory = await store.create({
agentId: AGENT_ID,
content: input.content,
category: input.category,
tags: input.tags,
metadata: input.metadata,
});
return {
content: [
{
type: 'text',
text: `Memory stored successfully.\n\nID: ${memory.id}\nCategory: ${memory.category}\nTier: ${memory.tier}\nTags: ${memory.tags.join(', ') || 'none'}`,
},
],
};
}
case 'memory_search': {
const input = SearchMemoryInputSchema.parse(args);
const results = await store.semanticSearch(input.query, {
agentId: AGENT_ID,
category: input.category,
tier: input.tier,
tags: input.tags,
limit: input.limit,
threshold: input.threshold,
});
if (results.length === 0) {
return {
content: [{ type: 'text', text: 'No memories found matching your query.' }],
};
}
const formatted = results
.map(
(r, i) =>
`${i + 1}. [${r.memory.category}] (score: ${r.score.toFixed(3)})\n ID: ${r.memory.id}\n ${r.memory.content}\n Tags: ${r.memory.tags.join(', ') || 'none'}`
)
.join('\n\n');
return {
content: [
{
type: 'text',
text: `Found ${results.length} memories:\n\n${formatted}`,
},
],
};
}
case 'memory_recall': {
const input = RecallMemoryInputSchema.parse(args);
let memories = await store.list(AGENT_ID, input.limit ?? 20);
if (input.category) {
memories = memories.filter(m => m.category === input.category);
}
if (input.tier) {
memories = memories.filter(m => m.tier === input.tier);
}
if (input.tags && input.tags.length > 0) {
memories = memories.filter(m =>
input.tags!.some(tag => m.tags.includes(tag))
);
}
if (memories.length === 0) {
return {
content: [{ type: 'text', text: 'No memories found with the specified filters.' }],
};
}
const formatted = memories
.map(
(m, i) =>
`${i + 1}. [${m.category}] (${m.tier})\n ID: ${m.id}\n ${m.content}\n Score: ${m.reinforcementScore.toFixed(2)} | Access: ${m.accessCount}`
)
.join('\n\n');
return {
content: [
{
type: 'text',
text: `Recalled ${memories.length} memories:\n\n${formatted}`,
},
],
};
}
case 'memory_get': {
const input = GetMemoryInputSchema.parse(args);
const memory = await store.get(input.id);
if (!memory) {
return {
content: [{ type: 'text', text: `Memory not found: ${input.id}` }],
isError: true,
};
}
return {
content: [
{
type: 'text',
text: `Memory Details:\n\nID: ${memory.id}\nCategory: ${memory.category}\nTier: ${memory.tier}\nContent: ${memory.content}\nTags: ${memory.tags.join(', ') || 'none'}\nReinforcement: ${memory.reinforcementScore.toFixed(2)}\nAccess Count: ${memory.accessCount}\nCreated: ${memory.createdAt}\nLast Accessed: ${memory.lastAccessedAt}`,
},
],
};
}
case 'memory_forget': {
const input = ForgetMemoryInputSchema.parse(args);
const existing = await store.get(input.id);
if (!existing) {
return {
content: [{ type: 'text', text: `Memory not found: ${input.id}` }],
isError: true,
};
}
await store.delete(input.id);
return {
content: [{ type: 'text', text: `Memory deleted: ${input.id}` }],
};
}
case 'memory_link': {
const input = LinkMemoriesInputSchema.parse(args);
const link = await store.link(
input.sourceId,
input.targetId,
input.relationshipType,
input.strength
);
return {
content: [
{
type: 'text',
text: `Link created:\n\nID: ${link.id}\n${input.sourceId} --[${input.relationshipType}]--> ${input.targetId}\nStrength: ${link.strength}`,
},
],
};
}
case 'memory_reinforce': {
const input = ReinforceMemoryInputSchema.parse(args);
const existing = await store.get(input.id);
if (!existing) {
return {
content: [{ type: 'text', text: `Memory not found: ${input.id}` }],
isError: true,
};
}
const memory = await store.reinforce(input.id, input.amount ?? 0.1);
return {
content: [
{
type: 'text',
text: `Memory reinforced:\n\nID: ${memory.id}\nNew Score: ${memory.reinforcementScore.toFixed(2)}\nTier: ${memory.tier}`,
},
],
};
}
case 'memory_stats': {
const stats = await store.getStats(AGENT_ID);
const categoryBreakdown = Object.entries(stats.byCategory)
.map(([cat, count]) => ` ${cat}: ${count}`)
.join('\n');
const tierBreakdown = Object.entries(stats.byTier)
.map(([tier, count]) => ` ${tier}: ${count}`)
.join('\n');
return {
content: [
{
type: 'text',
text: `Memory Statistics:\n\nTotal Memories: ${stats.totalMemories}\nAverage Reinforcement: ${stats.avgReinforcementScore.toFixed(2)}\n\nBy Category:\n${categoryBreakdown}\n\nBy Tier:\n${tierBreakdown}\n\nOldest: ${stats.oldestMemory || 'N/A'}\nNewest: ${stats.newestMemory || 'N/A'}`,
},
],
};
}
default:
return {
content: [{ type: 'text', text: `Unknown tool: ${name}` }],
isError: true,
};
}
} catch (error) {
const message = error instanceof Error ? error.message : 'Unknown error';
return {
content: [{ type: 'text', text: `Error: ${message}` }],
isError: true,
};
}
});
server.setRequestHandler(ListResourcesRequestSchema, async () => {
return {
resources: [
{
uri: 'memory://stats',
name: 'Memory Statistics',
description: 'Current memory store statistics',
mimeType: 'application/json',
},
{
uri: 'memory://recent',
name: 'Recent Memories',
description: 'Most recently accessed memories',
mimeType: 'application/json',
},
],
};
});
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
const { uri } = request.params;
const store = await getMemoryStore();
if (uri === 'memory://stats') {
const stats = await store.getStats(AGENT_ID);
return {
contents: [
{
uri,
mimeType: 'application/json',
text: JSON.stringify(stats, null, 2),
},
],
};
}
if (uri === 'memory://recent') {
const memories = await store.list(AGENT_ID, 10);
return {
contents: [
{
uri,
mimeType: 'application/json',
text: JSON.stringify(memories, null, 2),
},
],
};
}
throw new Error(`Unknown resource: ${uri}`);
});
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('SkillKit Memory MCP Server running on stdio');
}
const isMain = process.argv[1] === fileURLToPath(import.meta.url);
if (isMain) {
main().catch((error) => {
console.error('Fatal error:', error);
process.exit(1);
});
}
export { server };
-70
View File
@@ -1,70 +0,0 @@
import { z } from 'zod';
export const MemoryCategorySchema = z.enum([
'fact',
'decision',
'preference',
'pattern',
'insight',
'reasoning',
]);
export const MemoryTierSchema = z.enum(['warm', 'long']);
export const RelationshipTypeSchema = z.enum([
'related',
'derived',
'contradicts',
'supports',
]);
export const StoreMemoryInputSchema = z.object({
content: z.string().describe('The memory content to store'),
category: MemoryCategorySchema.describe('Category of the memory'),
tags: z.array(z.string()).optional().describe('Optional tags for organization'),
metadata: z.record(z.unknown()).optional().describe('Optional metadata'),
});
export const SearchMemoryInputSchema = z.object({
query: z.string().describe('Semantic search query'),
category: MemoryCategorySchema.optional().describe('Filter by category'),
tier: MemoryTierSchema.optional().describe('Filter by tier (warm or long)'),
tags: z.array(z.string()).optional().describe('Filter by tags'),
limit: z.number().min(1).max(50).default(10).describe('Maximum results to return'),
threshold: z.number().min(0).max(1).default(0.5).describe('Minimum similarity threshold'),
});
export const RecallMemoryInputSchema = z.object({
category: MemoryCategorySchema.optional().describe('Filter by category'),
tier: MemoryTierSchema.optional().describe('Filter by tier'),
tags: z.array(z.string()).optional().describe('Filter by tags'),
limit: z.number().min(1).max(100).default(20).describe('Maximum results'),
});
export const ForgetMemoryInputSchema = z.object({
id: z.string().describe('Memory ID to delete'),
});
export const LinkMemoriesInputSchema = z.object({
sourceId: z.string().describe('Source memory ID'),
targetId: z.string().describe('Target memory ID'),
relationshipType: RelationshipTypeSchema.describe('Type of relationship'),
strength: z.number().min(0).max(1).default(0.5).describe('Relationship strength'),
});
export const GetMemoryInputSchema = z.object({
id: z.string().describe('Memory ID to retrieve'),
});
export const ReinforceMemoryInputSchema = z.object({
id: z.string().describe('Memory ID to reinforce'),
amount: z.number().min(-1).max(1).default(0.1).describe('Reinforcement amount (-1 to 1)'),
});
export type StoreMemoryInput = z.infer<typeof StoreMemoryInputSchema>;
export type SearchMemoryInput = z.infer<typeof SearchMemoryInputSchema>;
export type RecallMemoryInput = z.infer<typeof RecallMemoryInputSchema>;
export type ForgetMemoryInput = z.infer<typeof ForgetMemoryInputSchema>;
export type LinkMemoriesInput = z.infer<typeof LinkMemoriesInputSchema>;
export type GetMemoryInput = z.infer<typeof GetMemoryInputSchema>;
export type ReinforceMemoryInput = z.infer<typeof ReinforceMemoryInputSchema>;
-10
View File
@@ -1,10 +0,0 @@
{
"extends": "../../tsconfig.base.json",
"compilerOptions": {
"outDir": "./dist",
"rootDir": "./src",
"composite": false
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist", "**/*.test.ts"]
}
-13
View File
@@ -1,13 +0,0 @@
import { defineConfig } from 'tsup';
export default defineConfig({
entry: ['src/index.ts'],
format: ['esm'],
dts: true,
clean: true,
sourcemap: true,
target: 'node18',
banner: {
js: '#!/usr/bin/env node',
},
});
-148
View File
@@ -1,148 +0,0 @@
# @skillkit/memory
[![npm version](https://img.shields.io/npm/v/@skillkit/memory.svg)](https://www.npmjs.com/package/@skillkit/memory)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
**Semantic memory with embeddings for SkillKit** - CozoDB-backed persistent memory with vector search for AI agents.
## Installation
```bash
npm install @skillkit/memory
```
## Key Features
- **CozoDB Backend**: Embedded graph database with HNSW vector index
- **Semantic Search**: Cosine similarity search over embeddings
- **Xenova Transformers**: Local embedding generation (no API keys)
- **Observations & Learnings**: Store raw observations and compressed learnings
- **Memory Compression**: Extract patterns from observations
- **Persistent Storage**: SQLite-backed durability
- **Memory Reinforcement**: Boost memory relevance through usage
## Usage
### Basic Memory Operations
```typescript
import { MemoryStore, EmbeddingEncoder } from '@skillkit/memory';
// Initialize encoder
const encoder = new EmbeddingEncoder();
await encoder.init();
// Create memory store
const store = new MemoryStore('./my-project/.skillkit/memory');
await store.init();
// Store an observation
await store.addObservation({
content: 'User prefers TypeScript strict mode',
tags: ['typescript', 'preferences'],
source: 'conversation',
});
// Search memories
const results = await store.search('typescript configuration', { limit: 5 });
```
### Memory Compression
```typescript
import { MemoryCompressor } from '@skillkit/memory';
// Compress observations into learnings
const compressor = new MemoryCompressor(store);
const learnings = await compressor.compress({
minObservations: 3,
maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
});
```
### Vector Search
```typescript
// Get embedding for a query
const embedding = await encoder.encode('React best practices');
// Search by vector
const results = await store.searchByVector(embedding, {
limit: 10,
threshold: 0.7,
});
```
### Export Memories as Skills
```typescript
import { MemoryExporter } from '@skillkit/memory';
// Export memories to a skill file
const exporter = new MemoryExporter(store);
const skill = await exporter.toSkill({
name: 'project-patterns',
tags: ['patterns', 'best-practices'],
});
```
## API Reference
### MemoryStore
```typescript
interface MemoryStore {
init(): Promise<void>;
addObservation(obs: Observation): Promise<string>;
addLearning(learning: Learning): Promise<string>;
search(query: string, options?: SearchOptions): Promise<Memory[]>;
searchByVector(embedding: number[], options?: SearchOptions): Promise<Memory[]>;
reinforce(id: string): Promise<void>;
close(): Promise<void>;
}
```
### EmbeddingEncoder
```typescript
interface EmbeddingEncoder {
init(): Promise<void>;
encode(text: string): Promise<number[]>;
encodeBatch(texts: string[]): Promise<number[][]>;
dispose(): Promise<void>;
}
```
### Types
```typescript
interface Observation {
content: string;
tags?: string[];
source?: string;
metadata?: Record<string, unknown>;
}
interface Learning {
title: string;
content: string;
tags?: string[];
confidence?: number;
}
interface Memory {
id: string;
content: string;
embedding: number[];
score?: number;
createdAt: Date;
}
```
## Documentation
Full documentation: https://github.com/rohitg00/skillkit
## License
Apache-2.0
-50
View File
@@ -1,50 +0,0 @@
{
"name": "@skillkit/memory",
"version": "1.8.0",
"description": "CozoDB-backed semantic memory with embeddings for SkillKit",
"type": "module",
"main": "./dist/index.js",
"types": "./dist/index.d.ts",
"exports": {
".": {
"import": "./dist/index.js",
"types": "./dist/index.d.ts"
}
},
"files": [
"dist"
],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
"typecheck": "tsc --noEmit",
"test": "vitest run",
"test:watch": "vitest"
},
"dependencies": {
"@skillkit/core": "workspace:*",
"cozo-node": "^0.7.6",
"@xenova/transformers": "^2.17.2"
},
"devDependencies": {
"tsup": "^8.0.1",
"typescript": "^5.3.3",
"vitest": "^1.2.0"
},
"engines": {
"node": ">=18"
},
"repository": {
"type": "git",
"url": "https://github.com/rohitg00/skillkit.git",
"directory": "packages/memory"
},
"keywords": [
"skillkit",
"memory",
"cozodb",
"embeddings",
"semantic-search"
],
"license": "Apache-2.0"
}
@@ -1,9 +0,0 @@
import { describe, it, expect } from 'vitest';
describe('@skillkit/memory', () => {
it('should export types', async () => {
const memory = await import('../index.js');
expect(memory).toBeDefined();
expect(memory.DEFAULT_EMBEDDING_DIMENSION).toBe(384);
});
});
@@ -1,358 +0,0 @@
import { CozoDb } from 'cozo-node';
import { mkdir } from 'node:fs/promises';
import { dirname, join } from 'node:path';
import { homedir } from 'node:os';
import { initializeSchema, dropSchema } from './schema.js';
export interface CozoAdapterOptions {
agentId: string;
dbPath?: string;
}
export class CozoAdapter {
private db: CozoDb | null = null;
private dbPath: string;
private initialized = false;
constructor(options: CozoAdapterOptions) {
this.dbPath = options.dbPath ?? this.getDefaultDbPath(options.agentId);
}
private getDefaultDbPath(agentId: string): string {
return join(homedir(), '.skillkit', 'agents', agentId, 'memory.db');
}
async initialize(): Promise<void> {
if (this.initialized) return;
await mkdir(dirname(this.dbPath), { recursive: true });
this.db = new CozoDb('rocksdb', this.dbPath);
await initializeSchema(this.db);
this.initialized = true;
}
async close(): Promise<void> {
if (this.db) {
this.db.close();
this.db = null;
this.initialized = false;
}
}
async reset(): Promise<void> {
if (!this.db) throw new Error('Database not initialized');
await dropSchema(this.db);
await initializeSchema(this.db);
}
async run(query: string, params?: Record<string, unknown>): Promise<CozoResult> {
if (!this.db) throw new Error('Database not initialized');
const result = await this.db.run(query, params);
return {
headers: result.headers,
rows: result.rows,
ok: result.ok,
};
}
async insertMemory(
id: string,
agentId: string,
category: string,
tier: string,
content: string,
reinforcementScore: number,
createdAt: string,
updatedAt: string,
accessCount: number,
lastAccessedAt: string,
tags: string[],
metadata: Record<string, unknown>
): Promise<void> {
const query = `
?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] <- [[
$id, $agent_id, $category, $tier, $content, $reinforcement_score, $created_at, $updated_at, $access_count, $last_accessed_at, $tags, $metadata
]]
:put memories {
id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata
}
`;
await this.run(query, {
id,
agent_id: agentId,
category,
tier,
content,
reinforcement_score: reinforcementScore,
created_at: createdAt,
updated_at: updatedAt,
access_count: accessCount,
last_accessed_at: lastAccessedAt,
tags,
metadata: JSON.stringify(metadata),
});
}
async insertEmbedding(id: string, embedding: number[]): Promise<void> {
const query = `
?[id, embedding] <- [[$id, $embedding]]
:put memory_vec { id, embedding }
`;
await this.run(query, { id, embedding });
}
async getMemory(id: string): Promise<MemoryRow | null> {
const query = `
?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] :=
*memories[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata],
id == $id
`;
const result = await this.run(query, { id });
if (result.rows.length === 0) return null;
return this.rowToMemory(result.rows[0]);
}
async getMemoriesByAgent(agentId: string, limit = 100): Promise<MemoryRow[]> {
const query = `
?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] :=
*memories[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata],
agent_id == $agent_id
:limit $limit
`;
const result = await this.run(query, { agent_id: agentId, limit });
return result.rows.map(row => this.rowToMemory(row));
}
async updateMemory(
id: string,
updates: Partial<{
category: string;
tier: string;
content: string;
reinforcementScore: number;
updatedAt: string;
accessCount: number;
lastAccessedAt: string;
tags: string[];
metadata: Record<string, unknown>;
}>
): Promise<void> {
const existing = await this.getMemory(id);
if (!existing) throw new Error(`Memory ${id} not found`);
const query = `
?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] <- [[
$id, $agent_id, $category, $tier, $content, $reinforcement_score, $created_at, $updated_at, $access_count, $last_accessed_at, $tags, $metadata
]]
:put memories {
id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata
}
`;
await this.run(query, {
id,
agent_id: existing.agentId,
category: updates.category ?? existing.category,
tier: updates.tier ?? existing.tier,
content: updates.content ?? existing.content,
reinforcement_score: updates.reinforcementScore ?? existing.reinforcementScore,
created_at: existing.createdAt,
updated_at: updates.updatedAt ?? new Date().toISOString(),
access_count: updates.accessCount ?? existing.accessCount,
last_accessed_at: updates.lastAccessedAt ?? existing.lastAccessedAt,
tags: updates.tags ?? existing.tags,
metadata: JSON.stringify(updates.metadata ?? existing.metadata),
});
}
async deleteMemory(id: string): Promise<void> {
const deleteMemory = `
?[id] <- [[$id]]
:rm memories { id }
`;
const deleteEmbedding = `
?[id] <- [[$id]]
:rm memory_vec { id }
`;
await this.run(deleteMemory, { id });
await this.run(deleteEmbedding, { id });
}
async semanticSearch(
embedding: number[],
limit = 10,
_agentId?: string,
_category?: string,
_tier?: string
): Promise<Array<{ id: string; score: number }>> {
const params: Record<string, unknown> = { embedding, limit };
const query = `
?[id, score] := ~memory_vec:embedding_idx{ id, embedding |
query: $embedding,
k: $limit,
ef: 50
}, score = cos_dist(embedding, $embedding)
:order score
:limit $limit
`;
const result = await this.run(query, params);
return result.rows.map(row => ({
id: row[0] as string,
score: 1 - (row[1] as number),
}));
}
async insertLink(
id: string,
sourceId: string,
targetId: string,
relationshipType: string,
strength: number,
createdAt: string
): Promise<void> {
const query = `
?[id, source_id, target_id, relationship_type, strength, created_at] <- [[
$id, $source_id, $target_id, $relationship_type, $strength, $created_at
]]
:put memory_links { id, source_id, target_id, relationship_type, strength, created_at }
`;
await this.run(query, {
id,
source_id: sourceId,
target_id: targetId,
relationship_type: relationshipType,
strength,
created_at: createdAt,
});
}
async getLinks(memoryId: string): Promise<LinkRow[]> {
const query = `
?[id, source_id, target_id, relationship_type, strength, created_at] :=
*memory_links[id, source_id, target_id, relationship_type, strength, created_at],
or(source_id == $memory_id, target_id == $memory_id)
`;
const result = await this.run(query, { memory_id: memoryId });
return result.rows.map(row => ({
id: row[0] as string,
sourceId: row[1] as string,
targetId: row[2] as string,
relationshipType: row[3] as string,
strength: row[4] as number,
createdAt: row[5] as string,
}));
}
async getStats(agentId?: string): Promise<StatsRow> {
let condition = '';
const params: Record<string, unknown> = {};
if (agentId) {
condition = ', agent_id == $agent_id';
params.agent_id = agentId;
}
const countQuery = `
?[count(id)] := *memories[id, agent_id, _, _, _, _, _, _, _, _, _, _]${condition}
`;
const countResult = await this.run(countQuery, params);
const total = countResult.rows[0]?.[0] as number ?? 0;
const categoryQuery = `
?[category, count(id)] := *memories[id, agent_id, category, _, _, _, _, _, _, _, _, _]${condition}
`;
const categoryResult = await this.run(categoryQuery, params);
const byCategory: Record<string, number> = {};
for (const row of categoryResult.rows) {
byCategory[row[0] as string] = row[1] as number;
}
const tierQuery = `
?[tier, count(id)] := *memories[id, agent_id, _, tier, _, _, _, _, _, _, _, _]${condition}
`;
const tierResult = await this.run(tierQuery, params);
const byTier: Record<string, number> = {};
for (const row of tierResult.rows) {
byTier[row[0] as string] = row[1] as number;
}
return {
total,
byCategory,
byTier,
};
}
private rowToMemory(row: unknown[]): MemoryRow {
return {
id: row[0] as string,
agentId: row[1] as string,
category: row[2] as string,
tier: row[3] as string,
content: row[4] as string,
reinforcementScore: row[5] as number,
createdAt: row[6] as string,
updatedAt: row[7] as string,
accessCount: row[8] as number,
lastAccessedAt: row[9] as string,
tags: row[10] as string[],
metadata: JSON.parse(row[11] as string),
};
}
get isInitialized(): boolean {
return this.initialized;
}
get path(): string {
return this.dbPath;
}
}
export interface CozoResult {
headers: string[];
rows: unknown[][];
ok: boolean;
}
export interface MemoryRow {
id: string;
agentId: string;
category: string;
tier: string;
content: string;
reinforcementScore: number;
createdAt: string;
updatedAt: string;
accessCount: number;
lastAccessedAt: string;
tags: string[];
metadata: Record<string, unknown>;
}
export interface LinkRow {
id: string;
sourceId: string;
targetId: string;
relationshipType: string;
strength: number;
createdAt: string;
}
export interface StatsRow {
total: number;
byCategory: Record<string, number>;
byTier: Record<string, number>;
}
-2
View File
@@ -1,2 +0,0 @@
export { CozoAdapter, type CozoAdapterOptions, type CozoResult, type MemoryRow, type LinkRow, type StatsRow } from './cozo-adapter.js';
export { initializeSchema, dropSchema } from './schema.js';
-137
View File
@@ -1,137 +0,0 @@
import type { CozoDb } from 'cozo-node';
export const MEMORY_SCHEMA = `
:create memories {
id: String
=>
agent_id: String,
category: String,
tier: String,
content: String,
reinforcement_score: Float,
created_at: String,
updated_at: String,
access_count: Int,
last_accessed_at: String,
tags: [String],
metadata: String
}
:create memory_vec {
id: String
=>
embedding: <F32; 384>
}
:create memory_links {
id: String
=>
source_id: String,
target_id: String,
relationship_type: String,
strength: Float,
created_at: String
}
::hnsw create memory_vec:embedding_idx {
dim: 384,
m: 16,
ef_construction: 100,
dtype: F32,
fields: [embedding],
distance: Cosine,
filter: null
}
`;
export const CREATE_MEMORIES_TABLE = `
:create memories {
id: String
=>
agent_id: String,
category: String,
tier: String,
content: String,
reinforcement_score: Float,
created_at: String,
updated_at: String,
access_count: Int,
last_accessed_at: String,
tags: [String],
metadata: String
}
`;
export const CREATE_MEMORY_VEC_TABLE = `
:create memory_vec {
id: String
=>
embedding: <F32; 384>
}
`;
export const CREATE_MEMORY_LINKS_TABLE = `
:create memory_links {
id: String
=>
source_id: String,
target_id: String,
relationship_type: String,
strength: Float,
created_at: String
}
`;
export const CREATE_HNSW_INDEX = `
::hnsw create memory_vec:embedding_idx {
dim: 384,
m: 16,
ef_construction: 100,
dtype: F32,
fields: [embedding],
distance: Cosine,
filter: null
}
`;
export async function initializeSchema(db: CozoDb): Promise<void> {
const tables = ['memories', 'memory_vec', 'memory_links'];
for (const table of tables) {
try {
await db.run(`?[id] := *${table}{id} :limit 1`);
} catch {
switch (table) {
case 'memories':
await db.run(CREATE_MEMORIES_TABLE);
break;
case 'memory_vec':
await db.run(CREATE_MEMORY_VEC_TABLE);
break;
case 'memory_links':
await db.run(CREATE_MEMORY_LINKS_TABLE);
break;
}
}
}
try {
await db.run(CREATE_HNSW_INDEX);
} catch {
}
}
export async function dropSchema(db: CozoDb): Promise<void> {
try {
await db.run('::hnsw drop memory_vec:embedding_idx');
} catch {
}
const tables = ['memory_links', 'memory_vec', 'memories'];
for (const table of tables) {
try {
await db.run(`::remove ${table}`);
} catch {
}
}
}
-140
View File
@@ -1,140 +0,0 @@
import { pipeline, env } from '@xenova/transformers';
import { DEFAULT_EMBEDDING_DIMENSION } from '../types.js';
env.cacheDir = './.cache/transformers';
let embeddingPipeline: any = null;
let initPromise: Promise<void> | null = null;
const DEFAULT_MODEL = 'Xenova/all-MiniLM-L6-v2';
export interface EncoderOptions {
model?: string;
cacheDir?: string;
}
export async function initializeEncoder(options: EncoderOptions = {}): Promise<void> {
if (embeddingPipeline) return;
if (initPromise) {
await initPromise;
return;
}
initPromise = (async () => {
if (options.cacheDir) {
env.cacheDir = options.cacheDir;
}
const modelName = options.model ?? DEFAULT_MODEL;
embeddingPipeline = await pipeline('feature-extraction', modelName, {
quantized: true,
} as any);
})();
try {
await initPromise;
} catch (error) {
initPromise = null;
throw error;
}
}
export async function encode(text: string): Promise<number[]> {
if (!embeddingPipeline) {
await initializeEncoder();
}
if (!embeddingPipeline) {
throw new Error('Failed to initialize embedding pipeline');
}
const output = await embeddingPipeline(text, {
pooling: 'mean',
normalize: true,
} as any);
const embedding = Array.from((output as any).data as Float32Array);
if (embedding.length !== DEFAULT_EMBEDDING_DIMENSION) {
throw new Error(
`Embedding dimension mismatch: expected ${DEFAULT_EMBEDDING_DIMENSION}, got ${embedding.length}`
);
}
return embedding;
}
export async function encodeBatch(texts: string[]): Promise<number[][]> {
if (texts.length === 0) return [];
if (!embeddingPipeline) {
await initializeEncoder();
}
if (!embeddingPipeline) {
throw new Error('Failed to initialize embedding pipeline');
}
const embeddings: number[][] = [];
for (const text of texts) {
const output = await embeddingPipeline(text, {
pooling: 'mean',
normalize: true,
} as any);
embeddings.push(Array.from((output as any).data as Float32Array));
}
return embeddings;
}
export function cosineSimilarity(a: number[], b: number[]): number {
if (a.length !== b.length) {
throw new Error('Vectors must have the same dimension');
}
let dotProduct = 0;
let normA = 0;
let normB = 0;
for (let i = 0; i < a.length; i++) {
dotProduct += a[i] * b[i];
normA += a[i] * a[i];
normB += b[i] * b[i];
}
const denominator = Math.sqrt(normA) * Math.sqrt(normB);
if (denominator === 0) return 0;
return dotProduct / denominator;
}
export function euclideanDistance(a: number[], b: number[]): number {
if (a.length !== b.length) {
throw new Error('Vectors must have the same dimension');
}
let sum = 0;
for (let i = 0; i < a.length; i++) {
const diff = a[i] - b[i];
sum += diff * diff;
}
return Math.sqrt(sum);
}
export function isEncoderReady(): boolean {
return embeddingPipeline !== null;
}
export async function disposeEncoder(): Promise<void> {
if (embeddingPipeline) {
try {
await embeddingPipeline.dispose();
} catch {
}
}
embeddingPipeline = null;
initPromise = null;
}
-16
View File
@@ -1,16 +0,0 @@
export {
initializeEncoder,
encode,
encodeBatch,
cosineSimilarity,
euclideanDistance,
isEncoderReady,
disposeEncoder,
type EncoderOptions,
} from './encoder.js';
export {
SemanticSearch,
quickSearch,
type SemanticSearchOptions,
} from './search.js';
-168
View File
@@ -1,168 +0,0 @@
import type { CozoAdapter } from '../database/cozo-adapter.js';
import type { PersistentMemory, MemorySearchOptions, MemorySearchResult } from '../types.js';
import { encode } from './encoder.js';
export interface SemanticSearchOptions extends MemorySearchOptions {
minScore?: number;
includeSimilar?: boolean;
maxSimilarPerResult?: number;
}
export class SemanticSearch {
constructor(private adapter: CozoAdapter) {}
async search(
query: string,
options: SemanticSearchOptions = {}
): Promise<MemorySearchResult[]> {
const {
agentId,
category,
tier,
limit = 10,
threshold = 0.5,
minScore = 0,
} = options;
const queryEmbedding = await encode(query);
const results = await this.adapter.semanticSearch(
queryEmbedding,
limit * 5,
agentId,
category,
tier
);
const searchResults: MemorySearchResult[] = [];
for (const { id, score } of results) {
if (score < Math.max(threshold, minScore)) continue;
if (searchResults.length >= limit) break;
const memory = await this.adapter.getMemory(id);
if (!memory) continue;
if (agentId && memory.agentId !== agentId) continue;
if (category && memory.category !== category) continue;
if (tier && memory.tier !== tier) continue;
searchResults.push({
memory: this.rowToMemory(memory),
score,
});
}
return searchResults;
}
async findSimilar(
memoryId: string,
limit = 5,
excludeSelf = true
): Promise<MemorySearchResult[]> {
const memory = await this.adapter.getMemory(memoryId);
if (!memory) {
throw new Error(`Memory ${memoryId} not found`);
}
const embedding = await encode(memory.content);
const results = await this.adapter.semanticSearch(
embedding,
limit + (excludeSelf ? 1 : 0),
memory.agentId
);
const searchResults: MemorySearchResult[] = [];
for (const { id, score } of results) {
if (excludeSelf && id === memoryId) continue;
if (searchResults.length >= limit) break;
const similarMemory = await this.adapter.getMemory(id);
if (!similarMemory) continue;
searchResults.push({
memory: this.rowToMemory(similarMemory),
score,
});
}
return searchResults;
}
async searchByCategory(
query: string,
category: string,
limit = 10
): Promise<MemorySearchResult[]> {
return this.search(query, { category: category as any, limit });
}
async searchByTier(
query: string,
tier: 'warm' | 'long',
limit = 10
): Promise<MemorySearchResult[]> {
return this.search(query, { tier, limit });
}
async hybridSearch(
query: string,
keywords: string[],
options: SemanticSearchOptions = {}
): Promise<MemorySearchResult[]> {
const semanticResults = await this.search(query, {
...options,
limit: (options.limit ?? 10) * 2,
});
const scoredResults = semanticResults.map(result => {
let keywordBoost = 0;
const contentLower = result.memory.content.toLowerCase();
for (const keyword of keywords) {
if (contentLower.includes(keyword.toLowerCase())) {
keywordBoost += 0.1;
}
}
return {
...result,
score: Math.min(1, result.score + keywordBoost),
};
});
scoredResults.sort((a, b) => b.score - a.score);
return scoredResults.slice(0, options.limit ?? 10);
}
private rowToMemory(row: any): PersistentMemory {
return {
id: row.id,
agentId: row.agentId,
category: row.category as PersistentMemory['category'],
tier: row.tier as PersistentMemory['tier'],
content: row.content,
embedding: row.embedding || [],
reinforcementScore: row.reinforcementScore,
createdAt: row.createdAt,
updatedAt: row.updatedAt,
accessCount: row.accessCount,
lastAccessedAt: row.lastAccessedAt,
tags: row.tags,
metadata: row.metadata,
};
}
}
export async function quickSearch(
adapter: CozoAdapter,
query: string,
options: SemanticSearchOptions = {}
): Promise<MemorySearchResult[]> {
const search = new SemanticSearch(adapter);
return search.search(query, options);
}
-29
View File
@@ -1,29 +0,0 @@
export * from './types.js';
export { CozoAdapter, type CozoAdapterOptions, type CozoResult, type MemoryRow, type LinkRow, type StatsRow } from './database/index.js';
export { initializeSchema, dropSchema } from './database/index.js';
export {
initializeEncoder,
encode,
encodeBatch,
cosineSimilarity,
euclideanDistance,
isEncoderReady,
disposeEncoder,
type EncoderOptions,
SemanticSearch,
quickSearch,
type SemanticSearchOptions,
} from './embeddings/index.js';
export { MemoryStore } from './stores/index.js';
export { TierManager, createTierManager, type TierEvaluationResult } from './tiers/index.js';
export async function createMemoryStore(agentId: string, dbPath?: string): Promise<import('./stores/memory-store.js').MemoryStore> {
const { MemoryStore } = await import('./stores/memory-store.js');
const store = new MemoryStore(agentId, dbPath);
await store.initialize();
return store;
}
-1
View File
@@ -1 +0,0 @@
export { MemoryStore } from './memory-store.js';
-287
View File
@@ -1,287 +0,0 @@
import { randomUUID } from 'node:crypto';
import { CozoAdapter } from '../database/cozo-adapter.js';
import { encode } from '../embeddings/encoder.js';
import type {
PersistentMemory,
MemoryCreateInput,
MemoryUpdateInput,
MemoryCategory,
MemoryTier,
MemoryLink,
MemoryStats,
MemorySearchResult,
MemorySearchOptions,
} from '../types.js';
import { SemanticSearch } from '../embeddings/search.js';
export class MemoryStore {
private adapter: CozoAdapter;
private search: SemanticSearch;
constructor(agentId: string, dbPath?: string) {
this.adapter = new CozoAdapter({ agentId, dbPath });
this.search = new SemanticSearch(this.adapter);
}
async initialize(): Promise<void> {
await this.adapter.initialize();
}
async close(): Promise<void> {
await this.adapter.close();
}
async create(input: MemoryCreateInput): Promise<PersistentMemory> {
const id = randomUUID();
const now = new Date().toISOString();
const embedding = await encode(input.content);
await this.adapter.insertMemory(
id,
input.agentId,
input.category,
input.tier ?? 'warm',
input.content,
1.0,
now,
now,
0,
now,
input.tags ?? [],
input.metadata ?? {}
);
await this.adapter.insertEmbedding(id, embedding);
return {
id,
agentId: input.agentId,
category: input.category,
tier: input.tier ?? 'warm',
content: input.content,
embedding,
reinforcementScore: 1.0,
createdAt: now,
updatedAt: now,
accessCount: 0,
lastAccessedAt: now,
tags: input.tags ?? [],
metadata: input.metadata ?? {},
};
}
async get(id: string): Promise<PersistentMemory | null> {
const row = await this.adapter.getMemory(id);
if (!row) return null;
await this.adapter.updateMemory(id, {
accessCount: row.accessCount + 1,
lastAccessedAt: new Date().toISOString(),
});
return {
id: row.id,
agentId: row.agentId,
category: row.category as MemoryCategory,
tier: row.tier as MemoryTier,
content: row.content,
embedding: [],
reinforcementScore: row.reinforcementScore,
createdAt: row.createdAt,
updatedAt: row.updatedAt,
accessCount: row.accessCount + 1,
lastAccessedAt: new Date().toISOString(),
tags: row.tags,
metadata: row.metadata,
};
}
async update(id: string, input: MemoryUpdateInput): Promise<PersistentMemory> {
const existing = await this.adapter.getMemory(id);
if (!existing) {
throw new Error(`Memory ${id} not found`);
}
const updates: Record<string, unknown> = {
updatedAt: new Date().toISOString(),
};
if (input.category) updates.category = input.category;
if (input.tier) updates.tier = input.tier;
if (input.tags) updates.tags = input.tags;
if (input.metadata) updates.metadata = input.metadata;
if (input.content && input.content !== existing.content) {
updates.content = input.content;
const embedding = await encode(input.content);
await this.adapter.insertEmbedding(id, embedding);
}
await this.adapter.updateMemory(id, updates as any);
const updated = await this.adapter.getMemory(id);
if (!updated) {
throw new Error(`Failed to update memory ${id}`);
}
return {
id: updated.id,
agentId: updated.agentId,
category: updated.category as MemoryCategory,
tier: updated.tier as MemoryTier,
content: updated.content,
embedding: [],
reinforcementScore: updated.reinforcementScore,
createdAt: updated.createdAt,
updatedAt: updated.updatedAt,
accessCount: updated.accessCount,
lastAccessedAt: updated.lastAccessedAt,
tags: updated.tags,
metadata: updated.metadata,
};
}
async delete(id: string): Promise<void> {
await this.adapter.deleteMemory(id);
}
async list(agentId: string, limit = 100): Promise<PersistentMemory[]> {
const rows = await this.adapter.getMemoriesByAgent(agentId, limit);
return rows.map(row => ({
id: row.id,
agentId: row.agentId,
category: row.category as MemoryCategory,
tier: row.tier as MemoryTier,
content: row.content,
embedding: [],
reinforcementScore: row.reinforcementScore,
createdAt: row.createdAt,
updatedAt: row.updatedAt,
accessCount: row.accessCount,
lastAccessedAt: row.lastAccessedAt,
tags: row.tags,
metadata: row.metadata,
}));
}
async semanticSearch(
query: string,
options: MemorySearchOptions = {}
): Promise<MemorySearchResult[]> {
return this.search.search(query, options);
}
async findSimilar(memoryId: string, limit = 5): Promise<MemorySearchResult[]> {
return this.search.findSimilar(memoryId, limit);
}
async reinforce(id: string, amount = 0.1): Promise<PersistentMemory> {
const existing = await this.adapter.getMemory(id);
if (!existing) {
throw new Error(`Memory ${id} not found`);
}
const newScore = Math.min(1, existing.reinforcementScore + amount);
await this.adapter.updateMemory(id, {
reinforcementScore: newScore,
updatedAt: new Date().toISOString(),
});
return this.get(id) as Promise<PersistentMemory>;
}
async weaken(id: string, amount = 0.1): Promise<PersistentMemory> {
const existing = await this.adapter.getMemory(id);
if (!existing) {
throw new Error(`Memory ${id} not found`);
}
const newScore = Math.max(0, existing.reinforcementScore - amount);
await this.adapter.updateMemory(id, {
reinforcementScore: newScore,
updatedAt: new Date().toISOString(),
});
return this.get(id) as Promise<PersistentMemory>;
}
async link(
sourceId: string,
targetId: string,
relationshipType: MemoryLink['relationshipType'],
strength = 1.0
): Promise<MemoryLink> {
const id = randomUUID();
const now = new Date().toISOString();
await this.adapter.insertLink(id, sourceId, targetId, relationshipType, strength, now);
return {
id,
sourceId,
targetId,
relationshipType,
strength,
createdAt: now,
};
}
async getLinks(memoryId: string): Promise<MemoryLink[]> {
const rows = await this.adapter.getLinks(memoryId);
return rows.map(row => ({
id: row.id,
sourceId: row.sourceId,
targetId: row.targetId,
relationshipType: row.relationshipType as MemoryLink['relationshipType'],
strength: row.strength,
createdAt: row.createdAt,
}));
}
async getStats(agentId?: string): Promise<MemoryStats> {
const stats = await this.adapter.getStats(agentId);
const byCategory: Record<MemoryCategory, number> = {
fact: stats.byCategory.fact ?? 0,
decision: stats.byCategory.decision ?? 0,
preference: stats.byCategory.preference ?? 0,
pattern: stats.byCategory.pattern ?? 0,
insight: stats.byCategory.insight ?? 0,
reasoning: stats.byCategory.reasoning ?? 0,
};
const byTier: Record<MemoryTier, number> = {
warm: stats.byTier.warm ?? 0,
long: stats.byTier.long ?? 0,
};
return {
totalMemories: stats.total,
byCategory,
byTier,
avgReinforcementScore: 0,
oldestMemory: null,
newestMemory: null,
};
}
async promoteToLongTerm(id: string): Promise<PersistentMemory> {
return this.update(id, { tier: 'long' });
}
async demoteToWarm(id: string): Promise<PersistentMemory> {
return this.update(id, { tier: 'warm' });
}
get isInitialized(): boolean {
return this.adapter.isInitialized;
}
get dbPath(): string {
return this.adapter.path;
}
}
-1
View File
@@ -1 +0,0 @@
export { TierManager, createTierManager, type TierEvaluationResult } from './tier-manager.js';
-164
View File
@@ -1,164 +0,0 @@
import type { MemoryStore } from '../stores/memory-store.js';
import type {
PersistentMemory,
TierPromotionConfig,
MemoryTier,
} from '../types.js';
import { DEFAULT_TIER_PROMOTION_CONFIG } from '../types.js';
export interface TierEvaluationResult {
memoryId: string;
currentTier: MemoryTier;
suggestedTier: MemoryTier;
reason: string;
score: number;
}
export class TierManager {
private config: TierPromotionConfig;
constructor(config: Partial<TierPromotionConfig> = {}) {
this.config = { ...DEFAULT_TIER_PROMOTION_CONFIG, ...config };
}
evaluateForPromotion(memory: PersistentMemory): TierEvaluationResult {
const score = this.calculatePromotionScore(memory);
const threshold = 0.7;
const shouldPromote = memory.tier === 'warm' && score >= threshold;
const shouldDemote = memory.tier === 'long' && score < 0.3;
let suggestedTier = memory.tier;
let reason = 'Memory is appropriately tiered';
if (shouldPromote) {
suggestedTier = 'long';
reason = this.getPromotionReason(memory);
} else if (shouldDemote) {
suggestedTier = 'warm';
reason = this.getDemotionReason(memory);
}
return {
memoryId: memory.id,
currentTier: memory.tier,
suggestedTier,
reason,
score,
};
}
calculatePromotionScore(memory: PersistentMemory): number {
const accessScore = Math.min(1, memory.accessCount / this.config.accessCountThreshold);
const reinforcementScore = memory.reinforcementScore / this.config.reinforcementScoreThreshold;
const ageMs = Date.now() - new Date(memory.createdAt).getTime();
const ageDays = ageMs / (1000 * 60 * 60 * 24);
const ageScore = Math.min(1, ageDays / this.config.ageThresholdDays);
const recencyMs = Date.now() - new Date(memory.lastAccessedAt).getTime();
const recencyDays = recencyMs / (1000 * 60 * 60 * 24);
const recencyScore = Math.max(0, 1 - recencyDays / 30);
const weights = {
access: 0.3,
reinforcement: 0.35,
age: 0.15,
recency: 0.2,
};
return (
accessScore * weights.access +
Math.min(1, reinforcementScore) * weights.reinforcement +
ageScore * weights.age +
recencyScore * weights.recency
);
}
async evaluateAll(store: MemoryStore, agentId: string): Promise<TierEvaluationResult[]> {
const memories = await store.list(agentId);
return memories.map(memory => this.evaluateForPromotion(memory));
}
async applyRecommendations(
store: MemoryStore,
evaluations: TierEvaluationResult[]
): Promise<{ promoted: string[]; demoted: string[] }> {
const promoted: string[] = [];
const demoted: string[] = [];
for (const evaluation of evaluations) {
if (evaluation.currentTier === evaluation.suggestedTier) continue;
if (evaluation.suggestedTier === 'long') {
await store.promoteToLongTerm(evaluation.memoryId);
promoted.push(evaluation.memoryId);
} else {
await store.demoteToWarm(evaluation.memoryId);
demoted.push(evaluation.memoryId);
}
}
return { promoted, demoted };
}
async autoPromote(
store: MemoryStore,
agentId: string
): Promise<{ promoted: string[]; demoted: string[] }> {
const evaluations = await this.evaluateAll(store, agentId);
return this.applyRecommendations(store, evaluations);
}
getConfig(): TierPromotionConfig {
return { ...this.config };
}
updateConfig(updates: Partial<TierPromotionConfig>): void {
this.config = { ...this.config, ...updates };
}
private getPromotionReason(memory: PersistentMemory): string {
const reasons: string[] = [];
if (memory.accessCount >= this.config.accessCountThreshold) {
reasons.push(`accessed ${memory.accessCount} times`);
}
if (memory.reinforcementScore >= this.config.reinforcementScoreThreshold) {
reasons.push(`high reinforcement (${memory.reinforcementScore.toFixed(2)})`);
}
const ageDays = (Date.now() - new Date(memory.createdAt).getTime()) / (1000 * 60 * 60 * 24);
if (ageDays >= this.config.ageThresholdDays) {
reasons.push(`${Math.floor(ageDays)} days old`);
}
return reasons.length > 0
? `Promote to long-term: ${reasons.join(', ')}`
: 'Memory qualifies for long-term storage';
}
private getDemotionReason(memory: PersistentMemory): string {
const reasons: string[] = [];
if (memory.reinforcementScore < 0.3) {
reasons.push(`low reinforcement (${memory.reinforcementScore.toFixed(2)})`);
}
const recencyDays =
(Date.now() - new Date(memory.lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
if (recencyDays > 30) {
reasons.push(`not accessed in ${Math.floor(recencyDays)} days`);
}
return reasons.length > 0
? `Demote to warm: ${reasons.join(', ')}`
: 'Memory no longer qualifies for long-term storage';
}
}
export function createTierManager(config?: Partial<TierPromotionConfig>): TierManager {
return new TierManager(config);
}
-94
View File
@@ -1,94 +0,0 @@
export type MemoryCategory =
| 'fact'
| 'decision'
| 'preference'
| 'pattern'
| 'insight'
| 'reasoning';
export type MemoryTier = 'warm' | 'long';
export interface PersistentMemory {
id: string;
agentId: string;
category: MemoryCategory;
tier: MemoryTier;
content: string;
embedding: number[];
reinforcementScore: number;
createdAt: string;
updatedAt: string;
accessCount: number;
lastAccessedAt: string;
tags: string[];
metadata: Record<string, unknown>;
}
export interface MemoryCreateInput {
agentId: string;
category: MemoryCategory;
content: string;
tier?: MemoryTier;
tags?: string[];
metadata?: Record<string, unknown>;
}
export interface MemoryUpdateInput {
category?: MemoryCategory;
tier?: MemoryTier;
content?: string;
tags?: string[];
metadata?: Record<string, unknown>;
}
export interface MemorySearchOptions {
agentId?: string;
category?: MemoryCategory;
tier?: MemoryTier;
tags?: string[];
limit?: number;
threshold?: number;
}
export interface MemorySearchResult {
memory: PersistentMemory;
score: number;
}
export interface MemoryLink {
id: string;
sourceId: string;
targetId: string;
relationshipType: 'related' | 'derived' | 'contradicts' | 'supports';
strength: number;
createdAt: string;
}
export interface MemoryStats {
totalMemories: number;
byCategory: Record<MemoryCategory, number>;
byTier: Record<MemoryTier, number>;
avgReinforcementScore: number;
oldestMemory: string | null;
newestMemory: string | null;
}
export interface TierPromotionConfig {
accessCountThreshold: number;
reinforcementScoreThreshold: number;
ageThresholdDays: number;
}
export const DEFAULT_TIER_PROMOTION_CONFIG: TierPromotionConfig = {
accessCountThreshold: 5,
reinforcementScoreThreshold: 0.7,
ageThresholdDays: 7,
};
export interface MemoryDatabaseConfig {
dbPath: string;
embeddingDimension: number;
maxConnections: number;
}
export const DEFAULT_EMBEDDING_DIMENSION = 384;
-10
View File
@@ -1,10 +0,0 @@
{
"extends": "../../tsconfig.base.json",
"compilerOptions": {
"outDir": "./dist",
"rootDir": "./src",
"composite": false
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist", "**/*.test.ts"]
}
-14
View File
@@ -1,14 +0,0 @@
import { defineConfig } from 'tsup';
export default defineConfig({
entry: ['src/index.ts'],
format: ['esm'],
target: 'node18',
outDir: 'dist',
clean: true,
dts: true,
sourcemap: true,
splitting: false,
skipNodeModulesBundle: true,
platform: 'node',
});
-220
View File
@@ -1,220 +0,0 @@
# @skillkit/mesh
[![npm version](https://img.shields.io/npm/v/@skillkit/mesh.svg)](https://www.npmjs.com/package/@skillkit/mesh)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
**Peer mesh network for SkillKit** - Multi-machine agent distribution with secure peer-to-peer communication.
## Installation
```bash
npm install @skillkit/mesh
```
## Key Features
- **Peer Discovery**: UDP multicast LAN discovery with signed announcements
- **Multi-Transport**: HTTP, WebSocket, and UDP transport layers
- **Ed25519 Cryptography**: Peer identity, message signing, and verification
- **XChaCha20-Poly1305**: End-to-end message encryption
- **TLS Support**: Self-signed certificates for secure transport
- **JWT Authentication**: Challenge-response handshake with EdDSA tokens
- **Health Monitoring**: Automatic peer health checks with latency tracking
- **Trust Management**: Peer trust/revoke with fingerprint-based verification
## Usage
### Initialize Mesh Network
```typescript
import { MeshHost, PeerIdentity, MeshSecurityConfig } from '@skillkit/mesh';
// Generate or load identity
const identity = await PeerIdentity.generate();
console.log('Fingerprint:', identity.fingerprint);
// Configure security
const security: MeshSecurityConfig = {
discovery: { mode: 'signed' },
transport: { encryption: 'required', tls: 'self-signed', requireAuth: true },
trust: { autoTrustFirst: true },
};
// Create mesh host
const host = new MeshHost({
hostId: 'my-workstation',
identity,
security,
});
await host.start();
```
### Discover Peers
```typescript
import { LocalDiscovery } from '@skillkit/mesh';
// Start discovery
const discovery = new LocalDiscovery({
identity,
port: 41234,
});
discovery.on('peer', (peer) => {
console.log('Found peer:', peer.hostId, peer.fingerprint);
});
await discovery.start();
await discovery.announce();
```
### Send Messages
```typescript
// Send to a specific peer
await host.send('peer-fingerprint', {
type: 'skill-sync',
payload: { skills: ['react-patterns', 'api-design'] },
});
// Broadcast to all peers
await host.broadcast({
type: 'announcement',
payload: { message: 'New skill available' },
});
```
### Secure Transport
```typescript
import { SecureWebSocketTransport, TLSManager } from '@skillkit/mesh';
// Generate TLS certificate
const certInfo = await TLSManager.generateCertificate(identity, 'my-host');
// Create secure WebSocket transport
const transport = new SecureWebSocketTransport({
port: 8443,
tls: {
cert: certInfo.cert,
key: certInfo.key,
},
requireAuth: true,
});
await transport.listen();
```
### Trust Management
```typescript
import { SecureKeystore } from '@skillkit/mesh';
// Initialize keystore
const keystore = new SecureKeystore({
path: '~/.skillkit/mesh/identity',
});
// Trust a peer
await keystore.addTrustedPeer(peerFingerprint, peerPublicKey);
// Revoke trust
await keystore.revokePeer(peerFingerprint);
// List trusted peers
const trusted = await keystore.getTrustedPeers();
```
## Security Levels
| Level | Discovery | Transport | Auth | Use Case |
|-------|-----------|-----------|------|----------|
| `development` | open | none | none | Local dev |
| `signed` | signed | optional | optional | Trusted LAN |
| `secure` (default) | signed | required | required | Production |
| `strict` | trusted-only | required | mTLS | High security |
## API Reference
### MeshHost
```typescript
interface MeshHost {
start(): Promise<void>;
stop(): Promise<void>;
send(peerId: string, message: TransportMessage): Promise<void>;
broadcast(message: TransportMessage): Promise<void>;
getPeers(): PeerInfo[];
on(event: 'message' | 'peer' | 'disconnect', handler: Function): void;
}
```
### PeerIdentity
```typescript
interface PeerIdentity {
static generate(): Promise<PeerIdentity>;
static fromPrivateKey(key: Uint8Array): Promise<PeerIdentity>;
static load(path: string, passphrase?: string): Promise<PeerIdentity>;
save(path: string, passphrase?: string): Promise<void>;
sign(message: Uint8Array): Promise<Uint8Array>;
static verify(sig: Uint8Array, msg: Uint8Array, pubKey: Uint8Array): Promise<boolean>;
deriveSharedSecret(peerPublicKey: Uint8Array): Uint8Array;
get publicKey(): Uint8Array;
get fingerprint(): string;
}
```
### Types
```typescript
interface PeerInfo {
hostId: string;
fingerprint: string;
address: string;
port: number;
status: 'online' | 'offline';
latency?: number;
}
interface TransportMessage {
type: string;
payload: unknown;
signature?: string;
senderFingerprint?: string;
}
interface MeshSecurityConfig {
discovery: { mode: 'open' | 'signed' | 'trusted-only' };
transport: { encryption: 'none' | 'optional' | 'required'; tls: 'none' | 'self-signed' | 'ca-signed'; requireAuth: boolean };
trust: { autoTrustFirst: boolean; requireManualApproval?: boolean; trustedFingerprints?: string[] };
}
```
## CLI Commands
```bash
skillkit mesh init # Initialize mesh network
skillkit mesh add <address> # Add a host to mesh
skillkit mesh remove <id> # Remove a host
skillkit mesh list # List known hosts
skillkit mesh discover # Discover hosts on LAN
skillkit mesh health # Check host health
skillkit mesh status # Show mesh status
# Security
skillkit mesh security init # Setup encryption keys
skillkit mesh security status # Show security status
skillkit mesh peer trust <id> # Trust a peer
skillkit mesh peer revoke <id># Revoke peer trust
skillkit mesh peer list # List trusted peers
```
## Documentation
Full documentation: https://github.com/rohitg00/skillkit
## License
Apache-2.0
-56
View File
@@ -1,56 +0,0 @@
{
"name": "@skillkit/mesh",
"version": "1.8.0",
"description": "Peer mesh network for multi-machine agent distribution",
"type": "module",
"main": "./dist/index.js",
"types": "./dist/index.d.ts",
"exports": {
".": {
"import": "./dist/index.js",
"types": "./dist/index.d.ts"
}
},
"files": [
"dist"
],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
"typecheck": "tsc --noEmit",
"test": "vitest run",
"test:watch": "vitest"
},
"dependencies": {
"@skillkit/core": "workspace:*",
"@noble/ed25519": "^2.1.0",
"@noble/curves": "^1.7.0",
"@noble/ciphers": "^1.0.0",
"@noble/hashes": "^1.5.0",
"jose": "^5.8.0",
"ws": "^8.16.0",
"got": "^14.2.0"
},
"devDependencies": {
"@types/ws": "^8.5.10",
"tsup": "^8.0.1",
"typescript": "^5.3.3",
"vitest": "^1.2.0"
},
"engines": {
"node": ">=18"
},
"repository": {
"type": "git",
"url": "https://github.com/rohitg00/skillkit.git",
"directory": "packages/mesh"
},
"keywords": [
"skillkit",
"mesh",
"peer",
"network",
"distributed"
],
"license": "Apache-2.0"
}
-10
View File
@@ -1,10 +0,0 @@
import { describe, it, expect } from 'vitest';
describe('@skillkit/mesh', () => {
it('should export types and constants', async () => {
const mesh = await import('../index.js');
expect(mesh).toBeDefined();
expect(mesh.DEFAULT_PORT).toBe(9876);
expect(mesh.MESH_VERSION).toBe('1.7.11');
});
});
-146
View File
@@ -1,146 +0,0 @@
import { readFile, writeFile, mkdir } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { homedir, hostname as osHostname } from 'node:os';
import { randomUUID } from 'node:crypto';
import type { Host, HostConfig, HostsFile } from '../types.js';
import { DEFAULT_PORT, MESH_VERSION } from '../types.js';
const HOSTS_FILE_PATH = join(homedir(), '.skillkit', 'hosts.json');
let fileLock: Promise<void> | null = null;
async function withFileLock<T>(fn: () => Promise<T>): Promise<T> {
while (fileLock) {
await fileLock;
}
let resolve: () => void;
fileLock = new Promise<void>(r => { resolve = r; });
try {
return await fn();
} finally {
fileLock = null;
resolve!();
}
}
export async function getHostsFilePath(): Promise<string> {
return HOSTS_FILE_PATH;
}
export async function loadHostsFile(): Promise<HostsFile> {
if (!existsSync(HOSTS_FILE_PATH)) {
return createDefaultHostsFile();
}
try {
const content = await readFile(HOSTS_FILE_PATH, 'utf-8');
return JSON.parse(content) as HostsFile;
} catch {
return createDefaultHostsFile();
}
}
export async function saveHostsFile(hostsFile: HostsFile): Promise<void> {
await mkdir(dirname(HOSTS_FILE_PATH), { recursive: true });
hostsFile.lastUpdated = new Date().toISOString();
await writeFile(HOSTS_FILE_PATH, JSON.stringify(hostsFile, null, 2), 'utf-8');
}
export function createDefaultHostsFile(): HostsFile {
return {
version: MESH_VERSION,
localHost: {
id: randomUUID(),
name: getDefaultHostName(),
port: DEFAULT_PORT,
autoStart: false,
discoveryEnabled: true,
},
knownHosts: [],
lastUpdated: new Date().toISOString(),
};
}
function getDefaultHostName(): string {
const hostname = osHostname();
return hostname || `skillkit-host-${randomUUID().slice(0, 8)}`;
}
export async function getLocalHostConfig(): Promise<HostConfig> {
const hostsFile = await loadHostsFile();
return hostsFile.localHost;
}
export async function updateLocalHostConfig(updates: Partial<HostConfig>): Promise<HostConfig> {
return withFileLock(async () => {
const hostsFile = await loadHostsFile();
hostsFile.localHost = { ...hostsFile.localHost, ...updates };
await saveHostsFile(hostsFile);
return hostsFile.localHost;
});
}
export async function addKnownHost(host: Host): Promise<void> {
return withFileLock(async () => {
const hostsFile = await loadHostsFile();
const existingIndex = hostsFile.knownHosts.findIndex(h => h.id === host.id);
if (existingIndex >= 0) {
hostsFile.knownHosts[existingIndex] = host;
} else {
hostsFile.knownHosts.push(host);
}
await saveHostsFile(hostsFile);
});
}
export async function removeKnownHost(hostId: string): Promise<boolean> {
return withFileLock(async () => {
const hostsFile = await loadHostsFile();
const initialLength = hostsFile.knownHosts.length;
hostsFile.knownHosts = hostsFile.knownHosts.filter(h => h.id !== hostId);
if (hostsFile.knownHosts.length < initialLength) {
await saveHostsFile(hostsFile);
return true;
}
return false;
});
}
export async function getKnownHosts(): Promise<Host[]> {
const hostsFile = await loadHostsFile();
return hostsFile.knownHosts;
}
export async function getKnownHost(hostId: string): Promise<Host | undefined> {
const hosts = await getKnownHosts();
return hosts.find(h => h.id === hostId);
}
export async function updateKnownHost(hostId: string, updates: Partial<Host>): Promise<Host | null> {
const hostsFile = await loadHostsFile();
const index = hostsFile.knownHosts.findIndex(h => h.id === hostId);
if (index < 0) return null;
hostsFile.knownHosts[index] = { ...hostsFile.knownHosts[index], ...updates };
await saveHostsFile(hostsFile);
return hostsFile.knownHosts[index];
}
export async function initializeHostsFile(): Promise<HostsFile> {
if (!existsSync(HOSTS_FILE_PATH)) {
const hostsFile = createDefaultHostsFile();
await saveHostsFile(hostsFile);
return hostsFile;
}
return loadHostsFile();
}
-14
View File
@@ -1,14 +0,0 @@
export {
loadHostsFile,
saveHostsFile,
createDefaultHostsFile,
getLocalHostConfig,
updateLocalHostConfig,
addKnownHost,
removeKnownHost,
getKnownHosts,
getKnownHost,
updateKnownHost,
initializeHostsFile,
getHostsFilePath,
} from './hosts-config.js';
-145
View File
@@ -1,145 +0,0 @@
import { xchacha20poly1305 } from '@noble/ciphers/chacha';
import { randomBytes } from '@noble/ciphers/webcrypto';
import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
import { hkdf } from '@noble/hashes/hkdf';
import { sha256 } from '@noble/hashes/sha256';
import { x25519 } from '@noble/curves/ed25519';
export interface EncryptedMessage {
nonce: string;
ciphertext: string;
}
export interface PublicKeyEncryptedMessage {
ephemeralPublicKey: string;
nonce: string;
ciphertext: string;
}
export class MessageEncryption {
private key: Uint8Array;
constructor(sharedSecret: Uint8Array) {
this.key = hkdf(sha256, sharedSecret, undefined, 'skillkit-mesh-v1', 32);
}
encrypt(plaintext: string | Uint8Array): EncryptedMessage {
const nonce = randomBytes(24);
const data =
typeof plaintext === 'string'
? new TextEncoder().encode(plaintext)
: plaintext;
const cipher = xchacha20poly1305(this.key, nonce);
const ciphertext = cipher.encrypt(data);
return {
nonce: bytesToHex(nonce),
ciphertext: bytesToHex(ciphertext),
};
}
decrypt(encrypted: EncryptedMessage): Uint8Array {
const nonce = hexToBytes(encrypted.nonce);
const ciphertext = hexToBytes(encrypted.ciphertext);
const cipher = xchacha20poly1305(this.key, nonce);
return cipher.decrypt(ciphertext);
}
decryptToString(encrypted: EncryptedMessage): string {
const plaintext = this.decrypt(encrypted);
return new TextDecoder().decode(plaintext);
}
decryptToObject<T = unknown>(encrypted: EncryptedMessage): T {
const plaintext = this.decryptToString(encrypted);
return JSON.parse(plaintext) as T;
}
encryptObject(obj: unknown): EncryptedMessage {
return this.encrypt(JSON.stringify(obj));
}
static fromSharedSecret(sharedSecret: Uint8Array): MessageEncryption {
return new MessageEncryption(sharedSecret);
}
}
export class PublicKeyEncryption {
static encrypt(
message: Uint8Array,
recipientPublicKey: Uint8Array
): PublicKeyEncryptedMessage {
const ephemeralPrivateKey = randomBytes(32);
const ephemeralPublicKey = x25519.scalarMultBase(ephemeralPrivateKey);
const sharedSecret = x25519.scalarMult(ephemeralPrivateKey, recipientPublicKey);
const key = hkdf(sha256, sharedSecret, undefined, 'skillkit-mesh-pk-v1', 32);
const nonce = randomBytes(24);
const cipher = xchacha20poly1305(key, nonce);
const ciphertext = cipher.encrypt(message);
return {
ephemeralPublicKey: bytesToHex(ephemeralPublicKey),
nonce: bytesToHex(nonce),
ciphertext: bytesToHex(ciphertext),
};
}
static encryptString(
message: string,
recipientPublicKey: Uint8Array
): PublicKeyEncryptedMessage {
const messageBytes = new TextEncoder().encode(message);
return PublicKeyEncryption.encrypt(messageBytes, recipientPublicKey);
}
static encryptStringHex(
message: string,
recipientPublicKeyHex: string
): PublicKeyEncryptedMessage {
const recipientPublicKey = hexToBytes(recipientPublicKeyHex);
return PublicKeyEncryption.encryptString(message, recipientPublicKey);
}
static decrypt(
encrypted: PublicKeyEncryptedMessage,
recipientPrivateKey: Uint8Array
): Uint8Array {
const ephemeralPublicKey = hexToBytes(encrypted.ephemeralPublicKey);
const nonce = hexToBytes(encrypted.nonce);
const ciphertext = hexToBytes(encrypted.ciphertext);
const sharedSecret = x25519.scalarMult(recipientPrivateKey, ephemeralPublicKey);
const key = hkdf(sha256, sharedSecret, undefined, 'skillkit-mesh-pk-v1', 32);
const cipher = xchacha20poly1305(key, nonce);
return cipher.decrypt(ciphertext);
}
static decryptToString(
encrypted: PublicKeyEncryptedMessage,
recipientPrivateKey: Uint8Array
): string {
const plaintext = PublicKeyEncryption.decrypt(encrypted, recipientPrivateKey);
return new TextDecoder().decode(plaintext);
}
static decryptToObject<T = unknown>(
encrypted: PublicKeyEncryptedMessage,
recipientPrivateKey: Uint8Array
): T {
const plaintext = PublicKeyEncryption.decryptToString(
encrypted,
recipientPrivateKey
);
return JSON.parse(plaintext) as T;
}
}
export function generateNonce(): string {
return bytesToHex(randomBytes(24));
}
export function generateMessageId(): string {
return bytesToHex(randomBytes(16));
}
-161
View File
@@ -1,161 +0,0 @@
import * as ed25519 from '@noble/ed25519';
import { x25519 } from '@noble/curves/ed25519';
import { sha256 } from '@noble/hashes/sha256';
import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
import { randomBytes } from '@noble/ciphers/webcrypto';
export interface PeerKeypair {
publicKey: Uint8Array;
privateKey: Uint8Array;
fingerprint: string;
}
export interface SerializedIdentity {
publicKey: string;
privateKey: string;
fingerprint: string;
}
export class PeerIdentity {
private keypair: PeerKeypair;
private constructor(keypair: PeerKeypair) {
this.keypair = keypair;
}
static async generate(): Promise<PeerIdentity> {
const privateKey = randomBytes(32);
const publicKey = await ed25519.getPublicKeyAsync(privateKey);
const fingerprint = PeerIdentity.computeFingerprint(publicKey);
return new PeerIdentity({
publicKey,
privateKey,
fingerprint,
});
}
static async fromPrivateKey(privateKey: Uint8Array): Promise<PeerIdentity> {
if (privateKey.length !== 32) {
throw new Error('Private key must be 32 bytes');
}
const publicKey = await ed25519.getPublicKeyAsync(privateKey);
const fingerprint = PeerIdentity.computeFingerprint(publicKey);
return new PeerIdentity({
publicKey,
privateKey,
fingerprint,
});
}
static fromSerialized(data: SerializedIdentity): PeerIdentity {
const publicKey = hexToBytes(data.publicKey);
const privateKey = hexToBytes(data.privateKey);
const fingerprint = data.fingerprint;
const computed = PeerIdentity.computeFingerprint(publicKey);
if (computed !== fingerprint) {
throw new Error('Fingerprint mismatch - corrupted identity');
}
return new PeerIdentity({
publicKey,
privateKey,
fingerprint,
});
}
static computeFingerprint(publicKey: Uint8Array): string {
const hash = sha256(publicKey);
return bytesToHex(hash.slice(0, 8));
}
static async verify(
signature: Uint8Array,
message: Uint8Array,
publicKey: Uint8Array
): Promise<boolean> {
try {
return await ed25519.verifyAsync(signature, message, publicKey);
} catch {
return false;
}
}
static async verifyHex(
signatureHex: string,
messageHex: string,
publicKeyHex: string
): Promise<boolean> {
try {
const signature = hexToBytes(signatureHex);
const message = hexToBytes(messageHex);
const publicKey = hexToBytes(publicKeyHex);
return await PeerIdentity.verify(signature, message, publicKey);
} catch {
return false;
}
}
async sign(message: Uint8Array): Promise<Uint8Array> {
return await ed25519.signAsync(message, this.keypair.privateKey);
}
async signString(message: string): Promise<string> {
const messageBytes = new TextEncoder().encode(message);
const signature = await this.sign(messageBytes);
return bytesToHex(signature);
}
async signObject(obj: object): Promise<string> {
const message = JSON.stringify(obj);
return await this.signString(message);
}
deriveSharedSecret(peerPublicKey: Uint8Array): Uint8Array {
const x25519PrivateKey = this.keypair.privateKey;
return x25519.scalarMult(x25519PrivateKey, peerPublicKey);
}
deriveSharedSecretHex(peerPublicKeyHex: string): Uint8Array {
const peerPublicKey = hexToBytes(peerPublicKeyHex);
return this.deriveSharedSecret(peerPublicKey);
}
serialize(): SerializedIdentity {
return {
publicKey: bytesToHex(this.keypair.publicKey),
privateKey: bytesToHex(this.keypair.privateKey),
fingerprint: this.keypair.fingerprint,
};
}
get publicKey(): Uint8Array {
return this.keypair.publicKey;
}
get publicKeyHex(): string {
return bytesToHex(this.keypair.publicKey);
}
get privateKey(): Uint8Array {
return this.keypair.privateKey;
}
get privateKeyHex(): string {
return bytesToHex(this.keypair.privateKey);
}
get fingerprint(): string {
return this.keypair.fingerprint;
}
toJSON(): { publicKey: string; fingerprint: string } {
return {
publicKey: this.publicKeyHex,
fingerprint: this.fingerprint,
};
}
}
-48
View File
@@ -1,48 +0,0 @@
export {
PeerIdentity,
type PeerKeypair,
type SerializedIdentity,
} from './identity.js';
export {
MessageEncryption,
PublicKeyEncryption,
generateNonce,
generateMessageId,
type EncryptedMessage,
type PublicKeyEncryptedMessage,
} from './encryption.js';
export {
signData,
verifySignedData,
isSignedDataExpired,
extractSignerFingerprint,
type SignedData,
type SignatureVerificationResult,
} from './signatures.js';
export {
SecureKeystore,
getKeystore,
resetKeystore,
type KeystoreConfig,
type TrustedPeer,
type KeystoreData,
} from './keystore.js';
export {
encryptData,
decryptData,
encryptObject,
decryptObject,
encryptFile,
decryptFile,
isEncryptedFile,
deriveKey,
generateSalt,
generateIV,
generateMachineKey,
hashPassphrase,
type EncryptedFile,
} from './storage.js';
-266
View File
@@ -1,266 +0,0 @@
import { readFile, writeFile, mkdir, access, unlink } from 'node:fs/promises';
import { join } from 'node:path';
import { homedir } from 'node:os';
import { existsSync } from 'node:fs';
import { PeerIdentity, type SerializedIdentity } from './identity.js';
import {
encryptObject,
decryptObject,
isEncryptedFile,
generateMachineKey,
} from './storage.js';
export interface KeystoreConfig {
path?: string;
encryptionKey?: string;
useMachineKey?: boolean;
}
export interface TrustedPeer {
fingerprint: string;
publicKey: string;
name?: string;
addedAt: string;
}
export interface KeystoreData {
version: '1.0';
trustedPeers: TrustedPeer[];
revokedFingerprints: string[];
}
const DEFAULT_KEYSTORE_PATH = join(homedir(), '.skillkit', 'mesh', 'identity');
export class SecureKeystore {
private path: string;
private passphrase: string;
private identity: PeerIdentity | null = null;
private keystoreData: KeystoreData | null = null;
constructor(config: KeystoreConfig = {}) {
this.path = config.path || DEFAULT_KEYSTORE_PATH;
if (config.encryptionKey) {
this.passphrase = config.encryptionKey;
} else if (config.useMachineKey !== false) {
this.passphrase = generateMachineKey();
} else {
throw new Error('Encryption key or machine key required');
}
}
private get keypairPath(): string {
return join(this.path, 'keypair.enc');
}
private get keystoreDataPath(): string {
return join(this.path, 'keystore.json');
}
async ensureDirectory(): Promise<void> {
if (!existsSync(this.path)) {
await mkdir(this.path, { recursive: true, mode: 0o700 });
}
}
async loadOrCreateIdentity(): Promise<PeerIdentity> {
if (this.identity) {
return this.identity;
}
await this.ensureDirectory();
try {
await access(this.keypairPath);
const content = await readFile(this.keypairPath, 'utf-8');
const encrypted = JSON.parse(content);
if (isEncryptedFile(encrypted)) {
const serialized = await decryptObject<SerializedIdentity>(
encrypted,
this.passphrase
);
this.identity = PeerIdentity.fromSerialized(serialized);
} else {
this.identity = PeerIdentity.fromSerialized(encrypted as SerializedIdentity);
}
} catch {
this.identity = await PeerIdentity.generate();
await this.saveIdentity();
}
return this.identity;
}
async saveIdentity(): Promise<void> {
if (!this.identity) {
throw new Error('No identity to save');
}
await this.ensureDirectory();
const serialized = this.identity.serialize();
const encrypted = await encryptObject(serialized, this.passphrase);
await writeFile(this.keypairPath, JSON.stringify(encrypted, null, 2), {
mode: 0o600,
});
}
async getIdentity(): Promise<PeerIdentity | null> {
return this.identity;
}
async hasIdentity(): Promise<boolean> {
try {
await access(this.keypairPath);
return true;
} catch {
return false;
}
}
async deleteIdentity(): Promise<void> {
try {
await unlink(this.keypairPath);
this.identity = null;
} catch {
}
}
private async loadKeystoreData(): Promise<KeystoreData> {
if (this.keystoreData) {
return this.keystoreData;
}
try {
await access(this.keystoreDataPath);
const content = await readFile(this.keystoreDataPath, 'utf-8');
this.keystoreData = JSON.parse(content) as KeystoreData;
} catch {
this.keystoreData = {
version: '1.0',
trustedPeers: [],
revokedFingerprints: [],
};
}
return this.keystoreData;
}
private async saveKeystoreData(): Promise<void> {
if (!this.keystoreData) return;
await this.ensureDirectory();
await writeFile(
this.keystoreDataPath,
JSON.stringify(this.keystoreData, null, 2),
{ mode: 0o600 }
);
}
async addTrustedPeer(
fingerprint: string,
publicKey: string,
name?: string
): Promise<void> {
const data = await this.loadKeystoreData();
const existing = data.trustedPeers.findIndex(
(p) => p.fingerprint === fingerprint
);
if (existing >= 0) {
data.trustedPeers[existing] = {
fingerprint,
publicKey,
name,
addedAt: new Date().toISOString(),
};
} else {
data.trustedPeers.push({
fingerprint,
publicKey,
name,
addedAt: new Date().toISOString(),
});
}
const revokedIndex = data.revokedFingerprints.indexOf(fingerprint);
if (revokedIndex >= 0) {
data.revokedFingerprints.splice(revokedIndex, 1);
}
await this.saveKeystoreData();
}
async removeTrustedPeer(fingerprint: string): Promise<void> {
const data = await this.loadKeystoreData();
data.trustedPeers = data.trustedPeers.filter(
(p) => p.fingerprint !== fingerprint
);
await this.saveKeystoreData();
}
async revokePeer(fingerprint: string): Promise<void> {
const data = await this.loadKeystoreData();
data.trustedPeers = data.trustedPeers.filter(
(p) => p.fingerprint !== fingerprint
);
if (!data.revokedFingerprints.includes(fingerprint)) {
data.revokedFingerprints.push(fingerprint);
}
await this.saveKeystoreData();
}
async isRevoked(fingerprint: string): Promise<boolean> {
const data = await this.loadKeystoreData();
return data.revokedFingerprints.includes(fingerprint);
}
async isTrusted(fingerprint: string): Promise<boolean> {
const data = await this.loadKeystoreData();
return data.trustedPeers.some((p) => p.fingerprint === fingerprint);
}
async getTrustedPeer(fingerprint: string): Promise<TrustedPeer | null> {
const data = await this.loadKeystoreData();
return data.trustedPeers.find((p) => p.fingerprint === fingerprint) || null;
}
async getTrustedPeers(): Promise<TrustedPeer[]> {
const data = await this.loadKeystoreData();
return [...data.trustedPeers];
}
async getRevokedFingerprints(): Promise<string[]> {
const data = await this.loadKeystoreData();
return [...data.revokedFingerprints];
}
async clearRevokedPeers(): Promise<void> {
const data = await this.loadKeystoreData();
data.revokedFingerprints = [];
await this.saveKeystoreData();
}
async exportPublicInfo(): Promise<{ fingerprint: string; publicKey: string }> {
const identity = await this.loadOrCreateIdentity();
return {
fingerprint: identity.fingerprint,
publicKey: identity.publicKeyHex,
};
}
}
let globalKeystore: SecureKeystore | null = null;
export function getKeystore(config?: KeystoreConfig): SecureKeystore {
if (!globalKeystore) {
globalKeystore = new SecureKeystore(config);
}
return globalKeystore;
}
export function resetKeystore(): void {
globalKeystore = null;
}
-147
View File
@@ -1,147 +0,0 @@
import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
import { sha256 } from '@noble/hashes/sha256';
import { PeerIdentity } from './identity.js';
export interface SignedData<T> {
data: T;
signature: string;
senderFingerprint: string;
senderPublicKey: string;
timestamp: string;
nonce: string;
}
export interface SignatureVerificationResult {
valid: boolean;
fingerprint?: string;
error?: string;
}
function generateNonce(): string {
const bytes = new Uint8Array(16);
crypto.getRandomValues(bytes);
return bytesToHex(bytes);
}
function canonicalize(obj: unknown): string {
if (obj === null || obj === undefined) {
return 'null';
}
if (typeof obj !== 'object') {
return JSON.stringify(obj);
}
if (Array.isArray(obj)) {
return '[' + obj.map(canonicalize).join(',') + ']';
}
const keys = Object.keys(obj as Record<string, unknown>).sort();
const pairs = keys.map((key) => {
const value = (obj as Record<string, unknown>)[key];
return JSON.stringify(key) + ':' + canonicalize(value);
});
return '{' + pairs.join(',') + '}';
}
function hashData(data: unknown): Uint8Array {
const canonical = canonicalize(data);
return sha256(new TextEncoder().encode(canonical));
}
export async function signData<T>(
data: T,
identity: PeerIdentity
): Promise<SignedData<T>> {
const timestamp = new Date().toISOString();
const nonce = generateNonce();
const toSign = {
data,
timestamp,
nonce,
senderFingerprint: identity.fingerprint,
};
const hash = hashData(toSign);
const signature = await identity.sign(hash);
return {
data,
signature: bytesToHex(signature),
senderFingerprint: identity.fingerprint,
senderPublicKey: identity.publicKeyHex,
timestamp,
nonce,
};
}
export async function verifySignedData<T>(
signed: SignedData<T>,
trustedPublicKey?: Uint8Array
): Promise<SignatureVerificationResult> {
try {
const publicKey = trustedPublicKey || hexToBytes(signed.senderPublicKey);
const computedFingerprint = PeerIdentity.computeFingerprint(publicKey);
if (computedFingerprint !== signed.senderFingerprint) {
return {
valid: false,
error: 'Fingerprint mismatch',
};
}
const toSign = {
data: signed.data,
timestamp: signed.timestamp,
nonce: signed.nonce,
senderFingerprint: signed.senderFingerprint,
};
const hash = hashData(toSign);
const signature = hexToBytes(signed.signature);
const valid = await PeerIdentity.verify(signature, hash, publicKey);
if (!valid) {
return {
valid: false,
error: 'Invalid signature',
};
}
return {
valid: true,
fingerprint: signed.senderFingerprint,
};
} catch (error) {
return {
valid: false,
error: error instanceof Error ? error.message : 'Unknown error',
};
}
}
export function isSignedDataExpired(
signed: SignedData<unknown>,
maxAgeMs: number = 5 * 60 * 1000
): boolean {
const timestamp = new Date(signed.timestamp).getTime();
const now = Date.now();
return now - timestamp > maxAgeMs;
}
export function extractSignerFingerprint(
signed: SignedData<unknown>
): string | null {
try {
const publicKey = hexToBytes(signed.senderPublicKey);
const computed = PeerIdentity.computeFingerprint(publicKey);
if (computed === signed.senderFingerprint) {
return signed.senderFingerprint;
}
return null;
} catch {
return null;
}
}
-187
View File
@@ -1,187 +0,0 @@
import {
createCipheriv,
createDecipheriv,
randomBytes,
scrypt,
createHash,
type ScryptOptions,
} from 'node:crypto';
import { readFile, writeFile, mkdir } from 'node:fs/promises';
import { dirname } from 'node:path';
import { existsSync } from 'node:fs';
export interface EncryptedFile {
version: '2.0';
encrypted: true;
algorithm: 'aes-256-gcm';
kdf: 'scrypt';
salt: string;
iv: string;
ciphertext: string;
authTag: string;
}
export interface EncryptionParams {
salt: Uint8Array;
iv: Uint8Array;
authTag: Buffer;
}
const SCRYPT_N = 2 ** 14;
const SCRYPT_R = 8;
const SCRYPT_P = 1;
const KEY_LENGTH = 32;
const IV_LENGTH = 12;
const SALT_LENGTH = 32;
export function deriveKey(
passphrase: string,
salt: Uint8Array
): Promise<Buffer> {
return new Promise((resolve, reject) => {
const options: ScryptOptions = {
N: SCRYPT_N,
r: SCRYPT_R,
p: SCRYPT_P,
};
scrypt(passphrase, salt, KEY_LENGTH, options, (err, derivedKey) => {
if (err) reject(err);
else resolve(derivedKey);
});
});
}
export function generateSalt(): Uint8Array {
return randomBytes(SALT_LENGTH);
}
export function generateIV(): Uint8Array {
return randomBytes(IV_LENGTH);
}
export function encrypt(
data: Uint8Array,
key: Buffer,
iv: Uint8Array
): { ciphertext: Buffer; authTag: Buffer } {
const cipher = createCipheriv('aes-256-gcm', key, iv);
const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
const authTag = cipher.getAuthTag();
return { ciphertext, authTag };
}
export function decrypt(
ciphertext: Buffer,
key: Buffer,
iv: Uint8Array,
authTag: Buffer
): Buffer {
const decipher = createDecipheriv('aes-256-gcm', key, iv);
decipher.setAuthTag(authTag);
return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
}
export async function encryptData(
data: Uint8Array | string,
passphrase: string
): Promise<EncryptedFile> {
const dataBytes =
typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
const salt = generateSalt();
const iv = generateIV();
const key = await deriveKey(passphrase, salt);
const { ciphertext, authTag } = encrypt(dataBytes, key, iv);
return {
version: '2.0',
encrypted: true,
algorithm: 'aes-256-gcm',
kdf: 'scrypt',
salt: Buffer.from(salt).toString('hex'),
iv: Buffer.from(iv).toString('hex'),
ciphertext: ciphertext.toString('hex'),
authTag: authTag.toString('hex'),
};
}
export async function decryptData(
encrypted: EncryptedFile,
passphrase: string
): Promise<Buffer> {
if (encrypted.version !== '2.0' || !encrypted.encrypted) {
throw new Error('Invalid encrypted file format');
}
const salt = Buffer.from(encrypted.salt, 'hex');
const iv = Buffer.from(encrypted.iv, 'hex');
const ciphertext = Buffer.from(encrypted.ciphertext, 'hex');
const authTag = Buffer.from(encrypted.authTag, 'hex');
const key = await deriveKey(passphrase, salt);
return decrypt(ciphertext, key, iv, authTag);
}
export async function encryptObject(
obj: unknown,
passphrase: string
): Promise<EncryptedFile> {
const json = JSON.stringify(obj);
return encryptData(json, passphrase);
}
export async function decryptObject<T = unknown>(
encrypted: EncryptedFile,
passphrase: string
): Promise<T> {
const decrypted = await decryptData(encrypted, passphrase);
return JSON.parse(decrypted.toString('utf-8')) as T;
}
export async function encryptFile(
data: unknown,
passphrase: string,
outputPath: string
): Promise<void> {
const dir = dirname(outputPath);
if (!existsSync(dir)) {
await mkdir(dir, { recursive: true });
}
const encrypted = await encryptObject(data, passphrase);
await writeFile(outputPath, JSON.stringify(encrypted, null, 2));
}
export async function decryptFile<T = unknown>(
inputPath: string,
passphrase: string
): Promise<T> {
const content = await readFile(inputPath, 'utf-8');
const encrypted = JSON.parse(content) as EncryptedFile;
return decryptObject<T>(encrypted, passphrase);
}
export function isEncryptedFile(data: unknown): data is EncryptedFile {
if (typeof data !== 'object' || data === null) return false;
const obj = data as Record<string, unknown>;
return (
obj.version === '2.0' &&
obj.encrypted === true &&
obj.algorithm === 'aes-256-gcm' &&
obj.kdf === 'scrypt' &&
typeof obj.salt === 'string' &&
typeof obj.iv === 'string' &&
typeof obj.ciphertext === 'string' &&
typeof obj.authTag === 'string'
);
}
export function hashPassphrase(passphrase: string): string {
return createHash('sha256').update(passphrase).digest('hex').slice(0, 16);
}
export function generateMachineKey(): string {
const hostname = process.env.HOSTNAME || 'unknown';
const user = process.env.USER || process.env.USERNAME || 'unknown';
const combined = `skillkit-mesh-${hostname}-${user}`;
return createHash('sha256').update(combined).digest('hex');
}
-23
View File
@@ -1,23 +0,0 @@
export {
LocalDiscovery,
getLocalIPAddress,
getAllLocalIPAddresses,
discoverOnce,
type LocalDiscoveryOptions,
} from './local.js';
export {
SecureLocalDiscovery,
discoverOnceSecure,
type SecureLocalDiscoveryOptions,
} from './secure-local.js';
export {
getTailscaleStatus,
isTailscaleAvailable,
getTailscaleIP,
discoverTailscaleHosts,
resolveTailscaleName,
type TailscaleStatus,
type TailscalePeer,
} from './tailscale.js';
-224
View File
@@ -1,224 +0,0 @@
import { createSocket, Socket } from 'node:dgram';
import { networkInterfaces } from 'node:os';
import type { DiscoveryMessage, Host } from '../types.js';
import { DEFAULT_DISCOVERY_PORT, MESH_VERSION } from '../types.js';
import { getLocalHostConfig, addKnownHost } from '../config/hosts-config.js';
const MULTICAST_ADDR = '239.255.255.250';
const DISCOVERY_INTERVAL_MS = 30000;
export interface LocalDiscoveryOptions {
port?: number;
interval?: number;
onDiscover?: (host: Host) => void;
}
export class LocalDiscovery {
private socket: Socket | null = null;
private announceInterval: NodeJS.Timeout | null = null;
private running = false;
private options: Required<LocalDiscoveryOptions>;
private discoveredHosts: Map<string, Host> = new Map();
constructor(options: LocalDiscoveryOptions = {}) {
this.options = {
port: options.port ?? DEFAULT_DISCOVERY_PORT,
interval: options.interval ?? DISCOVERY_INTERVAL_MS,
onDiscover: options.onDiscover ?? (() => {}),
};
}
async start(): Promise<void> {
if (this.running) return;
this.socket = createSocket({ type: 'udp4', reuseAddr: true });
this.socket.on('message', (msg, rinfo) => {
this.handleMessage(msg, rinfo);
});
this.socket.on('error', err => {
console.error('Discovery socket error:', err);
});
await new Promise<void>((resolve, reject) => {
this.socket!.bind(this.options.port, () => {
try {
this.socket!.addMembership(MULTICAST_ADDR);
this.socket!.setBroadcast(true);
this.socket!.setMulticastTTL(1);
resolve();
} catch (err) {
this.socket?.close();
this.socket = null;
reject(err);
}
});
});
this.running = true;
await this.announce();
this.announceInterval = setInterval(() => {
void this.announce().catch(err => {
console.error('Discovery announce error:', err);
});
}, this.options.interval);
}
async stop(): Promise<void> {
if (!this.running) return;
if (this.announceInterval) {
clearInterval(this.announceInterval);
this.announceInterval = null;
}
if (this.socket) {
try {
this.socket.dropMembership(MULTICAST_ADDR);
} catch {
}
this.socket.close();
this.socket = null;
}
this.running = false;
}
async announce(): Promise<void> {
if (!this.socket || !this.running) return;
const localConfig = await getLocalHostConfig();
const localAddress = getLocalIPAddress();
const message: DiscoveryMessage = {
type: 'announce',
hostId: localConfig.id,
hostName: localConfig.name,
address: localAddress,
port: localConfig.port,
tailscaleIP: localConfig.tailscaleIP,
version: MESH_VERSION,
timestamp: new Date().toISOString(),
};
const buffer = Buffer.from(JSON.stringify(message));
this.socket.send(buffer, 0, buffer.length, this.options.port, MULTICAST_ADDR);
}
async query(): Promise<void> {
if (!this.socket || !this.running) return;
const localConfig = await getLocalHostConfig();
const localAddress = getLocalIPAddress();
const message: DiscoveryMessage = {
type: 'query',
hostId: localConfig.id,
hostName: localConfig.name,
address: localAddress,
port: localConfig.port,
version: MESH_VERSION,
timestamp: new Date().toISOString(),
};
const buffer = Buffer.from(JSON.stringify(message));
this.socket.send(buffer, 0, buffer.length, this.options.port, MULTICAST_ADDR);
}
getDiscoveredHosts(): Host[] {
return Array.from(this.discoveredHosts.values());
}
isRunning(): boolean {
return this.running;
}
private async handleMessage(msg: Buffer, rinfo: { address: string; port: number }): Promise<void> {
try {
const message = JSON.parse(msg.toString()) as Partial<DiscoveryMessage>;
if (!message || (message.type !== 'announce' && message.type !== 'query' && message.type !== 'response')) return;
if (!message.hostId || !message.hostName) return;
const port = Number(message.port);
if (!Number.isInteger(port) || port < 1 || port > 65535) return;
const localConfig = await getLocalHostConfig();
if (message.hostId === localConfig.id) return;
const host: Host = {
id: message.hostId,
name: message.hostName,
address: rinfo.address,
port,
tailscaleIP: message.tailscaleIP,
status: 'online',
lastSeen: new Date().toISOString(),
version: message.version,
};
this.discoveredHosts.set(host.id, host);
await addKnownHost(host);
this.options.onDiscover(host);
if (message.type === 'query') {
await this.announce();
}
} catch {
}
}
}
export function getLocalIPAddress(): string {
const interfaces = networkInterfaces();
for (const name of Object.keys(interfaces)) {
const iface = interfaces[name];
if (!iface) continue;
for (const addr of iface) {
if (addr.family === 'IPv4' && !addr.internal) {
return addr.address;
}
}
}
return '127.0.0.1';
}
export function getAllLocalIPAddresses(): string[] {
const addresses: string[] = [];
const interfaces = networkInterfaces();
for (const name of Object.keys(interfaces)) {
const iface = interfaces[name];
if (!iface) continue;
for (const addr of iface) {
if (addr.family === 'IPv4' && !addr.internal) {
addresses.push(addr.address);
}
}
}
return addresses;
}
export async function discoverOnce(timeout = 5000): Promise<Host[]> {
const discovery = new LocalDiscovery();
await discovery.start();
await discovery.query();
await new Promise(resolve => setTimeout(resolve, timeout));
const hosts = discovery.getDiscoveredHosts();
await discovery.stop();
return hosts;
}
-349
View File
@@ -1,349 +0,0 @@
import { createSocket, Socket } from 'node:dgram';
import { networkInterfaces } from 'node:os';
import type { DiscoveryMessage, SignedDiscoveryMessage, Host } from '../types.js';
import { DEFAULT_DISCOVERY_PORT, MESH_VERSION } from '../types.js';
import { getLocalHostConfig, addKnownHost } from '../config/hosts-config.js';
import { PeerIdentity } from '../crypto/identity.js';
import { SecureKeystore } from '../crypto/keystore.js';
import {
type MeshSecurityConfig,
DEFAULT_SECURITY_CONFIG,
type DiscoverySecurityMode,
} from '../security/config.js';
import { hexToBytes } from '@noble/hashes/utils';
const MULTICAST_ADDR = '239.255.255.250';
const DISCOVERY_INTERVAL_MS = 30000;
export interface SecureLocalDiscoveryOptions {
port?: number;
interval?: number;
onDiscover?: (host: Host, fingerprint?: string) => void;
security?: MeshSecurityConfig;
identity?: PeerIdentity;
keystore?: SecureKeystore;
}
export class SecureLocalDiscovery {
private socket: Socket | null = null;
private announceInterval: NodeJS.Timeout | null = null;
private running = false;
private options: Required<Omit<SecureLocalDiscoveryOptions, 'identity' | 'keystore'>>;
private discoveredHosts: Map<string, Host> = new Map();
private identity: PeerIdentity | null = null;
private keystore: SecureKeystore | null = null;
private securityMode: DiscoverySecurityMode;
constructor(options: SecureLocalDiscoveryOptions = {}) {
this.options = {
port: options.port ?? DEFAULT_DISCOVERY_PORT,
interval: options.interval ?? DISCOVERY_INTERVAL_MS,
onDiscover: options.onDiscover ?? (() => {}),
security: options.security ?? DEFAULT_SECURITY_CONFIG,
};
this.identity = options.identity ?? null;
this.keystore = options.keystore ?? null;
this.securityMode = this.options.security.discovery.mode;
}
async initialize(): Promise<void> {
if (!this.identity && this.keystore) {
this.identity = await this.keystore.loadOrCreateIdentity();
}
if (!this.identity && this.securityMode !== 'open') {
this.identity = await PeerIdentity.generate();
}
}
async start(): Promise<void> {
if (this.running) return;
await this.initialize();
this.socket = createSocket({ type: 'udp4', reuseAddr: true });
this.socket.on('message', (msg, rinfo) => {
this.handleMessage(msg, rinfo);
});
this.socket.on('error', (err) => {
console.error('Discovery socket error:', err);
});
await new Promise<void>((resolve, reject) => {
this.socket!.bind(this.options.port, () => {
try {
this.socket!.addMembership(MULTICAST_ADDR);
this.socket!.setBroadcast(true);
this.socket!.setMulticastTTL(128);
resolve();
} catch (err) {
reject(err);
}
});
});
this.running = true;
await this.announce();
this.announceInterval = setInterval(() => {
this.announce();
}, this.options.interval);
}
async stop(): Promise<void> {
if (!this.running) return;
if (this.announceInterval) {
clearInterval(this.announceInterval);
this.announceInterval = null;
}
if (this.socket) {
try {
this.socket.dropMembership(MULTICAST_ADDR);
} catch {
}
this.socket.close();
this.socket = null;
}
this.running = false;
}
async announce(): Promise<void> {
if (!this.socket || !this.running) return;
const localConfig = await getLocalHostConfig();
const localAddress = getLocalIPAddress();
const baseMessage: DiscoveryMessage = {
type: 'announce',
hostId: localConfig.id,
hostName: localConfig.name,
address: localAddress,
port: localConfig.port,
tailscaleIP: localConfig.tailscaleIP,
version: MESH_VERSION,
timestamp: new Date().toISOString(),
};
let message: DiscoveryMessage | SignedDiscoveryMessage = baseMessage;
if (this.identity && this.securityMode !== 'open') {
const signature = await this.identity.signObject(baseMessage);
message = {
...baseMessage,
signature,
publicKey: this.identity.publicKeyHex,
fingerprint: this.identity.fingerprint,
} as SignedDiscoveryMessage;
}
const buffer = Buffer.from(JSON.stringify(message));
this.socket.send(buffer, 0, buffer.length, this.options.port, MULTICAST_ADDR);
}
async query(): Promise<void> {
if (!this.socket || !this.running) return;
const localConfig = await getLocalHostConfig();
const localAddress = getLocalIPAddress();
const baseMessage: DiscoveryMessage = {
type: 'query',
hostId: localConfig.id,
hostName: localConfig.name,
address: localAddress,
port: localConfig.port,
version: MESH_VERSION,
timestamp: new Date().toISOString(),
};
let message: DiscoveryMessage | SignedDiscoveryMessage = baseMessage;
if (this.identity && this.securityMode !== 'open') {
const signature = await this.identity.signObject(baseMessage);
message = {
...baseMessage,
signature,
publicKey: this.identity.publicKeyHex,
fingerprint: this.identity.fingerprint,
} as SignedDiscoveryMessage;
}
const buffer = Buffer.from(JSON.stringify(message));
this.socket.send(buffer, 0, buffer.length, this.options.port, MULTICAST_ADDR);
}
getDiscoveredHosts(): Host[] {
return Array.from(this.discoveredHosts.values());
}
isRunning(): boolean {
return this.running;
}
getFingerprint(): string | null {
return this.identity?.fingerprint ?? null;
}
private async handleMessage(
msg: Buffer,
rinfo: { address: string; port: number }
): Promise<void> {
try {
const raw = JSON.parse(msg.toString());
const localConfig = await getLocalHostConfig();
if (raw.hostId === localConfig.id) return;
let message: DiscoveryMessage;
let fingerprint: string | undefined;
if (this.isSignedMessage(raw)) {
const signedMsg = raw as SignedDiscoveryMessage;
fingerprint = signedMsg.fingerprint;
if (this.securityMode === 'signed' || this.securityMode === 'trusted-only') {
const isValid = await this.verifySignedMessage(signedMsg);
if (!isValid) {
return;
}
}
if (this.securityMode === 'trusted-only' && this.keystore) {
const isTrusted = await this.keystore.isTrusted(fingerprint);
const isRevoked = await this.keystore.isRevoked(fingerprint);
if (isRevoked) {
return;
}
if (!isTrusted) {
if (this.options.security.trust.autoTrustFirst) {
await this.keystore.addTrustedPeer(
fingerprint,
signedMsg.publicKey,
signedMsg.hostName
);
} else {
return;
}
}
}
message = {
type: signedMsg.type,
hostId: signedMsg.hostId,
hostName: signedMsg.hostName,
address: signedMsg.address,
port: signedMsg.port,
tailscaleIP: signedMsg.tailscaleIP,
version: signedMsg.version,
timestamp: signedMsg.timestamp,
};
} else {
if (this.securityMode !== 'open') {
return;
}
message = raw as DiscoveryMessage;
}
const host: Host = {
id: message.hostId,
name: message.hostName,
address: message.address || rinfo.address,
port: message.port,
tailscaleIP: message.tailscaleIP,
status: 'online',
lastSeen: new Date().toISOString(),
version: message.version,
metadata: fingerprint ? { fingerprint } : undefined,
};
this.discoveredHosts.set(host.id, host);
await addKnownHost(host);
this.options.onDiscover(host, fingerprint);
if (message.type === 'query') {
await this.announce();
}
} catch {
}
}
private isSignedMessage(msg: unknown): msg is SignedDiscoveryMessage {
if (typeof msg !== 'object' || msg === null) return false;
const obj = msg as Record<string, unknown>;
return (
typeof obj.signature === 'string' &&
typeof obj.publicKey === 'string' &&
typeof obj.fingerprint === 'string'
);
}
private async verifySignedMessage(
msg: SignedDiscoveryMessage
): Promise<boolean> {
try {
const publicKey = hexToBytes(msg.publicKey);
const computedFingerprint = PeerIdentity.computeFingerprint(publicKey);
if (computedFingerprint !== msg.fingerprint) {
return false;
}
const baseMessage: DiscoveryMessage = {
type: msg.type,
hostId: msg.hostId,
hostName: msg.hostName,
address: msg.address,
port: msg.port,
tailscaleIP: msg.tailscaleIP,
version: msg.version,
timestamp: msg.timestamp,
};
const messageBytes = new TextEncoder().encode(JSON.stringify(baseMessage));
const signature = hexToBytes(msg.signature);
return await PeerIdentity.verify(signature, messageBytes, publicKey);
} catch {
return false;
}
}
}
export function getLocalIPAddress(): string {
const interfaces = networkInterfaces();
for (const name of Object.keys(interfaces)) {
const iface = interfaces[name];
if (!iface) continue;
for (const addr of iface) {
if (addr.family === 'IPv4' && !addr.internal) {
return addr.address;
}
}
}
return '127.0.0.1';
}
export async function discoverOnceSecure(
timeout = 5000,
options: SecureLocalDiscoveryOptions = {}
): Promise<Host[]> {
const discovery = new SecureLocalDiscovery(options);
await discovery.start();
await discovery.query();
await new Promise((resolve) => setTimeout(resolve, timeout));
const hosts = discovery.getDiscoveredHosts();
await discovery.stop();
return hosts;
}
-134
View File
@@ -1,134 +0,0 @@
import { exec } from 'node:child_process';
import { promisify } from 'node:util';
import type { Host } from '../types.js';
import { MESH_VERSION } from '../types.js';
const execAsync = promisify(exec);
export interface TailscaleStatus {
available: boolean;
self?: TailscalePeer;
peers: TailscalePeer[];
magicDNSSuffix?: string;
}
export interface TailscalePeer {
id: string;
name: string;
tailscaleIP: string;
hostname: string;
online: boolean;
os?: string;
lastSeen?: string;
}
export async function getTailscaleStatus(): Promise<TailscaleStatus> {
try {
const { stdout } = await execAsync('tailscale status --json');
const status = JSON.parse(stdout);
const self: TailscalePeer | undefined = status.Self
? {
id: status.Self.ID,
name: status.Self.HostName,
tailscaleIP: status.Self.TailscaleIPs?.[0] || '',
hostname: status.Self.HostName,
online: status.Self.Online ?? true,
os: status.Self.OS,
}
: undefined;
const peers: TailscalePeer[] = [];
if (status.Peer) {
for (const [id, peer] of Object.entries(status.Peer) as [string, any][]) {
peers.push({
id,
name: peer.HostName,
tailscaleIP: peer.TailscaleIPs?.[0] || '',
hostname: peer.HostName,
online: peer.Online ?? false,
os: peer.OS,
lastSeen: peer.LastSeen,
});
}
}
return {
available: true,
self,
peers,
magicDNSSuffix: status.MagicDNSSuffix,
};
} catch {
return {
available: false,
peers: [],
};
}
}
export async function isTailscaleAvailable(): Promise<boolean> {
try {
await execAsync('tailscale version');
return true;
} catch {
return false;
}
}
export async function getTailscaleIP(): Promise<string | null> {
const status = await getTailscaleStatus();
return status.self?.tailscaleIP ?? null;
}
export async function discoverTailscaleHosts(skillkitPort: number): Promise<Host[]> {
const status = await getTailscaleStatus();
if (!status.available) return [];
const hosts: Host[] = [];
for (const peer of status.peers) {
if (!peer.online) continue;
hosts.push({
id: `tailscale-${peer.id}`,
name: peer.name,
address: peer.tailscaleIP,
port: skillkitPort,
tailscaleIP: peer.tailscaleIP,
status: 'unknown',
lastSeen: peer.lastSeen ?? new Date().toISOString(),
version: MESH_VERSION,
metadata: {
discoveredVia: 'tailscale',
os: peer.os,
},
});
}
return hosts;
}
export async function resolveTailscaleName(hostname: string): Promise<string | null> {
const status = await getTailscaleStatus();
if (!status.available) return null;
const normalizedName = hostname.toLowerCase();
for (const peer of status.peers) {
if (peer.hostname.toLowerCase() === normalizedName || peer.name.toLowerCase() === normalizedName) {
return peer.tailscaleIP;
}
}
if (status.magicDNSSuffix && hostname.endsWith(status.magicDNSSuffix)) {
const shortName = hostname.slice(0, -status.magicDNSSuffix.length - 1);
for (const peer of status.peers) {
if (peer.hostname.toLowerCase() === shortName.toLowerCase()) {
return peer.tailscaleIP;
}
}
}
return null;
}
-165
View File
@@ -1,165 +0,0 @@
export * from './types.js';
export {
loadHostsFile,
saveHostsFile,
createDefaultHostsFile,
getLocalHostConfig,
updateLocalHostConfig,
addKnownHost,
removeKnownHost,
getKnownHosts,
getKnownHost,
updateKnownHost,
initializeHostsFile,
getHostsFilePath,
} from './config/index.js';
export {
LocalDiscovery,
getLocalIPAddress,
getAllLocalIPAddresses,
discoverOnce,
type LocalDiscoveryOptions,
SecureLocalDiscovery,
discoverOnceSecure,
type SecureLocalDiscoveryOptions,
getTailscaleStatus,
isTailscaleAvailable,
getTailscaleIP,
discoverTailscaleHosts,
resolveTailscaleName,
type TailscaleStatus,
type TailscalePeer,
} from './discovery/index.js';
export {
PeerRegistryManager,
getPeerRegistry,
type PeerRegistry,
checkHostHealth,
checkAllHostsHealth,
getOnlineHosts,
getOfflineHosts,
waitForHost,
HealthMonitor,
type HealthCheckOptions,
} from './peer/index.js';
export {
HttpTransport,
sendToHost,
broadcastToHosts,
type HttpTransportOptions,
WebSocketTransport,
WebSocketServer,
type WebSocketTransportOptions,
type MessageHandler,
SecureWebSocketTransport,
SecureWebSocketServer,
type SecureWebSocketOptions,
type SecureMessageHandler,
SecureHttpTransport,
sendToHostSecure,
broadcastToHostsSecure,
verifySecureMessage,
type SecureHttpTransportOptions,
} from './transport/index.js';
export {
PeerIdentity,
type PeerKeypair,
type SerializedIdentity,
MessageEncryption,
PublicKeyEncryption,
generateNonce,
generateMessageId,
type EncryptedMessage,
type PublicKeyEncryptedMessage,
signData,
verifySignedData,
isSignedDataExpired,
extractSignerFingerprint,
type SignedData,
type SignatureVerificationResult,
SecureKeystore,
getKeystore,
resetKeystore,
type KeystoreConfig,
type TrustedPeer,
type KeystoreData,
encryptData,
decryptData,
encryptObject,
decryptObject,
encryptFile,
decryptFile,
isEncryptedFile,
deriveKey,
generateSalt,
generateIV,
generateMachineKey,
hashPassphrase,
type EncryptedFile,
} from './crypto/index.js';
export {
type MeshSecurityConfig,
type DiscoverySecurityConfig,
type TransportSecurityConfig,
type TrustConfig,
type DiscoverySecurityMode,
type TransportEncryption,
type TLSMode,
type SecurityPreset,
DEFAULT_SECURITY_CONFIG,
SECURITY_PRESETS,
getSecurityPreset,
mergeSecurityConfig,
validateSecurityConfig,
isSecurityEnabled,
describeSecurityLevel,
AuthManager,
extractBearerToken,
createBearerHeader,
type AuthToken,
type AuthChallengeRequest,
type AuthChallengeResponse,
type AuthResult,
TLSManager,
getTLSManager,
resetTLSManager,
type CertificateInfo,
type TLSConfig,
type TLSContextOptions,
} from './security/index.js';
export async function initializeMesh(): Promise<void> {
const { initializeHostsFile } = await import('./config/index.js');
const { getPeerRegistry } = await import('./peer/index.js');
await initializeHostsFile();
await getPeerRegistry();
}
export async function initializeSecureMesh(
securityConfig?: import('./security/index.js').MeshSecurityConfig
): Promise<{
identity: import('./crypto/index.js').PeerIdentity;
keystore: import('./crypto/index.js').SecureKeystore;
}> {
const { initializeHostsFile } = await import('./config/index.js');
const { getPeerRegistry } = await import('./peer/index.js');
const { SecureKeystore } = await import('./crypto/index.js');
await initializeHostsFile();
await getPeerRegistry();
const keystore = new SecureKeystore({
path: securityConfig?.identityPath,
});
const identity = await keystore.loadOrCreateIdentity();
return { identity, keystore };
}
-158
View File
@@ -1,158 +0,0 @@
import got from 'got';
import type { Host, HealthCheckResult, HostStatus } from '../types.js';
import { HEALTH_CHECK_TIMEOUT } from '../types.js';
import { getKnownHosts, updateKnownHost } from '../config/hosts-config.js';
export interface HealthCheckOptions {
timeout?: number;
updateStatus?: boolean;
}
export async function checkHostHealth(
host: Host,
options: HealthCheckOptions = {}
): Promise<HealthCheckResult> {
const timeout = options.timeout ?? HEALTH_CHECK_TIMEOUT;
const startTime = Date.now();
const result: HealthCheckResult = {
hostId: host.id,
address: host.address,
port: host.port,
status: 'unknown',
latencyMs: 0,
checkedAt: new Date().toISOString(),
};
try {
const url = `http://${host.address}:${host.port}/health`;
const response = await got.get(url, {
timeout: { request: timeout },
retry: { limit: 0 },
throwHttpErrors: false,
});
result.latencyMs = Date.now() - startTime;
if (response.statusCode === 200) {
result.status = 'online';
} else {
result.status = 'offline';
result.error = `HTTP ${response.statusCode}`;
}
} catch (err: any) {
result.latencyMs = Date.now() - startTime;
result.status = 'offline';
result.error = err.code || err.message || 'Connection failed';
}
if (options.updateStatus !== false) {
await updateKnownHost(host.id, {
status: result.status,
lastSeen: result.status === 'online' ? result.checkedAt : host.lastSeen,
});
}
return result;
}
export async function checkAllHostsHealth(
options: HealthCheckOptions = {}
): Promise<HealthCheckResult[]> {
const hosts = await getKnownHosts();
const results = await Promise.all(hosts.map(host => checkHostHealth(host, options)));
return results;
}
export async function getOnlineHosts(): Promise<Host[]> {
const hosts = await getKnownHosts();
return hosts.filter(h => h.status === 'online');
}
export async function getOfflineHosts(): Promise<Host[]> {
const hosts = await getKnownHosts();
return hosts.filter(h => h.status === 'offline');
}
export async function waitForHost(
host: Host,
maxWaitMs = 30000,
intervalMs = 1000
): Promise<boolean> {
const deadline = Date.now() + maxWaitMs;
while (Date.now() < deadline) {
const result = await checkHostHealth(host, { updateStatus: false });
if (result.status === 'online') {
await updateKnownHost(host.id, {
status: 'online',
lastSeen: new Date().toISOString(),
});
return true;
}
await new Promise(resolve => setTimeout(resolve, intervalMs));
}
return false;
}
export class HealthMonitor {
private interval: NodeJS.Timeout | null = null;
private running = false;
private checking = false;
private onStatusChange?: (host: Host, oldStatus: HostStatus, newStatus: HostStatus) => void;
constructor(options: { onStatusChange?: (host: Host, oldStatus: HostStatus, newStatus: HostStatus) => void } = {}) {
this.onStatusChange = options.onStatusChange;
}
async start(intervalMs = 30000): Promise<void> {
if (this.running) return;
this.running = true;
await this.checkAll();
this.interval = setInterval(() => {
if (!this.checking) {
this.checking = true;
this.checkAll().finally(() => {
this.checking = false;
});
}
}, intervalMs);
}
stop(): void {
if (!this.running) return;
if (this.interval) {
clearInterval(this.interval);
this.interval = null;
}
this.running = false;
}
isRunning(): boolean {
return this.running;
}
private async checkAll(): Promise<void> {
const hosts = await getKnownHosts();
for (const host of hosts) {
const oldStatus = host.status;
const result = await checkHostHealth(host);
if (this.onStatusChange && oldStatus !== result.status) {
this.onStatusChange(host, oldStatus, result.status);
}
}
}
}
-15
View File
@@ -1,15 +0,0 @@
export {
PeerRegistryManager,
getPeerRegistry,
type PeerRegistry,
} from './registry.js';
export {
checkHostHealth,
checkAllHostsHealth,
getOnlineHosts,
getOfflineHosts,
waitForHost,
HealthMonitor,
type HealthCheckOptions,
} from './health.js';
-225
View File
@@ -1,225 +0,0 @@
import { readFile, writeFile, mkdir } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { Peer, PeerRegistration, Host } from '../types.js';
import { getKnownHosts, getLocalHostConfig } from '../config/hosts-config.js';
const PEERS_DIR = join(homedir(), '.skillkit', 'mesh', 'peers');
export interface PeerRegistry {
peers: Map<string, Peer>;
localPeers: Map<string, Peer>;
}
export class PeerRegistryManager {
private registry: PeerRegistry = {
peers: new Map(),
localPeers: new Map(),
};
async initialize(): Promise<void> {
await mkdir(PEERS_DIR, { recursive: true });
await this.loadLocalPeers();
}
async registerLocalPeer(registration: PeerRegistration): Promise<Peer> {
const localConfig = await getLocalHostConfig();
const peer: Peer = {
hostId: localConfig.id,
agentId: registration.agentId,
agentName: registration.agentName,
aliases: registration.aliases,
capabilities: registration.capabilities,
status: 'online',
lastSeen: new Date().toISOString(),
};
this.registry.localPeers.set(peer.agentId, peer);
await this.saveLocalPeers();
return peer;
}
async unregisterLocalPeer(agentId: string): Promise<boolean> {
const deleted = this.registry.localPeers.delete(agentId);
if (deleted) {
await this.saveLocalPeers();
}
return deleted;
}
registerRemotePeer(peer: Peer): void {
const key = `${peer.hostId}:${peer.agentId}`;
this.registry.peers.set(key, peer);
}
unregisterRemotePeer(hostId: string, agentId: string): boolean {
const key = `${hostId}:${agentId}`;
return this.registry.peers.delete(key);
}
getPeer(hostId: string, agentId: string): Peer | undefined {
const key = `${hostId}:${agentId}`;
return this.registry.peers.get(key);
}
getLocalPeer(agentId: string): Peer | undefined {
return this.registry.localPeers.get(agentId);
}
getAllPeers(): Peer[] {
return [
...Array.from(this.registry.localPeers.values()),
...Array.from(this.registry.peers.values()),
];
}
getLocalPeers(): Peer[] {
return Array.from(this.registry.localPeers.values());
}
getRemotePeers(): Peer[] {
return Array.from(this.registry.peers.values());
}
getPeersByHost(hostId: string): Peer[] {
return this.getAllPeers().filter(p => p.hostId === hostId);
}
findPeerByName(name: string): Peer | undefined {
const lowerName = name.toLowerCase();
for (const peer of this.getAllPeers()) {
if (peer.agentName.toLowerCase() === lowerName) {
return peer;
}
if (peer.aliases.some(a => a.toLowerCase() === lowerName)) {
return peer;
}
}
return undefined;
}
findPeersByCapability(capability: string): Peer[] {
return this.getAllPeers().filter(p => p.capabilities.includes(capability));
}
async resolvePeerAddress(nameOrId: string): Promise<{ host: Host; peer: Peer } | null> {
const parts = nameOrId.split('@');
const peerName = parts[0];
const hostName = parts[1];
if (hostName) {
const hosts = await getKnownHosts();
const host = hosts.find(
h => h.name.toLowerCase() === hostName.toLowerCase() || h.id === hostName
);
if (!host) return null;
const peer = this.getPeersByHost(host.id).find(
p =>
p.agentName.toLowerCase() === peerName.toLowerCase() ||
p.agentId === peerName ||
p.aliases.some(a => a.toLowerCase() === peerName.toLowerCase())
);
if (!peer) return null;
return { host, peer };
}
const peer = this.findPeerByName(peerName);
if (!peer) return null;
const hosts = await getKnownHosts();
const host = hosts.find(h => h.id === peer.hostId);
if (!host) {
const localConfig = await getLocalHostConfig();
if (peer.hostId === localConfig.id) {
return {
host: {
id: localConfig.id,
name: localConfig.name,
address: '127.0.0.1',
port: localConfig.port,
status: 'online',
lastSeen: new Date().toISOString(),
},
peer,
};
}
return null;
}
return { host, peer };
}
updatePeerStatus(hostId: string, agentId: string, status: Peer['status']): void {
const key = `${hostId}:${agentId}`;
const peer = this.registry.peers.get(key);
if (peer) {
peer.status = status;
peer.lastSeen = new Date().toISOString();
}
}
markHostOffline(hostId: string): void {
for (const [, peer] of this.registry.peers) {
if (peer.hostId === hostId) {
peer.status = 'offline';
}
}
}
markHostOnline(hostId: string): void {
for (const [, peer] of this.registry.peers) {
if (peer.hostId === hostId) {
peer.status = 'online';
peer.lastSeen = new Date().toISOString();
}
}
}
clearRemotePeers(): void {
this.registry.peers.clear();
}
private async loadLocalPeers(): Promise<void> {
const filePath = join(PEERS_DIR, 'local-peers.json');
if (!existsSync(filePath)) return;
try {
const content = await readFile(filePath, 'utf-8');
const peers = JSON.parse(content) as Peer[];
for (const peer of peers) {
this.registry.localPeers.set(peer.agentId, peer);
}
} catch {
}
}
private async saveLocalPeers(): Promise<void> {
const filePath = join(PEERS_DIR, 'local-peers.json');
const peers = Array.from(this.registry.localPeers.values());
await mkdir(PEERS_DIR, { recursive: true });
await writeFile(filePath, JSON.stringify(peers, null, 2), 'utf-8');
}
}
let globalRegistry: PeerRegistryManager | null = null;
export async function getPeerRegistry(): Promise<PeerRegistryManager> {
if (!globalRegistry) {
globalRegistry = new PeerRegistryManager();
await globalRegistry.initialize();
}
return globalRegistry;
}
-311
View File
@@ -1,311 +0,0 @@
import { SignJWT, jwtVerify, importPKCS8, importSPKI, type KeyLike } from 'jose';
import { randomBytes, createPrivateKey, createPublicKey } from 'node:crypto';
import { PeerIdentity } from '../crypto/identity.js';
import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
export interface AuthToken {
hostId: string;
fingerprint: string;
publicKey: string;
capabilities: string[];
iat: number;
exp: number;
}
export interface AuthChallengeRequest {
challenge: string;
timestamp: string;
}
export interface AuthChallengeResponse {
challenge: string;
signature: string;
publicKey: string;
fingerprint: string;
timestamp: string;
}
export interface AuthResult {
authenticated: boolean;
fingerprint?: string;
publicKey?: string;
error?: string;
}
const DEFAULT_TOKEN_TTL = 24 * 60 * 60;
const CHALLENGE_SIZE = 32;
const CHALLENGE_EXPIRY_MS = 30 * 1000;
export class AuthManager {
private identity: PeerIdentity;
private pendingChallenges: Map<string, { expected: string; expires: number }> =
new Map();
constructor(identity: PeerIdentity) {
this.identity = identity;
}
private async getSigningKey(): Promise<KeyLike> {
const privateKeyObj = createPrivateKey({
key: Buffer.concat([
Buffer.from('302e020100300506032b657004220420', 'hex'),
Buffer.from(this.identity.privateKey),
]),
format: 'der',
type: 'pkcs8',
});
const pem = privateKeyObj.export({ type: 'pkcs8', format: 'pem' }) as string;
return importPKCS8(pem, 'EdDSA');
}
private async getVerifyingKey(publicKeyHex: string): Promise<KeyLike> {
const publicKeyBytes = hexToBytes(publicKeyHex);
const publicKeyObj = createPublicKey({
key: Buffer.concat([
Buffer.from('302a300506032b6570032100', 'hex'),
Buffer.from(publicKeyBytes),
]),
format: 'der',
type: 'spki',
});
const pem = publicKeyObj.export({ type: 'spki', format: 'pem' }) as string;
return importSPKI(pem, 'EdDSA');
}
async createToken(
hostId: string,
capabilities: string[] = [],
ttlSeconds: number = DEFAULT_TOKEN_TTL
): Promise<string> {
const now = Math.floor(Date.now() / 1000);
const signingKey = await this.getSigningKey();
const token = await new SignJWT({
hostId,
fingerprint: this.identity.fingerprint,
publicKey: this.identity.publicKeyHex,
capabilities,
})
.setProtectedHeader({ alg: 'EdDSA' })
.setIssuedAt(now)
.setExpirationTime(now + ttlSeconds)
.setIssuer('skillkit-mesh')
.sign(signingKey);
return token;
}
async verifyToken(token: string): Promise<AuthToken | null> {
try {
const parts = token.split('.');
if (parts.length !== 3) {
return null;
}
const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
if (!payload.publicKey) {
return null;
}
const computedFingerprint = PeerIdentity.computeFingerprint(hexToBytes(payload.publicKey));
if (computedFingerprint !== payload.fingerprint) {
return null;
}
const verifyingKey = await this.getVerifyingKey(payload.publicKey);
const { payload: verified } = await jwtVerify(token, verifyingKey, {
issuer: 'skillkit-mesh',
});
return {
hostId: verified.hostId as string,
fingerprint: verified.fingerprint as string,
publicKey: verified.publicKey as string,
capabilities: (verified.capabilities as string[]) || [],
iat: verified.iat as number,
exp: verified.exp as number,
};
} catch {
return null;
}
}
createChallenge(): AuthChallengeRequest {
const challengeBytes = randomBytes(CHALLENGE_SIZE);
const challenge = bytesToHex(challengeBytes);
const timestamp = new Date().toISOString();
this.pendingChallenges.set(challenge, {
expected: challenge,
expires: Date.now() + CHALLENGE_EXPIRY_MS,
});
this.cleanupExpiredChallenges();
return {
challenge,
timestamp,
};
}
async respondToChallenge(
challengeRequest: AuthChallengeRequest
): Promise<AuthChallengeResponse> {
const message = `${challengeRequest.challenge}:${challengeRequest.timestamp}`;
const signature = await this.identity.signString(message);
return {
challenge: challengeRequest.challenge,
signature,
publicKey: this.identity.publicKeyHex,
fingerprint: this.identity.fingerprint,
timestamp: challengeRequest.timestamp,
};
}
async verifyChallengeResponse(
response: AuthChallengeResponse
): Promise<AuthResult> {
const pending = this.pendingChallenges.get(response.challenge);
if (!pending) {
return {
authenticated: false,
error: 'Unknown or expired challenge',
};
}
if (Date.now() > pending.expires) {
this.pendingChallenges.delete(response.challenge);
return {
authenticated: false,
error: 'Challenge expired',
};
}
try {
const publicKey = hexToBytes(response.publicKey);
const computedFingerprint = PeerIdentity.computeFingerprint(publicKey);
if (computedFingerprint !== response.fingerprint) {
return {
authenticated: false,
error: 'Fingerprint mismatch',
};
}
const message = `${response.challenge}:${response.timestamp}`;
const messageBytes = new TextEncoder().encode(message);
const signature = hexToBytes(response.signature);
const valid = await PeerIdentity.verify(signature, messageBytes, publicKey);
if (!valid) {
return {
authenticated: false,
error: 'Invalid signature',
};
}
this.pendingChallenges.delete(response.challenge);
return {
authenticated: true,
fingerprint: response.fingerprint,
publicKey: response.publicKey,
};
} catch (error) {
return {
authenticated: false,
error: error instanceof Error ? error.message : 'Verification failed',
};
}
}
private cleanupExpiredChallenges(): void {
const now = Date.now();
for (const [challenge, data] of this.pendingChallenges) {
if (now > data.expires) {
this.pendingChallenges.delete(challenge);
}
}
}
async createSignedMessage(payload: unknown): Promise<{
payload: unknown;
signature: string;
fingerprint: string;
timestamp: string;
}> {
const timestamp = new Date().toISOString();
const toSign = JSON.stringify({ payload, timestamp });
const signature = await this.identity.signString(toSign);
return {
payload,
signature,
fingerprint: this.identity.fingerprint,
timestamp,
};
}
async verifySignedMessage(message: {
payload: unknown;
signature: string;
fingerprint: string;
timestamp: string;
publicKey?: string;
}): Promise<{ valid: boolean; fingerprint?: string; error?: string }> {
try {
if (!message.publicKey) {
return { valid: false, error: 'Missing public key' };
}
const publicKey = hexToBytes(message.publicKey);
const computedFingerprint = PeerIdentity.computeFingerprint(publicKey);
if (computedFingerprint !== message.fingerprint) {
return { valid: false, error: 'Fingerprint mismatch' };
}
const toSign = JSON.stringify({
payload: message.payload,
timestamp: message.timestamp,
});
const messageBytes = new TextEncoder().encode(toSign);
const signature = hexToBytes(message.signature);
const valid = await PeerIdentity.verify(signature, messageBytes, publicKey);
if (!valid) {
return { valid: false, error: 'Invalid signature' };
}
return { valid: true, fingerprint: message.fingerprint };
} catch (error) {
return {
valid: false,
error: error instanceof Error ? error.message : 'Verification failed',
};
}
}
get fingerprint(): string {
return this.identity.fingerprint;
}
get publicKey(): string {
return this.identity.publicKeyHex;
}
}
export function extractBearerToken(
authHeader: string | undefined
): string | null {
if (!authHeader) return null;
const match = authHeader.match(/^Bearer\s+(.+)$/i);
return match ? match[1] : null;
}
export function createBearerHeader(token: string): string {
return `Bearer ${token}`;
}

Some files were not shown because too many files have changed in this diff Show More