Compare commits

..
Author SHA1 Message Date
Rohit Ghumare b456f7b691 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:32:12 +00:00
Rohit Ghumare a5d692093a fix: add all 32 agents to documentation and tests
- apps/skillkit/README.md: Split agents into Primary (17) and Extended (15)
- e2e/onboarding-ui.e2e.test.ts: Add 15 extended agents to test array
- e2e/translation.e2e.test.ts: Add 15 extended agents to SUPPORTED_AGENTS
- README.md: Add extended agents to inline list and table
2026-01-29 13:20:06 +00:00
Rohit Ghumare 6c8d5b0a72 fix: update agent count from 17 to 32 across codebase
- Update all documentation files (README.md, package READMEs)
- Update hardcoded AGENT_COUNT constant in onboarding
- Update JSDoc comments in core modules
- Update test files and e2e tests
- SkillKit now supports 32 AI coding agents:
  Primary: claude-code, codex, cursor, antigravity, opencode,
  gemini-cli, amp, clawdbot, droid, github-copilot, goose,
  kilo, kiro-cli, roo, trae, windsurf, universal
  Extended: cline, codebuddy, commandcode, continue, crush,
  factory, mcpjam, mux, neovate, openhands, pi, qoder, qwen,
  vercel, zencoder
2026-01-29 13:07:52 +00:00
171 changed files with 3766 additions and 20165 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 -86
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
@@ -322,9 +323,6 @@ skillkit primer --all-agents # Generate for all 32 agents
skillkit primer --agent claude-code,cursor # Specific agents only
skillkit primer --dry-run # Preview without writing files
skillkit primer --analyze-only # Only show codebase analysis
skillkit primer --output ./instructions # Write to custom directory
skillkit primer --json # Output analysis as JSON (for scripting)
skillkit primer --json --analyze-only # Machine-readable analysis
```
Inspired by [primer](https://github.com/pierceboggan/primer) but extended for all SkillKit agents.
@@ -353,37 +351,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 +417,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 +489,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 +545,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",
+2 -10
View File
@@ -81,16 +81,8 @@ export function getAdapter(type: AgentType): AgentAdapter {
return adapters[type];
}
export interface AgentAdapterWithType extends AgentAdapter {
readonly agentType: AgentType;
}
export function getAllAdapters(): AgentAdapterWithType[] {
return Object.entries(adapters).map(([type, adapter]) => ({
...adapter,
type: type as AgentType,
agentType: type as AgentType,
}));
export function getAllAdapters(): AgentAdapter[] {
return Object.values(adapters);
}
export async function detectAgent(): Promise<AgentType> {
+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();
}
}
}
+1 -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'));
@@ -169,6 +107,7 @@ export class PrimerCommand extends Command {
try {
const result = generatePrimer(projectPath, {
projectPath,
agents,
allAgents: this.allAgents,
outputDir: this.output ? resolve(this.output) : undefined,
-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'],
};
@@ -173,7 +173,6 @@ describe('Primer', () => {
});
expect(result.success).toBe(true);
expect(result.generated.length).toBeGreaterThan(0);
const instruction = result.generated[0];
expect(instruction.content).toContain('# test-project');
+13 -21
View File
@@ -1,5 +1,5 @@
import { existsSync, readFileSync, readdirSync } from 'node:fs';
import { join, basename, relative, sep } from 'node:path';
import { join, basename } from 'node:path';
import type {
PrimerAnalysis,
PackageManager,
@@ -125,8 +125,7 @@ export class PrimerAnalyzer {
try {
const entries = readdirSync(dir, { withFileTypes: true });
for (const entry of entries) {
const fullPath = join(dir, entry.name);
const relativePath = relative(this.projectPath, fullPath);
const relativePath = join(dir, entry.name).replace(this.projectPath + '/', '');
if (entry.name.startsWith('.') && entry.name !== '.github' && entry.name !== '.env.example') {
if (!entry.isDirectory()) {
this.files.add(relativePath);
@@ -138,7 +137,7 @@ export class PrimerAnalyzer {
}
this.files.add(relativePath);
if (entry.isDirectory()) {
scan(fullPath, depth + 1);
scan(join(dir, entry.name), depth + 1);
}
}
} catch {
@@ -232,15 +231,10 @@ export class PrimerAnalyzer {
}
if (this.hasFile('pyproject.toml') || this.hasFile('requirements.txt') || this.hasFile('setup.py')) {
const source = this.hasFile('pyproject.toml')
? 'pyproject.toml'
: this.hasFile('requirements.txt')
? 'requirements.txt'
: 'setup.py';
languages.push({
name: 'python',
confidence: 100,
source,
source: 'pyproject.toml',
});
}
@@ -295,8 +289,8 @@ export class PrimerAnalyzer {
return languages;
}
private detectPackageManagers(): PackageManager[] {
const managers: Set<PackageManager> = new Set();
private detectPackageManagers(): string[] {
const managers: Set<string> = new Set();
for (const [file, manager] of Object.entries(PACKAGE_MANAGER_FILES)) {
if (this.hasFile(file)) {
@@ -308,8 +302,8 @@ export class PrimerAnalyzer {
const packageManager = this.packageJson.packageManager;
if (typeof packageManager === 'string') {
const match = packageManager.match(/^(npm|pnpm|yarn|bun)@/);
if (match && ['npm', 'pnpm', 'yarn', 'bun'].includes(match[1])) {
managers.add(match[1] as PackageManager);
if (match) {
managers.add(match[1]);
}
}
}
@@ -322,11 +316,11 @@ export class PrimerAnalyzer {
hasWorkspaces: false,
};
if (this.hasFile('packages') || this.hasFile('apps')) {
structure.type = 'monorepo';
} else if (this.hasFile('src')) {
if (this.hasFile('src')) {
structure.type = 'src-based';
structure.srcDir = 'src';
} else if (this.hasFile('packages') || this.hasFile('apps')) {
structure.type = 'monorepo';
} else if (this.hasFile('lib')) {
structure.type = 'src-based';
structure.srcDir = 'lib';
@@ -588,7 +582,7 @@ export class PrimerAnalyzer {
let directories = 0;
for (const file of this.files) {
if (file.includes(sep)) {
if (file.includes('/')) {
directories++;
}
files++;
@@ -602,9 +596,7 @@ export class PrimerAnalyzer {
private hasFile(name: string): boolean {
if (name.includes('*')) {
const regex = new RegExp(
name.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')
);
const regex = new RegExp(name.replace(/\*/g, '.*'));
for (const file of this.files) {
if (regex.test(file)) return true;
}
+151 -314
View File
@@ -12,121 +12,40 @@ import type {
import { AGENT_INSTRUCTION_TEMPLATES } from './types.js';
import { analyzePrimer } from './analyzer.js';
const ALL_AGENTS: AgentType[] = Object.keys(AGENT_CONFIG) as AgentType[];
type OutputFormat = 'markdown' | 'mdc' | 'json' | 'xml';
interface FormatRenderer {
h1(text: string): string;
h2(text: string): string;
h3(text: string): string;
bold(text: string): string;
code(text: string): string;
codeBlock(code: string, lang?: string): string;
list(items: string[]): string;
keyValue(key: string, value: string): string;
paragraph(text: string): string;
separator(): string;
wrap(content: string, metadata?: Record<string, unknown>): string;
}
const markdownRenderer: FormatRenderer = {
h1: (text) => `# ${text}`,
h2: (text) => `## ${text}`,
h3: (text) => `### ${text}`,
bold: (text) => `**${text}**`,
code: (text) => `\`${text}\``,
codeBlock: (code, lang = '') => `\`\`\`${lang}\n${code}\n\`\`\``,
list: (items) => items.map(item => `- ${item}`).join('\n'),
keyValue: (key, value) => `**${key}:** ${value}`,
paragraph: (text) => text,
separator: () => '',
wrap: (content) => content,
};
const mdcRenderer: FormatRenderer = {
h1: (text) => `# ${text}`,
h2: (text) => `## ${text}`,
h3: (text) => `### ${text}`,
bold: (text) => `**${text}**`,
code: (text) => `\`${text}\``,
codeBlock: (code, lang = '') => `\`\`\`${lang}\n${code}\n\`\`\``,
list: (items) => items.map(item => `- ${item}`).join('\n'),
keyValue: (key, value) => `**${key}:** ${value}`,
paragraph: (text) => text,
separator: () => '',
wrap: (content, metadata) => {
if (metadata && Object.keys(metadata).length > 0) {
const yaml = Object.entries(metadata)
.map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
.join('\n');
return `---\n${yaml}\n---\n\n${content}`;
}
return content;
},
};
const jsonRenderer: FormatRenderer = {
h1: (text) => text,
h2: (text) => text,
h3: (text) => text,
bold: (text) => text,
code: (text) => text,
codeBlock: (code) => code,
list: (items) => items.join(', '),
keyValue: (key, value) => `${key}: ${value}`,
paragraph: (text) => text,
separator: () => '',
wrap: (content, metadata) => {
try {
const data = { ...metadata, content };
return JSON.stringify(data, null, 2);
} catch {
return content;
}
},
};
const xmlRenderer: FormatRenderer = {
h1: (text) => `<h1>${escapeXml(text)}</h1>`,
h2: (text) => `<h2>${escapeXml(text)}</h2>`,
h3: (text) => `<h3>${escapeXml(text)}</h3>`,
bold: (text) => `<strong>${escapeXml(text)}</strong>`,
code: (text) => `<code>${escapeXml(text)}</code>`,
codeBlock: (code, lang = '') => `<pre${lang ? ` lang="${lang}"` : ''}><code>${escapeXml(code)}</code></pre>`,
list: (items) => `<ul>\n${items.map(item => ` <li>${escapeXml(item)}</li>`).join('\n')}\n</ul>`,
keyValue: (key, value) => `<dt>${escapeXml(key)}</dt><dd>${escapeXml(value)}</dd>`,
paragraph: (text) => `<p>${escapeXml(text)}</p>`,
separator: () => '',
wrap: (content, metadata) => {
const attrs = metadata
? Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(String(v))}"`).join(' ')
: '';
return `<?xml version="1.0" encoding="UTF-8"?>\n<instructions${attrs ? ' ' + attrs : ''}>\n${content}\n</instructions>`;
},
};
function escapeXml(text: string): string {
return text
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&apos;');
}
function getRenderer(format: OutputFormat): FormatRenderer {
switch (format) {
case 'mdc':
return mdcRenderer;
case 'json':
return jsonRenderer;
case 'xml':
return xmlRenderer;
default:
return markdownRenderer;
}
}
const ALL_AGENTS: AgentType[] = [
'claude-code',
'cursor',
'codex',
'gemini-cli',
'opencode',
'antigravity',
'amp',
'clawdbot',
'droid',
'github-copilot',
'goose',
'kilo',
'kiro-cli',
'roo',
'trae',
'windsurf',
'universal',
'cline',
'codebuddy',
'commandcode',
'continue',
'crush',
'factory',
'mcpjam',
'mux',
'neovate',
'openhands',
'pi',
'qoder',
'qwen',
'vercel',
'zencoder',
];
export class PrimerGenerator {
private projectPath: string;
@@ -142,7 +61,6 @@ export class PrimerGenerator {
const warnings: string[] = [];
const errors: string[] = [];
const generated: GeneratedInstruction[] = [];
const seenPaths = new Map<string, string>();
this.analysis = analyzePrimer(this.projectPath);
@@ -162,15 +80,6 @@ export class PrimerGenerator {
try {
const instruction = this.generateForAgent(agent);
if (instruction) {
const existingAgent = seenPaths.get(instruction.filepath);
if (existingAgent) {
warnings.push(
`Skipping ${agent}: output path "${instruction.filename}" already used by ${existingAgent}`
);
continue;
}
seenPaths.set(instruction.filepath, agent);
if (!this.options.dryRun) {
this.writeInstruction(instruction);
}
@@ -253,21 +162,10 @@ export class PrimerGenerator {
}
private getDefaultTemplate(agent: AgentType, config: AgentDirectoryConfig): AgentInstructionTemplate {
const formatMap: Record<string, OutputFormat> = {
'.md': 'markdown',
'.json': 'json',
'.mdc': 'mdc',
'.xml': 'xml',
};
const ext = config.configFile.includes('.')
? '.' + config.configFile.split('.').pop()
: '.md';
const format = formatMap[ext] || 'markdown';
return {
agent,
filename: config.configFile,
format,
format: 'markdown',
sectionOrder: ['overview', 'stack', 'commands', 'conventions', 'structure', 'guidelines'],
};
}
@@ -275,17 +173,10 @@ export class PrimerGenerator {
private generateContent(template: AgentInstructionTemplate): string {
if (!this.analysis) return '';
const format = template.format as OutputFormat;
const renderer = getRenderer(format);
if (format === 'json') {
return this.generateJsonContent(template);
}
const sections: string[] = [];
for (const section of template.sectionOrder) {
const content = this.generateSection(section, template, renderer);
const content = this.generateSection(section, template);
if (content) {
sections.push(content);
}
@@ -302,310 +193,271 @@ export class PrimerGenerator {
}
if (this.options.customInstructions) {
result += '\n\n' + renderer.h2('Custom Instructions') + '\n\n' + this.options.customInstructions;
result += '\n\n## Custom Instructions\n\n' + this.options.customInstructions;
}
const metadata = format === 'mdc' ? {
title: this.analysis.project.name,
type: this.analysis.project.type,
generated: new Date().toISOString(),
} : undefined;
return renderer.wrap(result, metadata);
return result;
}
private generateJsonContent(template: AgentInstructionTemplate): string {
if (!this.analysis) return '{}';
const data: Record<string, unknown> = {
project: this.analysis.project,
languages: this.analysis.languages.map(l => l.name),
packageManagers: this.analysis.packageManagers,
stack: {
frameworks: this.analysis.stack.frameworks.map(f => ({ name: f.name, version: f.version })),
libraries: this.analysis.stack.libraries.map(l => ({ name: l.name, version: l.version })),
styling: this.analysis.stack.styling.map(s => s.name),
testing: this.analysis.stack.testing.map(t => t.name),
databases: this.analysis.stack.databases.map(d => d.name),
},
commands: this.analysis.buildCommands,
conventions: this.analysis.conventions,
structure: this.analysis.structure,
importantFiles: this.analysis.importantFiles,
generated: {
agent: template.agent,
timestamp: new Date().toISOString(),
},
};
if (this.options.customInstructions) {
data.customInstructions = this.options.customInstructions;
}
return JSON.stringify(data, null, 2);
}
private generateSection(section: string, template: AgentInstructionTemplate, renderer: FormatRenderer): string {
private generateSection(section: string, template: AgentInstructionTemplate): string {
if (!this.analysis) return '';
switch (section) {
case 'overview':
return this.generateOverviewSection(renderer);
return this.generateOverviewSection();
case 'stack':
return this.generateStackSection(renderer);
return this.generateStackSection();
case 'commands':
return this.generateCommandsSection(renderer);
return this.generateCommandsSection();
case 'conventions':
return this.generateConventionsSection(renderer);
return this.generateConventionsSection();
case 'structure':
return this.generateStructureSection(renderer);
return this.generateStructureSection();
case 'guidelines':
return this.generateGuidelinesSection(template.agent, renderer);
return this.generateGuidelinesSection(template.agent);
default:
return '';
}
}
private generateOverviewSection(renderer: FormatRenderer): string {
private generateOverviewSection(): string {
if (!this.analysis) return '';
const { project, languages } = this.analysis;
const lines: string[] = [];
lines.push(renderer.h1(project.name));
lines.push(`# ${project.name}`);
lines.push('');
if (project.description) {
lines.push(renderer.paragraph(project.description));
lines.push(project.description);
lines.push('');
}
if (project.type) {
lines.push(renderer.keyValue('Project Type', this.formatProjectType(project.type)));
lines.push(`**Project Type:** ${this.formatProjectType(project.type)}`);
}
if (languages.length > 0) {
const langNames = languages.map(l => this.capitalize(l.name)).join(', ');
lines.push(renderer.keyValue('Languages', langNames));
lines.push(`**Languages:** ${langNames}`);
}
if (project.version) {
lines.push(renderer.keyValue('Version', project.version));
lines.push(`**Version:** ${project.version}`);
}
return lines.join('\n');
}
private generateStackSection(renderer: FormatRenderer): string {
private generateStackSection(): string {
if (!this.analysis) return '';
const { stack, packageManagers } = this.analysis;
const lines: string[] = [];
lines.push(renderer.h2('Technology Stack'));
lines.push('## Technology Stack');
lines.push('');
if (stack.frameworks.length > 0) {
lines.push(renderer.h3('Frameworks'));
const items = stack.frameworks.map(fw => {
lines.push('### Frameworks');
for (const fw of stack.frameworks) {
const version = fw.version ? ` (${fw.version})` : '';
return `${this.capitalize(fw.name)}${version}`;
});
lines.push(renderer.list(items));
lines.push(`- ${this.capitalize(fw.name)}${version}`);
}
lines.push('');
}
if (stack.libraries.length > 0) {
lines.push(renderer.h3('Libraries'));
const items = stack.libraries.map(lib => {
lines.push('### Libraries');
for (const lib of stack.libraries) {
const version = lib.version ? ` (${lib.version})` : '';
return `${this.capitalize(lib.name)}${version}`;
});
lines.push(renderer.list(items));
lines.push(`- ${this.capitalize(lib.name)}${version}`);
}
lines.push('');
}
if (stack.styling.length > 0) {
lines.push(renderer.h3('Styling'));
lines.push(renderer.list(stack.styling.map(s => this.capitalize(s.name))));
lines.push('### Styling');
for (const style of stack.styling) {
lines.push(`- ${this.capitalize(style.name)}`);
}
lines.push('');
}
if (stack.testing.length > 0) {
lines.push(renderer.h3('Testing'));
lines.push(renderer.list(stack.testing.map(t => this.capitalize(t.name))));
lines.push('### Testing');
for (const test of stack.testing) {
lines.push(`- ${this.capitalize(test.name)}`);
}
lines.push('');
}
if (stack.databases.length > 0) {
lines.push(renderer.h3('Databases'));
lines.push(renderer.list(stack.databases.map(d => this.capitalize(d.name))));
lines.push('### Databases');
for (const db of stack.databases) {
lines.push(`- ${this.capitalize(db.name)}`);
}
lines.push('');
}
if (packageManagers.length > 0) {
lines.push(renderer.h3('Package Manager'));
lines.push(renderer.list([packageManagers.map(pm => this.capitalize(pm)).join(', ')]));
lines.push('### Package Manager');
lines.push(`- ${packageManagers.map(pm => this.capitalize(pm)).join(', ')}`);
lines.push('');
}
return lines.join('\n');
}
private generateCommandsSection(renderer: FormatRenderer): string {
private generateCommandsSection(): string {
if (!this.analysis || !this.analysis.buildCommands) return '';
const { buildCommands } = this.analysis;
const lines: string[] = [];
const commands: string[] = [];
lines.push(renderer.h2('Development Commands'));
lines.push('## Development Commands');
lines.push('');
lines.push('```bash');
if (buildCommands.install) {
commands.push(`# Install dependencies`);
commands.push(buildCommands.install);
commands.push('');
lines.push(`# Install dependencies`);
lines.push(buildCommands.install);
lines.push('');
}
if (buildCommands.dev) {
commands.push(`# Start development server`);
commands.push(buildCommands.dev);
commands.push('');
lines.push(`# Start development server`);
lines.push(buildCommands.dev);
lines.push('');
}
if (buildCommands.build) {
commands.push(`# Build for production`);
commands.push(buildCommands.build);
commands.push('');
lines.push(`# Build for production`);
lines.push(buildCommands.build);
lines.push('');
}
if (buildCommands.test) {
commands.push(`# Run tests`);
commands.push(buildCommands.test);
commands.push('');
lines.push(`# Run tests`);
lines.push(buildCommands.test);
lines.push('');
}
if (buildCommands.lint) {
commands.push(`# Run linter`);
commands.push(buildCommands.lint);
commands.push('');
lines.push(`# Run linter`);
lines.push(buildCommands.lint);
lines.push('');
}
if (buildCommands.format) {
commands.push(`# Format code`);
commands.push(buildCommands.format);
lines.push(`# Format code`);
lines.push(buildCommands.format);
}
lines.push(renderer.codeBlock(commands.join('\n'), 'bash'));
lines.push('```');
return lines.join('\n');
}
private generateConventionsSection(renderer: FormatRenderer): string {
private generateConventionsSection(): string {
if (!this.analysis) return '';
const { conventions, patterns } = this.analysis;
const lines: string[] = [];
lines.push(renderer.h2('Code Conventions'));
lines.push('## Code Conventions');
lines.push('');
if (conventions) {
const items: string[] = [];
if (conventions.indentation) {
items.push(`${renderer.bold('Indentation:')} ${conventions.indentation}`);
lines.push(`- **Indentation:** ${conventions.indentation}`);
}
if (conventions.quotes) {
items.push(`${renderer.bold('Quotes:')} ${conventions.quotes}`);
lines.push(`- **Quotes:** ${conventions.quotes}`);
}
if (conventions.semicolons !== undefined) {
items.push(`${renderer.bold('Semicolons:')} ${conventions.semicolons ? 'required' : 'omitted'}`);
lines.push(`- **Semicolons:** ${conventions.semicolons ? 'required' : 'omitted'}`);
}
if (conventions.trailingCommas) {
items.push(`${renderer.bold('Trailing Commas:')} ${conventions.trailingCommas}`);
lines.push(`- **Trailing Commas:** ${conventions.trailingCommas}`);
}
if (conventions.maxLineLength) {
items.push(`${renderer.bold('Max Line Length:')} ${conventions.maxLineLength}`);
}
if (items.length > 0) {
lines.push(renderer.list(items));
lines.push(`- **Max Line Length:** ${conventions.maxLineLength}`);
}
}
if (patterns) {
lines.push('');
lines.push(renderer.h3('Patterns'));
const items: string[] = [];
lines.push('### Patterns');
if (patterns.components) {
items.push(`${renderer.bold('Components:')} ${patterns.components}`);
lines.push(`- **Components:** ${patterns.components}`);
}
if (patterns.stateManagement) {
items.push(`${renderer.bold('State Management:')} ${patterns.stateManagement}`);
lines.push(`- **State Management:** ${patterns.stateManagement}`);
}
if (patterns.apiStyle) {
items.push(`${renderer.bold('API Style:')} ${patterns.apiStyle}`);
lines.push(`- **API Style:** ${patterns.apiStyle}`);
}
if (patterns.styling) {
items.push(`${renderer.bold('Styling:')} ${patterns.styling}`);
lines.push(`- **Styling:** ${patterns.styling}`);
}
if (patterns.testing) {
items.push(`${renderer.bold('Testing:')} ${patterns.testing}`);
lines.push(`- **Testing:** ${patterns.testing}`);
}
if (patterns.linting) {
items.push(`${renderer.bold('Linting:')} ${patterns.linting}`);
lines.push(`- **Linting:** ${patterns.linting}`);
}
if (patterns.formatting) {
items.push(`${renderer.bold('Formatting:')} ${patterns.formatting}`);
}
if (items.length > 0) {
lines.push(renderer.list(items));
lines.push(`- **Formatting:** ${patterns.formatting}`);
}
}
return lines.join('\n');
}
private generateStructureSection(renderer: FormatRenderer): string {
private generateStructureSection(): string {
if (!this.analysis) return '';
const { structure, importantFiles } = this.analysis;
const lines: string[] = [];
lines.push(renderer.h2('Project Structure'));
lines.push('## Project Structure');
lines.push('');
if (structure) {
if (structure.type) {
lines.push(renderer.keyValue('Structure Type', structure.type));
lines.push(`**Structure Type:** ${structure.type}`);
}
if (structure.srcDir) {
lines.push(renderer.keyValue('Source Directory', renderer.code(`${structure.srcDir}/`)));
lines.push(`**Source Directory:** \`${structure.srcDir}/\``);
}
if (structure.testDir) {
lines.push(renderer.keyValue('Test Directory', renderer.code(`${structure.testDir}/`)));
lines.push(`**Test Directory:** \`${structure.testDir}/\``);
}
if (structure.hasWorkspaces && structure.workspaces) {
lines.push(renderer.keyValue('Workspaces', structure.workspaces.join(', ')));
lines.push(`**Workspaces:** ${structure.workspaces.join(', ')}`);
}
lines.push('');
}
if (importantFiles.length > 0) {
lines.push(renderer.h3('Important Files'));
lines.push(renderer.list(importantFiles.slice(0, 15).map(f => renderer.code(f))));
lines.push('### Important Files');
for (const file of importantFiles.slice(0, 15)) {
lines.push(`- \`${file}\``);
}
}
return lines.join('\n');
}
private generateGuidelinesSection(_agent: AgentType, renderer: FormatRenderer): string {
private generateGuidelinesSection(_agent: AgentType): string {
if (!this.analysis) return '';
const { stack, patterns } = this.analysis;
const lines: string[] = [];
lines.push(renderer.h2('Development Guidelines'));
lines.push('## Development Guidelines');
lines.push('');
const hasReact = stack.frameworks.some(f => f.name === 'react' || f.name === 'nextjs');
@@ -616,74 +468,59 @@ export class PrimerGenerator {
const hasZod = stack.libraries.some(l => l.name === 'zod');
if (hasTypeScript) {
lines.push(renderer.h3('TypeScript'));
lines.push(renderer.list([
'Use strict TypeScript with proper type annotations',
'Prefer `interface` for object types, `type` for unions/intersections',
'Avoid `any` - use `unknown` when type is uncertain',
]));
lines.push('### TypeScript');
lines.push('- Use strict TypeScript with proper type annotations');
lines.push('- Prefer `interface` for object types, `type` for unions/intersections');
lines.push('- Avoid `any` - use `unknown` when type is uncertain');
lines.push('');
}
if (hasReact) {
lines.push(renderer.h3('React'));
const reactItems = [
'Use functional components with hooks',
'Prefer composition over inheritance',
'Keep components small and focused',
];
lines.push('### React');
lines.push('- Use functional components with hooks');
lines.push('- Prefer composition over inheritance');
lines.push('- Keep components small and focused');
if (patterns?.stateManagement) {
reactItems.push(`Use ${patterns.stateManagement} for state management`);
lines.push(`- Use ${patterns.stateManagement} for state management`);
}
lines.push(renderer.list(reactItems));
lines.push('');
}
if (hasVue) {
lines.push(renderer.h3('Vue'));
lines.push(renderer.list([
'Use Composition API with `<script setup>`',
'Keep components small and focused',
]));
lines.push('### Vue');
lines.push('- Use Composition API with `<script setup>`');
lines.push('- Keep components small and focused');
lines.push('');
}
if (hasTailwind) {
lines.push(renderer.h3('Styling'));
lines.push(renderer.list([
'Use Tailwind CSS utility classes',
'Follow mobile-first responsive design',
'Extract repeated patterns to components',
]));
lines.push('### Styling');
lines.push('- Use Tailwind CSS utility classes');
lines.push('- Follow mobile-first responsive design');
lines.push('- Extract repeated patterns to components');
lines.push('');
}
if (hasPrisma) {
lines.push(renderer.h3('Database'));
lines.push(renderer.list([
'Use Prisma for database operations',
'Keep database queries in dedicated service files',
'Use transactions for related operations',
]));
lines.push('### Database');
lines.push('- Use Prisma for database operations');
lines.push('- Keep database queries in dedicated service files');
lines.push('- Use transactions for related operations');
lines.push('');
}
if (hasZod) {
lines.push(renderer.h3('Validation'));
lines.push(renderer.list([
'Use Zod for runtime validation',
'Define schemas alongside types',
]));
lines.push('### Validation');
lines.push('- Use Zod for runtime validation');
lines.push('- Define schemas alongside types');
lines.push('');
}
lines.push(renderer.h3('General'));
lines.push(renderer.list([
'Follow existing code patterns and conventions',
'Write clear, self-documenting code',
'Keep functions small and focused',
'Add tests for new functionality',
]));
lines.push('### General');
lines.push('- Follow existing code patterns and conventions');
lines.push('- Write clear, self-documenting code');
lines.push('- Keep functions small and focused');
lines.push('- Add tests for new functionality');
return lines.join('\n');
}
+1 -1
View File
@@ -91,7 +91,7 @@ export const PrimerAnalysis = z.object({
repository: z.string().optional(),
}),
languages: z.array(Detection).default([]),
packageManagers: z.array(PackageManager).default([]),
packageManagers: z.array(z.string()).default([]),
stack: ProjectStack,
patterns: ProjectPatterns.optional(),
structure: ProjectStructure.optional(),
-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;
}

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