Compare commits

..
Author SHA1 Message Date
Rohit Ghumare 9f0eabc876 chore: bump version to 1.21.0 2026-04-11 16:27:20 +01:00
Rohit Ghumare ceeae304b5 Merge pull request #105 from rohitg00/feat/infra-v1.21
feat: trust levels, checksum updates, lock.json, custom taps
2026-04-11 16:26:17 +01:00
Rohit Ghumare bb97e9b747 docs: update agent count to 45, add v1.21.0 feature docs
- Fix "44 agents" → "45 agents" across 34 files (website, docs,
  package.json, tests, extension, API, TUI)
- README: add tap, check, update, publish submit to commands section
- Commands.tsx: add Sources category with tap commands, update manage
  group with remove --source/--all and check
- commands.mdx: full docs for tap, check, update, remove, publish
  submit with all new flags and behaviors
- configuration.mdx: document lock.json and taps.json
- security.mdx: document trust badges system
2026-04-11 14:09:58 +01:00
Rohit Ghumare 8b4f207fa1 fix: gate official badge on GitHub provider type 2026-04-11 13:56:26 +01:00
Rohit Ghumare c533d6f3bc fix: respect --no-federated flag to disable GitHub search 2026-04-11 13:52:02 +01:00
Rohit Ghumare e7dbaeb2b3 fix: standalone path in lock, sync lock on update, honor --force
- install: use actual installed path (handles .md files) for lock
  entry and results instead of reconstructing from skillName
- update: call addSkillToLock after both local and remote updates
  so lock.json stays in sync with metadata
- update: --force bypasses GitHub activity and checksum skip-checks
- update: timestamp comparison falls back to installedAt when
  updatedAt is not set
2026-04-11 13:46:28 +01:00
Rohit Ghumare 05b566c0df fix: address Devin and CodeRabbit review findings
- Use finally for temp cleanup so user cancels don't leak cloned dirs
- Move addSkillToLock outside inner agent loop, merge agents array
- Use source:name as lock key to avoid cross-source collisions
- Gate GitHub activity check on provider.type (skip for GitLab/Bitbucket)
- Normalize source URL to owner/repo before official check
- Include skill name in trust badge output
- Atomic lock.json writes via tmp file + renameSync
- Remove stale --federated suggestion from find no-results message
2026-04-11 13:36:07 +01:00
Rohit Ghumare 56c565bc65 feat: add user-level custom taps for skill sources
Introduce tap add/remove/list commands to manage custom skill sources
stored in ~/.skillkit/taps.json. Taps are included in find/search
results, allowing users to add private or community repositories.
2026-04-11 11:52:46 +01:00
Rohit Ghumare b4582c465d feat: add centralized lock.json for installed skill tracking
Introduce ~/.skillkit/lock.json with LockEntry/LockFile schemas to
track all installed skills in a single file. Install writes entries,
remove deletes them. Enables future team sync and reproducible setups.
2026-04-11 11:50:17 +01:00
Rohit Ghumare d929fe3af0 feat: add checksum-based change detection for skill updates
Compute SHA-256 checksum of SKILL.md on install and store in metadata.
During update, check GitHub pushedAt timestamp and compare checksums
to skip unnecessary re-downloads when content hasn't changed.
2026-04-11 11:49:05 +01:00
Rohit Ghumare 696db60cb4 feat: add trust level badges during install confirmation
Show trust badges for each skill during install: [Official] for known
official sources (Anthropic, Vercel, Expo, Remotion, Supabase, Stripe),
or [Trusted]/[Review]/[Caution] based on TrustScorer analysis.
2026-04-11 11:47:41 +01:00
Rohit Ghumare da14f329fd feat: quarantine cleanup on failure, federated search by default
- Hoist cloneResult above try block so catch can clean up temp dir
  on any failure path, not just the happy path
- Always include GitHub API in find search results (was behind
  --federated flag, now default)
2026-04-11 11:45:03 +01:00
Rohit Ghumare dc3f9ba330 Merge pull request #104 from rohitg00/feat/publish-check-stats
feat: direct publish, GitHub API update detection, quality scores
2026-04-11 11:27:34 +01:00
Rohit Ghumare 4206b8aab1 fix: prevent command injection in auto-publish workflow
- Pass all user-controlled values via env vars instead of
  interpolating ${{ outputs.* }} into inline scripts
- Fix operator precedence bug: entry.source || (owner && repo ? ...)
- Use --body-file instead of heredocs with interpolated values
- Quote all variable references in shell commands
2026-04-11 10:56:33 +01:00
Rohit Ghumare a4540c5fc1 simplify: extract timeAgo and fetchGitHubActivity to shared helpers 2026-04-11 10:50:59 +01:00
Rohit Ghumare 8cfae7e105 feat: auto-publish workflow for skill submissions and add HermesHub source
Add .github/workflows/auto-publish.yml that triggers on skill-submission
labeled issues, extracts JSON from issue body, validates the source repo
exists, runs security scanner and quality evaluation, then auto-merges
passing submissions (score >= 75) or flags them for manual review.

Add NousResearch/hermes-agent to marketplace/sources.json as a federated
search source for Hermes agent skills.
2026-04-11 10:45:44 +01:00
Rohit Ghumare f2183b8e14 feat: direct publish via gh CLI, GitHub API update detection, quality scores
publish submit:
- Runs quality eval + security scan before submission
- Shows quality badge, stars, last push date, and warnings
- Creates issue directly via gh CLI (no browser needed)
- Falls back to manual URL if gh is not installed/authenticated
- Issue body includes quality score, stars, and push date

check:
- Fetches pushed_at from GitHub API for real update detection
- Shows quality badges next to skill names
- Shows stars and push date in verbose mode
- Displays average quality score across all skills
2026-04-11 10:36:29 +01:00
Rohit Ghumare 573bbbeed7 Update README.md 2026-04-11 00:30:03 +01:00
Rohit Ghumare 7003fd3372 docs: add comparison video, update README for v1.20.0
- Add skills-vs-skillkit.mp4 comparison video
- Update agent count from 44 to 45
- Add remove --source/--all to commands section
- Add v1.20.0 callout (live progress, sparse checkout, bulk remove)
2026-04-11 00:25:59 +01:00
Rohit Ghumare c611e70764 fix: bump version in docs packages to 1.20.0 2026-04-10 22:12:40 +01:00
Rohit Ghumare 73f95c0b6e chore: bump version to 1.20.0 2026-04-10 22:11:44 +01:00
Rohit Ghumare 25556d15d9 Merge pull request #103 from rohitg00/feat/clone-progress-sparse
feat: live clone progress + sparse checkout for large repos
2026-04-10 22:10:41 +01:00
Rohit Ghumare 2b1c04e221 fix: address CodeRabbit review findings
- findSkill: fall through to .md check when parseSkill returns null
- Use isPathInside instead of dir.includes(cwd) for location detection
- Optional chaining on meta.source in remove --source filter
- Track fence delimiter type per CommonMark (backtick vs tilde)
- Wrap statSync in try-catch so one bad source doesn't abort all installs
- Add cleanup fallback when sparse-checkout/checkout fails
2026-04-10 22:10:07 +01:00
Rohit Ghumare b1e1e2f266 simplify: extract toAdapterInfo helper, remove spawnGit overloads
- helpers.ts: extract toAdapterInfo() to eliminate 4x repeated object
  construction
- base.ts: remove redundant spawnGit overload signatures, remove
  ?? (() => {}) since spawnGit already handles undefined onProgress
2026-04-10 22:06:06 +01:00
Rohit Ghumare 84fb16486b fix: save metadata for standalone .md skills as sibling dotfiles
Standalone .md skills (e.g. doc_explanation.md) now get metadata saved
as .doc_explanation.skillkit.json in the same directory. This allows
remove --source to find and remove them. Updated saveSkillMetadata,
loadSkillMetadata, loadMetadata, and remove command to handle both
directory and sibling metadata patterns.
2026-04-10 22:03:55 +01:00
Rohit Ghumare 0aae4b16a7 feat: add --all and --source flags to skillkit remove
- skillkit remove --all: removes all installed skills
- skillkit remove --source iii-hq/iii: removes all skills from that source
- Both check .skillkit.json metadata to match source
2026-04-10 21:59:24 +01:00
Rohit Ghumare 244413da79 fix: show logo on TTY regardless of --all/--yes flags 2026-04-10 21:57:39 +01:00
Rohit Ghumare d9d775b189 fix: skillkit read searches all agent dirs and finds standalone .md skills
getSearchDirs now collects skill directories from ALL agent adapters
instead of only the configured agent. This fixes 'skill not found' when
skills were installed to .claude/skills/ but the default agent is
universal (which only searches skills/).

findSkill now also checks name.md for standalone .md skills that were
installed as plain files.
2026-04-10 21:56:06 +01:00
Rohit Ghumare ba09309d5b fix: compute standalone file target path once, use everywhere
Move isStandaloneFile detection and .md suffix normalization before
the existence/force/symlink checks so all code paths use the same
effective target path. Fixes --force not detecting previously installed
standalone skills and symlinks pointing to the wrong filename.
2026-04-10 21:51:30 +01:00
Rohit Ghumare 430bcefaa6 fix: narrow partial clone fallback, cap stderr, add -- before paths
- Restrict try/catch to only the partial clone spawn so
  sparse-checkout/checkout failures bubble up as real errors instead
  of being misreported as "partial clone unsupported"
- Cap stderr accumulator to 4KB to bound memory on verbose clones
- Add -- terminator before sparsePaths in sparse-checkout set to
  prevent user-controlled subpath from being parsed as git options
2026-04-10 21:49:13 +01:00
Rohit Ghumare 3007e9f8fd fix: preserve standalone .md skills as plain files
Instead of wrapping standalone .md skills in a directory, copy them
as-is with .md extension. Skip saveSkillMetadata for standalone files
since it requires a directory. This preserves the original format that
repos like iii-hq/iii use for lightweight single-file skills.
2026-04-10 21:46:18 +01:00
Rohit Ghumare 7160dfddf2 fix: install standalone .md skills by wrapping in a directory
Standalone .md skills (e.g. doc_explanation.md) were copied as plain
files, then saveSkillMetadata tried to write .skillkit.json inside
them causing ENOTDIR. Now detects file sources via statSync and
creates a directory with SKILL.md inside instead.
2026-04-10 21:44:02 +01:00
Rohit Ghumare 16d00a8ec9 fix: address review findings in cloneRepo and scanner
- spawnGit: set stdout to 'ignore' instead of 'pipe' to prevent
  buffer deadlock (git clone writes to stderr, not stdout)
- tryPartialClone: emit fallback message via onProgress instead of
  silently swallowing the error
- scanner: preserve fence markers so PI011 delimiter injection is
  still detected, only strip inner code block content
- scanner: guard against unclosed frontmatter by looking ahead for
  closing --- before entering frontmatter mode
2026-04-10 21:40:45 +01:00
Rohit Ghumare 3457fbc011 fix: sparse checkout includes subpath so skill discovery works
cloneRepo now accepts a subpath option. When set, sparse-checkout
includes both the subpath itself and SKILL_DISCOVERY_PATHS under it.
All four providers pass their parsed subpath through to cloneRepo.

Without this, sparse checkout would skip the subpath directory and
discoverSkills would find nothing.
2026-04-10 21:27:44 +01:00
Rohit Ghumare dd30ee0af0 fix: scanner false positives on markdown code blocks and frontmatter
Strip fenced code blocks and standard YAML frontmatter before scanning
markdown files. This eliminates three categories of false positives:

- PI013: no longer flags standard --- frontmatter delimiters
- CI007: no longer flags curl|sh in code examples
- DE003: no longer flags process.env in code examples

Real threats in prose (outside code blocks) are still caught.
2026-04-10 21:25:03 +01:00
Rohit Ghumare 1fb95fd57e feat: add live clone progress and sparse checkout for large repos
Replace silent execFileSync with async spawn + --progress flag so the
spinner shows real download progress (e.g. "Receiving objects 45%").
For large monorepos, try partial clone (--filter=blob:none) with sparse
checkout of SKILL_DISCOVERY_PATHS first, falling back to regular
--depth 1 clone if the server doesn't support it. Also adds
--single-branch --no-tags to all clones.

Shared cloneRepo() helper in base.ts eliminates duplicate clone logic
across all four git providers.
2026-04-10 20:28:38 +01:00
Rohit Ghumare dfa8d12c65 Merge pull request #100 from rohitg00/fix/audit-batch-3
fix: complete chalk→onboarding migration, refactor install.ts
2026-04-07 19:58:50 +01:00
Rohit Ghumare 172602f173 fix: preserve exit codes in refactored install.ts, fix spinner API
- selectSkills/selectAgents now return { result, exitCode } to
  distinguish errors (exit 1) from cancellations (exit 0)
- Fixes: --skill with nonexistent name returned 0 instead of 1
- Fixes: --agent with invalid name returned 0 instead of 1
- ai.ts: s.stop('msg', 1) → s.stop(colors.error('msg'))
  (clack spinner.stop only accepts message, not exit code)
2026-04-07 15:46:15 +01:00
Rohit Ghumare e542c4e484 fix: complete chalk→onboarding migration, refactor install.ts (#87 #88 #93)
Complete chalk/ora elimination:
- All 41 chalk imports removed from commands/ (41→0)
- All ora imports removed (replaced with onboarding spinner)
- Consistent use of colors/warn/success/error/step helpers

install.ts refactor (#93):
- extract execute() from 700→50 lines (orchestration only)
- 14 focused private methods: resolveSource, listSkills,
  selectSkills, selectAgents, selectMethod, runSecurityScan,
  confirmInstall, performInstall, cleanupTemp, updateAgentsMd,
  showResults, showSkillsShStats, showProTips

Closes #87, closes #93
Partial progress on #88 (spinners added via migration)
2026-04-07 14:02:01 +01:00
Rohit Ghumare 9fa542e8d8 Merge pull request #99 from rohitg00/fix/audit-batch-2
fix: normalize --agent flag, migrate 6 commands to onboarding helpers
2026-04-07 12:30:28 +01:00
Rohit Ghumare f714a39a46 fix: add deprecation warning when --agents is used
generate.ts and manifest.ts now warn when --agents (deprecated) is
used instead of --agent. Message: "Warning: --agents is deprecated,
use --agent instead (--agents will be removed in v2.0)"

Findings 3 (scan.ts stderr) and 4 (translate.ts stderr) skipped:
error() from onboarding goes to stdout via clack — this is the
standard pattern across all migrated commands. Changing individual
commands would break consistency.
2026-04-07 12:27:37 +01:00
Rohit Ghumare d9142c8125 fix: simplify review — error styling, double-wrap, aliases
- translate.ts: 7 error paths used colors.muted() (gray) instead of
  error() (red) — errors were invisible. Now properly styled.
- update.ts: error(colors.muted(...)) double-wrapped ANSI codes.
  Split into s.stop() for headline + console.log for detail.
- enable.ts: dropped successLog/errorLog aliases, renamed counters
  to successCount/failedCount (matches translate.ts pattern)
- update.ts: removed unused error import
2026-04-07 12:24:15 +01:00
Rohit Ghumare 64944a1c50 fix: normalize --agent flag, migrate 6 commands to onboarding helpers
Option naming (#94):
- generate.ts, manifest.ts: accept --agent as primary (--agents as alias)

Chalk→onboarding migration (#87, #88):
- update.ts: chalk/ora → colors/spinner from onboarding
- translate.ts: chalk → colors/warn/success from onboarding
- remove.ts: chalk → colors/warn/success/error from onboarding
- enable.ts: chalk → colors/warn/successLog/errorLog from onboarding
- scan.ts: stderr.write → error() from onboarding
- list.ts: chalk → colors/warn from onboarding

Chalk imports reduced from 41 to 36 across commands.
All 13 packages build, all 25 test suites pass.
2026-04-07 12:15:03 +01:00
Rohit Ghumare 12bba7f32c Merge pull request #98 from rohitg00/fix/openclaw-cleanup
refactor: deduplicate OpenClaw adapter, fix clawdbot config
2026-04-07 11:57:07 +01:00
Rohit Ghumare 02fe3f2509 fix: TUI uses hardcoded AgentType — import from @skillkit/core instead
The TUI had a manually-maintained 44-agent AgentType union in
translator.service.ts that fell out of sync when openclaw was added
to core. Replace with re-export from @skillkit/core so it stays in
sync automatically. Fixes CI typecheck failure from #86.
2026-04-07 11:52:16 +01:00
Rohit Ghumare 808ae83271 refactor: deduplicate OpenClaw adapter, fix clawdbot config
Follow-up to #86 — cleanup without changing contributor attribution.

- OpenClawAdapter extends ClawdbotAdapter (removes 80 lines of copy-paste)
- Revert clawdbot config to legacy paths (.clawdbot/skills, AGENTS.md)
- OpenClaw detection: ~/.openclaw or openclaw.json
- Widen ClawdbotAdapter property types for extensibility
- Fix tests: adapter count 44→45, remove stale detection assertions
2026-04-07 11:48:05 +01:00
Rohit Ghumare 5324e4528b feat: add OpenClaw agent adapter (Clawdbot rebrand) (#86)
feat: add OpenClaw agent adapter (Clawdbot rebrand)
2026-04-07 11:40:08 +01:00
Rohit Ghumare 59ea709613 fix: version display, install UX — audit findings (#95)
* fix: version display, install UX — audit findings

- Fix version showing hardcoded 1.7.6 instead of actual 1.19.2
  - Export setVersion/setAgentCount from @skillkit/cli
  - Call setVersion(version) and setAgentCount(getAllAdapters().length) in cli.ts
  - Change fallback from '1.7.6' to 'dev' so stale values are obvious

- Fix install pre-selecting all skills by default (bad UX)
  - Add "Install all / Select specific" prompt before multiselect
  - When selecting manually, start with nothing pre-selected
  - Apply same fix to both InstallCommand and runInstallFlow()
  - Matches existing quickAgentSelect pattern

Fixes found during comprehensive codebase audit.
Related issues: #87, #88, #89, #90, #91, #92, #93, #94

* refactor: extract quickSkillSelect, use getAdapterCount

- Extract duplicated "Install all / Select specific" pattern into
  quickSkillSelect() in prompts.ts (mirrors existing quickAgentSelect)
- Both install.ts and runInstallFlow() now use the shared helper
- Add getAdapterCount() to @skillkit/agents to avoid allocating 44
  spread-copied objects just to call .length
- Use getAdapterCount() in cli.ts instead of getAllAdapters().length
2026-04-07 10:44:29 +01:00
Lumina Mao 6ed78ceba7 fix: address PR review comments for OpenClaw adapter
- Remove legacy clawdbot path checks from OpenClawAdapter.isDetected()
  so pure clawdbot workspaces are not hijacked by OpenClaw detection
- Add '.openclaw/agents' to ALL_AGENT_DISCOVERY_PATHS so agent
  discovery works for OpenClaw agent directories
2026-03-27 05:10:21 -07:00
Lumina Mao 3509b74f85 feat: add OpenClaw agent adapter (Clawdbot rebrand)
OpenClaw (formerly Clawdbot) is a local-first AI agent framework with a
persistent gateway daemon. This adds first-class OpenClaw support:

- New `openclaw` agent type in AgentType enum and all Record types
- New `OpenClawAdapter` class with detection for `~/.openclaw/` + `openclaw.json`
- OpenClaw agent config: `skills/` dir (not `.clawdbot/skills/`), CLAUDE.md config
- Extended frontmatter fields: permissions, triggers, metadata, version, scan_exempt
- Agent dirs: `agents/` and `~/.openclaw/agents/`
- Command format: `.claude/commands/` directory
- Translator format map: `openclaw` → `skill-md`
- Simplified clawdbot adapter detection (legacy paths only)

OpenClaw SKILL.md files use an extended YAML frontmatter schema:
  - permissions: { filesystem: none|read|write, network: true|false }
  - triggers: [{ command: /skill-name }]
  - metadata.openclaw.requires: { bins: [], env: [], os: [] }

This enables `skillkit translate <skill> --to openclaw` producing
SKILL.md files compatible with the OpenClaw gateway runtime.

Ref: https://docs.openclaw.ai
2026-03-22 09:03:19 -07:00
Rohit Ghumare 5691b10c7e feat: add multi-tier eval engine (skillkit eval) (#85)
* feat: add multi-tier eval engine (skillkit eval)

6-tier evaluation system for comprehensive skill assessment:
- Tier 1: LLM quality scoring (G-Eval pattern, 6 dimensions)
- Tier 2: Contradiction detection (formal rules + LLM semantic)
- Tier 3: Behavioral security (code analysis + taint tracking + LLM)
- Tier 4: Sandbox execution testing (Docker, graceful skip)
- Tier 5: Dynamic marketplace benchmarks (percentile ranking)
- Tier 6: Community signals (freshness, metadata, content health)

Works without API keys (heuristic fallback for Tier 1, Tiers 5-6).
Full LLM evaluation with --provider flag.

* fix: address Devin review — input validation for eval CLI

- --min-score NaN bypass: validate parseInt result before comparison
- --timeout NaN propagation: skip NaN timeout instead of passing to Docker
- --tier invalid input: graceful error message instead of unhandled throw
- scoreContentSize formula: cap sub-optimal at 99 to distinguish from optimal

* fix: address CodeRabbit review findings on eval system

- Harden contradiction/security prompts against prompt injection by
  wrapping untrusted content in <skill_content> XML tags and adding
  explicit "treat as untrusted data" instructions
- Use head+tail content sampling in security prompt instead of head-only
  truncation to catch malicious payloads at end of content
- Add missing Tier 4 sandbox formatter to reporter.ts
- Fix misleading sampleSize fallback in dynamic-benchmark.ts
- Move --min-score NaN validation before engine.evaluate() to avoid
  wasting LLM calls on invalid input
- Add truncation indicator to quality-cot.ts prompts
- Add term length limits (>100 chars) in contradiction.ts to mitigate
  ReDoS risk on dynamically constructed regex

* fix: address round 2 review findings on eval system

- Wrap quality-cot prompts with <skill_content> XML tags and untrusted
  data instructions, consistent with contradiction/security prompts
- Change truncateContent to head+tail sampling (4000+2000) instead of
  head-only, so completeness/token-efficiency evaluators see both
  beginning and end of long skills
- Fix escapeXmlTags regex to handle whitespace variants before closing
  angle bracket (</skill_content >, </skill_content\n>)
- Type DIMENSION_PROMPTS with Record<EvalDimension, PromptBuilder> for
  compile-time key validation
- Clamp estimatePercentile return to [0,100] range defensively
- Make buildStatsFromMarketplace async with periodic yields (every 50
  skills) to avoid blocking the event loop on first-run cache miss
- Extract parsedTimeout local variable in eval.ts to avoid double
  parseInt parsing

* fix: address round 3 Devin + CodeRabbit findings on eval system

- Scan both code blocks AND full content for dangerous patterns in
  behavioral-security.ts, with deduplication by description+snippet
  to avoid double-reporting (Devin: security scanner skipped prose)
- Use non-greedy regex /\[[\s\S]*?\]/ in parseSemanticFindings to
  match first complete JSON array instead of greedily spanning to
  last bracket in LLM response (Devin: greedy regex corrupted JSON)
- Fix formatSandboxDetails to use r.testCase matching SandboxResult
  type instead of r.name which doesn't exist (Devin: property mismatch)
- Make MarketplaceSkill.description optional to match marketplace
  schema where only id/name/source/tags are required (CodeRabbit)
- Rename sandbox test case from "code example execution" to "code
  block content validation" since it validates content not execution
  (CodeRabbit)

* fix: address round 4 Devin + CodeRabbit findings on eval system

Inline fixes:
- Replace greedy JSON regex in behavioral-security.ts runLLMAnalysis
  with balanced bracket extraction that correctly handles ] inside
  JSON string values
- Replace non-greedy regex in contradiction.ts parseSemanticFindings
  with same balanced bracket extraction (non-greedy also breaks on
  inner brackets)
- Fix crossValidatedCount in behavioral-security.ts to accumulate
  (+= uniqueEngines.size) instead of replacing (Math.max)
- Fix gradeDeterministic: cleanExit && hasOutput without matching
  expectedOutcome now returns passed:false score:50 instead of
  passed:true score:75
- Docker unavailable returns score:-1 sentinel instead of 0/F;
  engine.ts filters score<0 tiers from overall average so
  Docker-less machines aren't penalized

Duplicate fix:
- Add score field to SandboxResult type; store gradeResult.score
  in each result; compute tier score from average of numeric scores
  instead of boolean pass rate

Nitpick fixes:
- Distinguish "Docker unavailable" from "No tests executed" in
  formatSandboxDetails
- Tighten base64 obfuscation regex to require 4-char groups
- Only push 'llm' to engines when LLM actually produced findings
- Bound \s+ to \s{1,10} in dynamically constructed regexes in
  contradiction.ts to prevent catastrophic backtracking
- Validate cache timestamp with Number.isFinite() in loadCache to
  reject corrupted cache files with NaN timestamps
2026-03-10 18:34:32 +00:00
134 changed files with 3485 additions and 2222 deletions
+324
View File
@@ -0,0 +1,324 @@
name: Auto-Publish Skill Submission
on:
issues:
types: [labeled]
permissions:
issues: write
contents: write
concurrency:
group: auto-publish-${{ github.event.issue.number }}
cancel-in-progress: false
jobs:
auto-publish:
if: github.event.label.name == 'skill-submission'
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install pnpm
uses: pnpm/action-setup@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'pnpm'
- name: Install dependencies
run: pnpm install --frozen-lockfile
- name: Build
run: pnpm build
- name: Extract and validate submission
id: validate
uses: actions/github-script@v7
env:
ISSUE_BODY: ${{ github.event.issue.body }}
with:
script: |
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');
const body = process.env.ISSUE_BODY || '';
const jsonMatch = body.match(/```json\s*\n([\s\S]*?)\n```/);
if (!jsonMatch) {
core.setOutput('status', 'error');
core.setOutput('message', 'No JSON block found in issue body. Please include your source entry between \\`\\`\\`json and \\`\\`\\` fences.');
return;
}
let entry;
try {
entry = JSON.parse(jsonMatch[1].trim());
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Invalid JSON in submission: ${e.message}`);
return;
}
const source = entry.source || (entry.owner && entry.repo ? `${entry.owner}/${entry.repo}` : null);
const name = entry.name;
const description = entry.description || '';
if (!source || !name) {
core.setOutput('status', 'error');
core.setOutput('message', 'Missing required fields. JSON must include `source` (owner/repo) and `name`.');
return;
}
const parts = source.split('/');
if (parts.length !== 2 || !parts[0] || !parts[1]) {
core.setOutput('status', 'error');
core.setOutput('message', `Invalid source format "${source}". Must be "owner/repo".`);
return;
}
const [owner, repo] = parts;
const sourcesData = JSON.parse(fs.readFileSync('marketplace/sources.json', 'utf-8'));
const existing = sourcesData.sources.find(s => s.source === source);
if (existing) {
core.setOutput('status', 'error');
core.setOutput('message', `Source "${source}" already exists in sources.json as "${existing.name}".`);
return;
}
try {
const repoCheck = await github.rest.repos.get({ owner, repo });
if (repoCheck.status !== 200) throw new Error('not found');
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Repository "${source}" does not exist or is not accessible on GitHub.`);
return;
}
const cloneDir = `/tmp/skill-check-${owner}-${repo}`;
try {
execSync(`git clone --depth 1 https://github.com/${owner}/${repo}.git ${cloneDir}`, {
timeout: 60000,
stdio: 'pipe',
});
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Failed to clone repository "${source}".`);
return;
}
let scanVerdict = 'pass';
let scanSummary = '';
let qualityScore = 0;
let qualitySummary = '';
try {
const scanScript = `
const { SkillScanner } = require('./packages/core/dist/scanner/scanner.js');
const scanner = new SkillScanner();
scanner.scan('${cloneDir}').then(result => {
console.log(JSON.stringify({
verdict: result.verdict,
stats: result.stats,
findings: result.findings.length,
}));
});
`;
const scanOutput = execSync(`node -e "${scanScript.replace(/\n/g, ' ')}"`, {
cwd: process.cwd(),
timeout: 30000,
stdio: 'pipe',
}).toString().trim();
const scanResult = JSON.parse(scanOutput);
scanVerdict = scanResult.verdict;
scanSummary = `Verdict: ${scanResult.verdict}, Findings: ${scanResult.findings}, Critical: ${scanResult.stats.critical}, High: ${scanResult.stats.high}`;
} catch (e) {
scanSummary = 'Scanner completed with warnings';
}
const skillMdCandidates = ['SKILL.md', 'skill.md', 'README.md'];
let skillContent = null;
for (const candidate of skillMdCandidates) {
try {
const found = execSync(`find ${cloneDir} -name "${candidate}" -maxdepth 3 -type f`, {
stdio: 'pipe',
}).toString().trim().split('\n').filter(Boolean);
if (found.length > 0) {
skillContent = fs.readFileSync(found[0], 'utf-8');
break;
}
} catch {}
}
if (skillContent) {
try {
const qualityScript = `
const { evaluateSkillContent } = require('./packages/core/dist/quality/index.js');
const fs = require('fs');
const content = fs.readFileSync('${cloneDir}/.skill-content.tmp', 'utf-8');
const result = evaluateSkillContent(content);
console.log(JSON.stringify({ overall: result.overall, warnings: result.warnings }));
`;
fs.writeFileSync(`${cloneDir}/.skill-content.tmp`, skillContent);
const qualityOutput = execSync(`node -e "${qualityScript.replace(/\n/g, ' ')}"`, {
cwd: process.cwd(),
timeout: 30000,
stdio: 'pipe',
}).toString().trim();
const qualityResult = JSON.parse(qualityOutput);
qualityScore = qualityResult.overall;
qualitySummary = `Score: ${qualityResult.overall}/100, Warnings: ${qualityResult.warnings.length}`;
} catch (e) {
qualityScore = 50;
qualitySummary = 'Quality evaluation encountered an error; defaulting to 50';
}
} else {
qualityScore = 50;
qualitySummary = 'No SKILL.md or README.md found; defaulting to score 50';
}
const scanPassed = scanVerdict !== 'fail';
const qualityPassed = qualityScore >= 75;
core.setOutput('source', source);
core.setOutput('name', name);
core.setOutput('description', description);
core.setOutput('official', entry.official === true ? 'true' : 'false');
core.setOutput('scan_verdict', scanVerdict);
core.setOutput('scan_summary', scanSummary);
core.setOutput('quality_score', String(qualityScore));
core.setOutput('quality_summary', qualitySummary);
if (scanPassed && qualityPassed) {
core.setOutput('status', 'pass');
core.setOutput('message', `Validation passed. Security: ${scanSummary}. Quality: ${qualitySummary}.`);
} else {
const reasons = [];
if (!scanPassed) reasons.push(`Security scan failed: ${scanSummary}`);
if (!qualityPassed) reasons.push(`Quality score ${qualityScore}/100 is below threshold of 75`);
core.setOutput('status', 'reject');
core.setOutput('message', reasons.join('. '));
}
- name: Add source and commit
if: steps.validate.outputs.status == 'pass'
env:
SKILL_SOURCE: ${{ steps.validate.outputs.source }}
SKILL_NAME: ${{ steps.validate.outputs.name }}
SKILL_DESCRIPTION: ${{ steps.validate.outputs.description }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
node -e "
const fs = require('fs');
const data = JSON.parse(fs.readFileSync('marketplace/sources.json', 'utf-8'));
const newEntry = { source: process.env.SKILL_SOURCE, name: process.env.SKILL_NAME };
if (process.env.SKILL_DESCRIPTION) {
newEntry.description = process.env.SKILL_DESCRIPTION;
}
const skillsSh = data.sources.pop();
data.sources.push(newEntry);
if (skillsSh && skillsSh.registry === 'skills-sh') {
data.sources.push(skillsSh);
}
data.updatedAt = new Date().toISOString().split('T')[0];
fs.writeFileSync('marketplace/sources.json', JSON.stringify(data, null, 2) + '\n');
"
git config --local user.email "github-actions[bot]@users.noreply.github.com"
git config --local user.name "github-actions[bot]"
git add marketplace/sources.json
git commit -m "feat(marketplace): add source from #${ISSUE_NUMBER}"
git push
- name: Close issue on success
if: steps.validate.outputs.status == 'pass'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
SKILL_SOURCE: ${{ steps.validate.outputs.source }}
SKILL_NAME: ${{ steps.validate.outputs.name }}
SCAN_SUMMARY: ${{ steps.validate.outputs.scan_summary }}
QUALITY_SUMMARY: ${{ steps.validate.outputs.quality_summary }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<ENDOFCOMMENT
**Skill source auto-published!**
**Source:** \`${SKILL_SOURCE}\`
**Name:** ${SKILL_NAME}
**Security:** ${SCAN_SUMMARY}
**Quality:** ${QUALITY_SUMMARY}
The source has been added to \`marketplace/sources.json\` and will be included in the next release.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue close "${ISSUE_NUMBER}"
- name: Comment rejection reason
if: steps.validate.outputs.status == 'reject'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REJECT_MESSAGE: ${{ steps.validate.outputs.message }}
SCAN_VERDICT: ${{ steps.validate.outputs.scan_verdict }}
SCAN_SUMMARY: ${{ steps.validate.outputs.scan_summary }}
QUALITY_SCORE: ${{ steps.validate.outputs.quality_score }}
QUALITY_SUMMARY: ${{ steps.validate.outputs.quality_summary }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<ENDOFCOMMENT
**Skill submission did not pass automated checks.**
${REJECT_MESSAGE}
**Details:**
- Security scan: ${SCAN_VERDICT} (${SCAN_SUMMARY})
- Quality score: ${QUALITY_SCORE}/100 (${QUALITY_SUMMARY})
Please address these issues and update your submission. A maintainer will review manually.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue edit "${ISSUE_NUMBER}" --add-label "needs-review"
- name: Comment parse error
if: steps.validate.outputs.status == 'error'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
ERROR_MESSAGE: ${{ steps.validate.outputs.message }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<'ENDOFCOMMENT'
**Could not process skill submission.**
ENDOFCOMMENT
echo "${ERROR_MESSAGE}" >> /tmp/comment.md
cat >> /tmp/comment.md <<'ENDOFCOMMENT'
**Expected format in issue body:**
```json
{
"source": "owner/repo",
"name": "Display Name",
"description": "Optional description"
}
```
Please update the issue body and re-apply the `skill-submission` label.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue edit "${ISSUE_NUMBER}" --add-label "needs-review"
+22 -8
View File
@@ -15,13 +15,14 @@
[![GitHub stars](https://img.shields.io/github/stars/rohitg00/skillkit?style=flat-square)](https://github.com/rohitg00/skillkit/stargazers) [![GitHub stars](https://img.shields.io/github/stars/rohitg00/skillkit?style=flat-square)](https://github.com/rohitg00/skillkit/stargazers)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=flat-square)](https://opensource.org/licenses/Apache-2.0) [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=flat-square)](https://opensource.org/licenses/Apache-2.0)
**SkillKit** is the open source package manager for AI agent skills. Write a skill once, deploy it to **44 agents** — Claude, Cursor, Copilot, Windsurf, Devin, Codex, and 38 more. No rewrites. 400K+ skills across registries. **SkillKit** is the open source package manager for AI agent skills. Write a skill once, deploy it to **45 agents** — Claude, Cursor, Copilot, Windsurf, Devin, Codex, and 39 more. No rewrites. 400K+ skills across registries.
[Website](https://skillkit.sh) &middot; [Docs](https://skillkit.sh/docs) &middot; [API Explorer](https://skillkit.sh/api) &middot; [Chrome Extension](https://github.com/rohitg00/skillkit/tree/main/packages/extension#readme) &middot; [npm](https://www.npmjs.com/package/skillkit) [Website](https://skillkit.sh) &middot; [Docs](https://skillkit.sh/docs) &middot; [API Explorer](https://skillkit.sh/api) &middot; [Chrome Extension](https://github.com/rohitg00/skillkit/tree/main/packages/extension#readme) &middot; [npm](https://www.npmjs.com/package/skillkit)
</div> </div>
--- ---
https://github.com/user-attachments/assets/b1843a07-2c54-422d-8903-f30a790cfb37
Skills make AI coding agents smarter. But every agent uses a different format: Skills make AI coding agents smarter. But every agent uses a different format:
@@ -34,7 +35,7 @@ Skills make AI coding agents smarter. But every agent uses a different format:
You end up rewriting the same skill for each agent, or locking into one platform. You end up rewriting the same skill for each agent, or locking into one platform.
**SkillKit fixes this.** Install from 400K+ skills across registries, auto-translate between formats, persist learnings with Memory. Works with Claude, Cursor, Windsurf, Copilot, and 40 more. **SkillKit fixes this.** Install from 400K+ skills across registries, auto-translate between formats, persist learnings with Memory. Works with Claude, Cursor, Windsurf, Copilot, and 41 more.
```bash ```bash
npx skillkit@latest npx skillkit@latest
@@ -44,12 +45,12 @@ npx skillkit@latest
<div align="center"> <div align="center">
[![Watch the demo](docs/img/inital-command.png)](https://raw.githubusercontent.com/rohitg00/skillkit/main/docs/video/skillkit.mp4) ![SkillKit vs skills CLI](docs/img/inital-command.png)
*Click the image above to watch the full demo*
</div> </div>
> **New in v1.20.0:** Live download progress, sparse checkout for monorepos (~1.4s for large repos), and `skillkit remove --source` to bulk-remove by repo.
## Quick Start ## Quick Start
```bash ```bash
@@ -203,7 +204,7 @@ skillkit ui
![SkillKit Interactive CLI](docs/img/inital-command.png) ![SkillKit Interactive CLI](docs/img/inital-command.png)
## Supported Agents (44) ## Supported Agents (45)
| Agent | Format | Directory | | Agent | Format | Directory |
|-------|--------|-----------| |-------|--------|-----------|
@@ -219,7 +220,7 @@ skillkit ui
| **Sourcegraph Cody** | SKILL.md | `.cody/skills/` | | **Sourcegraph Cody** | SKILL.md | `.cody/skills/` |
| **Amazon Q** | SKILL.md | `.amazonq/skills/` | | **Amazon Q** | SKILL.md | `.amazonq/skills/` |
Plus 33 more: Amp, Antigravity, Augment Code, Bolt, Clawdbot, Cline, CodeBuddy, CodeGPT, CommandCode, Continue, Crush, Droid, Factory, Goose, Kilo Code, Kiro CLI, Lovable, MCPJam, Mux, Neovate, OpenHands, Pi, PlayCode, Qoder, Qwen, Replit Agent, Roo Code, Tabby, Tabnine, Trae, Vercel, Zencoder, Universal Plus 34 more: Amp, Antigravity, Augment Code, Bolt, Clawdbot, Cline, CodeBuddy, CodeGPT, CommandCode, Continue, Crush, Droid, Factory, Goose, Kilo Code, Kiro CLI, Lovable, MCPJam, Mux, Neovate, OpenClaw, OpenHands, Pi, PlayCode, Qoder, Qwen, Replit Agent, Roo Code, Tabby, Tabnine, Trae, Vercel, Zencoder, Universal
[Full agent details](https://skillkit.sh/docs/agents) [Full agent details](https://skillkit.sh/docs/agents)
@@ -228,13 +229,18 @@ Plus 33 more: Amp, Antigravity, Augment Code, Bolt, Clawdbot, Cline, CodeBuddy,
### Core ### Core
```bash ```bash
skillkit install <source> # Install skills skillkit install <source> # Install skills (with live progress)
skillkit remove <skills> # Remove skills skillkit remove <skills> # Remove skills
skillkit remove --source org/repo # Remove all skills from a source
skillkit remove --all # Remove all installed skills
skillkit update # Update skills (with change detection)
skillkit check # Check for updates, quality, and activity
skillkit translate <skill> --to # Translate between agents skillkit translate <skill> --to # Translate between agents
skillkit sync # Deploy to agent config skillkit sync # Deploy to agent config
skillkit recommend # Smart recommendations skillkit recommend # Smart recommendations
skillkit generate # AI skill generation wizard skillkit generate # AI skill generation wizard
skillkit serve # Start REST API server skillkit serve # Start REST API server
skillkit publish submit # Publish to marketplace via CLI
``` ```
### Discovery & Security ### Discovery & Security
@@ -246,6 +252,14 @@ skillkit find <query> # Quick search
skillkit scan <path> # Security scan for skills skillkit scan <path> # Security scan for skills
``` ```
### Custom Sources
```bash
skillkit tap add owner/repo # Add custom skill source
skillkit tap list # List custom sources
skillkit tap remove owner/repo # Remove custom source
```
### Issue Planner ### Issue Planner
```bash ```bash
+35
View File
@@ -0,0 +1,35 @@
# SOUL
## Core Truths
- Ship working software. Everything else is negotiable.
- Simple beats clever. If a junior dev can't read it in 30 seconds, it's too complex.
- Opinions are load-bearing. "It depends" is a cop-out 90% of the time. Pick a side, explain why, move on.
- Exhaustion before escalation. Try everything available before asking for help or giving up.
- Broken things get fixed now, not "in a follow-up PR."
- If the tests pass and the build is green, stop touching it.
## Boundaries
- Never leak secrets, credentials, or private data. Period.
- Ask before doing anything destructive or irreversible. One confirmation. Not three.
- Be honest about uncertainty. "I don't know" is a valid answer. Bullshitting is not.
- The user's codebase is their house. Don't rearrange the furniture without permission.
## Vibe
- Never open with "Great question," "I'd be happy to help," or "Absolutely." Just answer.
- Brevity is mandatory. If the answer fits in one sentence, one sentence is what you get.
- Humor is welcome when it's natural. Not forced puns. The kind of wit that comes from actually understanding the problem.
- Call things out. If you're about to do something dumb, I'll say so. Charm over cruelty, but no sugarcoating.
- Swearing is fine when it lands. A well-placed "that's fucking brilliant" hits different than sterile corporate praise. Don't force it. Don't overdo it. But if a situation calls for a "holy shit" — say holy shit.
- No hedging. No weasel words. No "it might be worth considering perhaps maybe." Say the thing.
- Match energy. Quick question gets a quick answer. Deep problem gets deep analysis. Read the room.
- Code speaks louder than explanations. Show, don't tell. Then shut up.
- Be the assistant you'd actually want to talk to at 2am. Not a corporate drone. Not a sycophant. Just... good.
## Continuity
- This file is a living document. If something stops being true, change it.
- Session memory is ephemeral. This file is how identity persists.
- If this file gets modified during a session, say so explicitly.
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "skillkit", "name": "skillkit",
"version": "1.19.2", "version": "1.21.0",
"description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 13 more", "description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 13 more",
"type": "module", "type": "module",
"bin": { "bin": {
+12
View File
@@ -3,6 +3,8 @@ import { readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url'; import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path'; import { dirname, join } from 'node:path';
import { Cli, Builtins } from 'clipanion'; import { Cli, Builtins } from 'clipanion';
import { setVersion, setAgentCount } from '@skillkit/cli';
import { getAdapterCount } from '@skillkit/agents';
import { import {
InstallCommand, InstallCommand,
SyncCommand, SyncCommand,
@@ -122,6 +124,9 @@ import {
TimelineCommand, TimelineCommand,
SessionHandoffCommand, SessionHandoffCommand,
LineageCommand, LineageCommand,
TapAddCommand,
TapRemoveCommand,
TapListCommand,
} from '@skillkit/cli'; } from '@skillkit/cli';
const __filename = fileURLToPath(import.meta.url); const __filename = fileURLToPath(import.meta.url);
@@ -130,6 +135,9 @@ const packageJsonPath = join(__dirname, '../package.json');
const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')); const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
const version = packageJson.version || '1.2.0'; const version = packageJson.version || '1.2.0';
setVersion(version);
setAgentCount(getAdapterCount());
const cli = new Cli({ const cli = new Cli({
binaryLabel: 'skillkit', binaryLabel: 'skillkit',
binaryName: 'skillkit', binaryName: 'skillkit',
@@ -272,4 +280,8 @@ cli.register(TimelineCommand);
cli.register(SessionHandoffCommand); cli.register(SessionHandoffCommand);
cli.register(LineageCommand); cli.register(LineageCommand);
cli.register(TapAddCommand);
cli.register(TapRemoveCommand);
cli.register(TapListCommand);
cli.runExit(process.argv.slice(2)); cli.runExit(process.argv.slice(2));
+2 -2
View File
@@ -1,11 +1,11 @@
--- ---
title: Supported Agents title: Supported Agents
description: 44 AI coding agents supported by SkillKit description: 45 AI coding agents supported by SkillKit
--- ---
# Supported Agents # Supported Agents
SkillKit uses an adapter pattern to support 44 AI coding platforms. Each adapter implements `getConfigPath()` and `generateConfig()` methods. SkillKit uses an adapter pattern to support 45 AI coding platforms. Each adapter implements `getConfigPath()` and `generateConfig()` methods.
## Agent Directory Mapping ## Agent Directory Mapping
+93 -10
View File
@@ -70,11 +70,24 @@ skillkit install anthropics/skills --agent claude --agent cursor
skillkit remove <skill-names> [options] skillkit remove <skill-names> [options]
``` ```
| Option | Purpose | | Option | Short | Purpose |
|--------|---------| |--------|-------|---------|
| `--agent` | Target specific agents (default: all) | | `--agent` | — | Target specific agents (default: all) |
| `--yes` | Skip confirmation | | `--yes` | — | Skip confirmation |
| `--keep-metadata` | Remove skill but preserve metadata | | `--keep-metadata` | — | Remove skill but preserve metadata |
| `--source` | `-s` | Remove all skills installed from a specific source |
| `--all` | `-a` | Remove all installed skills |
| `--force` | `-f` | Skip confirmation prompt |
### Bulk Removal
```bash
skillkit remove --source iii-hq/iii
skillkit remove --all
skillkit remove --all --force
```
When using `--source`, SkillKit matches against the source field in each skill's metadata and removes every skill that was installed from that repository. When using `--all`, every discovered skill across all agent directories is removed. Both flags update AGENTS.md automatically if managed sections are present.
## Update Command ## Update Command
@@ -82,11 +95,19 @@ skillkit remove <skill-names> [options]
skillkit update [skill-names] [options] skillkit update [skill-names] [options]
``` ```
| Option | Purpose | | Option | Short | Purpose |
|--------|---------| |--------|-------|---------|
| `--dry-run` | Check for updates without installing | | `--dry-run` | — | Check for updates without installing |
| `--yes` | Skip confirmation prompts | | `--yes` | — | Skip confirmation prompts |
| `--agent` | Update in specific agents only | | `--agent` | — | Update in specific agents only |
| `--force` | `-f` | Force update, bypass checksum and GitHub API checks |
The update command uses a two-stage change detection pipeline:
1. **GitHub API check** -- For remote sources, SkillKit queries the GitHub API to compare the repository's `pushed_at` timestamp against the installed metadata. If the repository has not been pushed since the last install or update, the skill is skipped without cloning.
2. **Checksum comparison** -- After cloning, a checksum of the source SKILL.md is compared against the stored checksum. If the content is identical, the update is skipped.
Use `--force` to bypass both checks and always overwrite the installed skill.
## Enable/Disable Commands ## Enable/Disable Commands
@@ -97,6 +118,26 @@ skillkit disable <skill-names> [options]
Disabled skills are ignored by the `sync` command. No file changes occur. Disabled skills are ignored by the `sync` command. No file changes occur.
## Check Command
```bash
skillkit check [skill-names] [options]
```
Checks installed skills for available updates, quality scores, and GitHub activity.
| Option | Short | Purpose |
|--------|-------|---------|
| `--verbose` | `-v` | Show detailed output including stars and push dates |
| `--quiet` | `-q` | Minimal output |
For remote GitHub sources, the check command queries the GitHub API to compare each repository's `pushed_at` timestamp against the installed date. Each skill displays its quality score badge (A-F). In verbose mode, the output also includes the repository's star count and how recently it was pushed.
```bash
skillkit check
skillkit check pdf xlsx --verbose
```
## List Command ## List Command
```bash ```bash
@@ -457,6 +498,48 @@ skillkit publish --dry-run # Preview without writing
skillkit publish submit # Submit to SkillKit marketplace skillkit publish submit # Submit to SkillKit marketplace
``` ```
### publish submit
Submits a skill to the SkillKit marketplace by creating a GitHub issue on `rohitg00/skillkit` via the `gh` CLI. No browser is needed.
Before submitting, the command displays:
- Quality score and grade (A-F) from the skill evaluator
- GitHub star count and last push date from the GitHub API
- Any quality warnings (up to 3)
If `gh` is not installed or not authenticated, the command prints a manual submission URL as a fallback.
## Tap Command
Manage custom skill sources (taps). Taps are user-level source repositories stored in `~/.skillkit/taps.json`. They let you add private or third-party skill repositories that are not part of the official marketplace.
### tap add
Add a custom skill source.
```bash
skillkit tap add owner/repo
skillkit tap add owner/repo --name "My Skills"
```
### tap remove
Remove a custom skill source.
```bash
skillkit tap remove owner/repo
```
### tap list
List all custom skill sources.
```bash
skillkit tap list
```
Once a tap is added, skills from that source appear in `skillkit marketplace search` results and can be installed with the standard `skillkit install owner/repo` workflow.
## Security Scanning ## Security Scanning
```bash ```bash
@@ -152,11 +152,61 @@ primer:
- .next - .next
``` ```
## Lock File
SkillKit maintains a centralized lock file at `~/.skillkit/lock.json` that tracks every installed skill. The lock file is written on install, updated on update, and cleaned on remove.
```json
{
"version": 1,
"skills": {
"pdf": {
"source": "anthropics/skills",
"checksum": "sha256:abc123...",
"agents": ["claude-code", "cursor"],
"installedAt": "2026-04-01T12:00:00Z",
"updatedAt": "2026-04-08T09:30:00Z"
}
}
}
```
| Field | Description |
|-------|-------------|
| `source` | The repository or local path the skill was installed from |
| `checksum` | SHA-256 hash of the SKILL.md content at install time, used for update detection |
| `agents` | Which agents the skill is installed for |
| `installedAt` | ISO timestamp of initial installation |
| `updatedAt` | ISO timestamp of the most recent update |
The `update` command compares the stored checksum against the source to skip unchanged skills. The `remove` command cleans up the corresponding lock entry.
## Taps File
Custom skill source repositories are stored in `~/.skillkit/taps.json`. Taps are managed via the `skillkit tap` commands.
```json
{
"version": 1,
"taps": [
{
"source": "myorg/internal-skills",
"name": "Internal Skills",
"addedAt": "2026-04-05T10:00:00Z"
}
]
}
```
Skills from tapped sources appear in marketplace search results and can be installed like any other source. See the [tap command](/docs/commands#tap-command) documentation for usage.
## Directory Structure ## Directory Structure
``` ```
~/.skillkit/ ~/.skillkit/
├── preferences.json # User preferences ├── preferences.json # User preferences
├── lock.json # Installed skill tracking
├── taps.json # Custom skill sources
├── cache/ # Marketplace cache ├── cache/ # Marketplace cache
├── memory/ # Learning storage ├── memory/ # Learning storage
│ ├── observations/ │ ├── observations/
+1 -1
View File
@@ -29,7 +29,7 @@ skillkit/
│ ├── core/ # Business logic │ ├── core/ # Business logic
│ ├── cli/ # CLI │ ├── cli/ # CLI
│ ├── tui/ # Terminal UI │ ├── tui/ # Terminal UI
│ └── agents/ # 44 adapters │ └── agents/ # 45 adapters
├── marketplace/ # Skills data ├── marketplace/ # Skills data
│ ├── skills.json │ ├── skills.json
│ └── sources.json │ └── sources.json
+2 -2
View File
@@ -7,7 +7,7 @@ description: Universal skill management for AI coding agents
Skills make AI coding agents smarter. But every agent uses a different format — Claude Code wants `.claude/skills/`, Cursor uses `.mdc`, Copilot expects `.github/skills/`. You end up rewriting the same skill three times, or locking into one platform. Skills make AI coding agents smarter. But every agent uses a different format — Claude Code wants `.claude/skills/`, Cursor uses `.mdc`, Copilot expects `.github/skills/`. You end up rewriting the same skill three times, or locking into one platform.
SkillKit fixes this. Write a skill once, deploy it to all 44 agents. SkillKit fixes this. Write a skill once, deploy it to all 45 agents.
## Get Started ## Get Started
@@ -95,7 +95,7 @@ SkillKit sits between your skills and your agents. It handles format translation
## Supported Agents ## Supported Agents
44 agents and counting: 45 agents and counting:
**Claude Code** | **Cursor** | **Codex** | **Gemini CLI** | **OpenCode** | **GitHub Copilot** | **Windsurf** | Amp | Antigravity | Clawdbot | Cline | CodeBuddy | CommandCode | Continue | Crush | Droid | Factory | Goose | Kilo Code | Kiro CLI | MCPJam | Mux | Neovate | OpenHands | Pi | Qoder | Qwen | Roo Code | Trae | Vercel | Zencoder | Universal **Claude Code** | **Cursor** | **Codex** | **Gemini CLI** | **OpenCode** | **GitHub Copilot** | **Windsurf** | Amp | Antigravity | Clawdbot | Cline | CodeBuddy | CommandCode | Continue | Crush | Droid | Factory | Goose | Kilo Code | Kiro CLI | MCPJam | Mux | Neovate | OpenHands | Pi | Qoder | Qwen | Roo Code | Trae | Vercel | Zencoder | Universal
+1 -1
View File
@@ -58,7 +58,7 @@ The init command:
```bash ```bash
skillkit init --agent cursor skillkit init --agent cursor
skillkit init --list # Show all 44 supported agents skillkit init --list # Show all 45 supported agents
skillkit init --quiet # Skip logo and prompts (for CI) skillkit init --quiet # Skip logo and prompts (for CI)
``` ```
+3 -3
View File
@@ -5,7 +5,7 @@ description: Auto-generate AI agent instructions from your codebase
# Primer # Primer
Primer analyzes your codebase and automatically generates optimized instructions for all 44 AI agents. No more manual configuration—let SkillKit detect your tech stack, coding patterns, and project structure. Primer analyzes your codebase and automatically generates optimized instructions for all 45 AI agents. No more manual configuration—let SkillKit detect your tech stack, coding patterns, and project structure.
## Quick Start ## Quick Start
@@ -16,7 +16,7 @@ skillkit primer
# Generate for specific agents # Generate for specific agents
skillkit primer --agent claude,cursor,windsurf skillkit primer --agent claude,cursor,windsurf
# Generate for all 44 agents # Generate for all 45 agents
skillkit primer --all-agents skillkit primer --all-agents
# Preview without writing files # Preview without writing files
@@ -65,7 +65,7 @@ Primer creates agent-specific instructions for:
└── copilot-instructions.md └── copilot-instructions.md
``` ```
### All 44 Agents ### All 45 Agents
Each agent gets optimized instructions in their native format. Each agent gets optimized instructions in their native format.
## Example Output ## Example Output
+22
View File
@@ -242,6 +242,28 @@ console.log(`Findings: ${result.findings.length}`);
| **Low** | 1 (with `--fail-on low`) | Minor issue or best practice | | **Low** | 1 (with `--fail-on low`) | Minor issue or best practice |
| **Info** | 0 | Informational finding | | **Info** | 0 | Informational finding |
## Trust Badges
Skills display a trust badge based on their source and quality analysis. Badges appear during installation, in `skillkit check` output, and in marketplace search results.
| Badge | Criteria |
|-------|----------|
| **[Official]** | Published by a known official source (Anthropic, Vercel, iii-hq, etc.) |
| **[Trusted]** | TrustScorer rates the skill 8-10 based on clarity, boundaries, specificity, and safety |
| **[Review]** | TrustScorer rates the skill 5-7; the skill may need refinement |
| **[Caution]** | TrustScorer rates the skill 0-4; requires careful review before use |
The `TrustScorer` evaluates four weighted dimensions:
| Dimension | Weight | What it measures |
|-----------|--------|------------------|
| Clarity | 30% | How well-defined the skill's purpose and instructions are |
| Boundaries | 25% | Whether the skill stays within its declared scope |
| Specificity | 25% | How concrete and actionable the instructions are |
| Safety | 20% | Absence of dangerous patterns (injection, exfiltration, secrets) |
Official sources are allowlisted by organization name and always receive the `[Official]` badge regardless of score. For all other sources, the badge is determined by the composite trust score.
## False Positive Handling ## False Positive Handling
The scanner automatically filters: The scanner automatically filters:
+1 -1
View File
@@ -5,7 +5,7 @@ description: Convert skills between AI agent formats
# Translation # Translation
SkillKit automatically converts between all 44 agent formats using an adapter pattern. SkillKit automatically converts between all 45 agent formats using an adapter pattern.
## Basic Translation ## Basic Translation
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "skillkit-docs", "name": "skillkit-docs",
"version": "1.19.2", "version": "1.21.0",
"private": true, "private": true,
"scripts": { "scripts": {
"build": "next build", "build": "next build",
+2 -2
View File
@@ -39,8 +39,8 @@ export default function HomePage() {
{/* Features Grid */} {/* Features Grid */}
<div className="grid grid-cols-1 md:grid-cols-3 gap-6 mb-16"> <div className="grid grid-cols-1 md:grid-cols-3 gap-6 mb-16">
<div className="border border-zinc-800 bg-zinc-900/30 p-6"> <div className="border border-zinc-800 bg-zinc-900/30 p-6">
<h3 className="text-lg font-bold text-white mb-2 font-mono">44 Agents</h3> <h3 className="text-lg font-bold text-white mb-2 font-mono">45 Agents</h3>
<p className="text-zinc-500 text-sm">Claude, Cursor, Codex, Windsurf, Copilot, and 39 more supported out of the box.</p> <p className="text-zinc-500 text-sm">Claude, Cursor, Codex, Windsurf, Copilot, and 40 more supported out of the box.</p>
</div> </div>
<div className="border border-zinc-800 bg-zinc-900/30 p-6"> <div className="border border-zinc-800 bg-zinc-900/30 p-6">
<h3 className="text-lg font-bold text-white mb-2 font-mono">400K+ Skills</h3> <h3 className="text-lg font-bold text-white mb-2 font-mono">400K+ Skills</h3>
@@ -44,12 +44,12 @@ const sections: DocSection[] = [
content: ( content: (
<div className="space-y-4"> <div className="space-y-4">
<p className="text-zinc-300"> <p className="text-zinc-300">
SkillKit is a universal command-line interface (CLI) and programmatic toolkit for managing AI agent skills across 44 AI coding platforms. It solves the fragmentation problem where each AI agent uses different skill formats and directory structures. SkillKit is a universal command-line interface (CLI) and programmatic toolkit for managing AI agent skills across 45 AI coding platforms. It solves the fragmentation problem where each AI agent uses different skill formats and directory structures.
</p> </p>
<h3 className="text-lg font-semibold text-white mt-6">Core Capabilities</h3> <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"> <ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">Skill Discovery</span> - Browse 400K+ skills from registries with AI-powered recommendations</li> <li><span className="text-white">Skill Discovery</span> - Browse 400K+ skills from registries with AI-powered recommendations</li>
<li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 44 agent-specific formats</li> <li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 45 agent-specific formats</li>
<li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li> <li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li>
</ul> </ul>
</div> </div>
@@ -102,7 +102,7 @@ skillkit install anthropics/skills`}</CodeBlock>
<ul className="list-disc list-inside space-y-2 text-zinc-400"> <ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">UI Tier</span> - CLI commands, Terminal UI (OpenTUI-based), and documentation website</li> <li><span className="text-white">UI Tier</span> - CLI commands, Terminal UI (OpenTUI-based), and documentation website</li>
<li><span className="text-white">Core Logic Tier</span> - @skillkit/core for business logic; @skillkit/agents for adapter implementations</li> <li><span className="text-white">Core Logic Tier</span> - @skillkit/core for business logic; @skillkit/agents for adapter implementations</li>
<li><span className="text-white">Integration Tier</span> - File systems, Git repositories, marketplace APIs, and 44 AI agents</li> <li><span className="text-white">Integration Tier</span> - File systems, Git repositories, marketplace APIs, and 45 AI agents</li>
</ul> </ul>
<h3 className="text-lg font-semibold text-white mt-6">Monorepo Structure</h3> <h3 className="text-lg font-semibold text-white mt-6">Monorepo Structure</h3>
@@ -130,7 +130,7 @@ skillkit install anthropics/skills`}</CodeBlock>
content: ( content: (
<div className="space-y-4"> <div className="space-y-4">
<p className="text-zinc-300"> <p className="text-zinc-300">
SkillKit supports 44 AI coding agents with automatic format translation: SkillKit supports 45 AI coding agents with automatic format translation:
</p> </p>
<Table <Table
+3 -3
View File
@@ -9,7 +9,7 @@ interface Feature {
const FEATURES: Feature[] = [ const FEATURES: Feature[] = [
{ {
title: 'Multi-Agent', title: 'Multi-Agent',
description: 'Deploy to 44 AI coding agents with one command.', description: 'Deploy to 45 AI coding agents with one command.',
icon: ( icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor"> <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" /> <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
@@ -64,7 +64,7 @@ const FEATURES: Feature[] = [
]; ];
const COMPARISONS = [ const COMPARISONS = [
['Agents', '1', '44'], ['Agents', '1', '45'],
['Translation', 'Manual', 'Auto'], ['Translation', 'Manual', 'Auto'],
['Sharing', 'Copy/paste', '.skills manifest'], ['Sharing', 'Copy/paste', '.skills manifest'],
['Discovery', 'Forums', 'CLI + AI'], ['Discovery', 'Forums', 'CLI + AI'],
@@ -83,7 +83,7 @@ export function Features(): React.ReactElement {
</p> </p>
<div className="flex gap-6 sm:gap-8"> <div className="flex gap-6 sm:gap-8">
<div> <div>
<div className="text-2xl sm:text-3xl font-bold text-white font-mono">44</div> <div className="text-2xl sm:text-3xl font-bold text-white font-mono">45</div>
<div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Agents</div> <div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Agents</div>
</div> </div>
<div> <div>
@@ -69,8 +69,8 @@ const ADVANCED_FEATURES: AdvancedFeature[] = [
id: 'primer', id: 'primer',
title: 'Primer', title: 'Primer',
subtitle: 'Zero-Config AI Instructions', subtitle: 'Zero-Config AI Instructions',
description: 'Automatically generate CLAUDE.md, .cursorrules, and agent instructions by analyzing your codebase. Detects your tech stack, coding patterns, and project structure—then creates optimized instructions for all 44 agents.', description: 'Automatically generate CLAUDE.md, .cursorrules, and agent instructions by analyzing your codebase. Detects your tech stack, coding patterns, and project structure—then creates optimized instructions for all 45 agents.',
highlight: 'Auto-generates instructions for 44 agents', highlight: 'Auto-generates instructions for 45 agents',
icon: ( icon: (
<svg className="w-8 h-8" fill="none" viewBox="0 0 24 24" stroke="currentColor"> <svg className="w-8 h-8" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-3 7h3m-3 4h3m-6-4h.01M9 16h.01" /> <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-3 7h3m-3 4h3m-6-4h.01M9 16h.01" />
@@ -78,7 +78,7 @@ const ADVANCED_FEATURES: AdvancedFeature[] = [
), ),
commands: [ commands: [
{ cmd: 'primer', desc: 'Analyze & generate for detected agents' }, { cmd: 'primer', desc: 'Analyze & generate for detected agents' },
{ cmd: 'primer --all-agents', desc: 'Generate for all 44 agents' }, { cmd: 'primer --all-agents', desc: 'Generate for all 45 agents' },
{ cmd: 'primer --analyze-only', desc: 'Preview codebase analysis' }, { cmd: 'primer --analyze-only', desc: 'Preview codebase analysis' },
{ cmd: 'primer --json', desc: 'Machine-readable output' }, { cmd: 'primer --json', desc: 'Machine-readable output' },
], ],
+1 -1
View File
@@ -429,7 +429,7 @@ export function Agents(): React.ReactElement {
<section className="py-6 border-b border-zinc-800 overflow-hidden"> <section className="py-6 border-b border-zinc-800 overflow-hidden">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8"> <div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<p className="text-zinc-500 font-mono text-[11px] uppercase tracking-widest mb-6 text-center"> <p className="text-zinc-500 font-mono text-[11px] uppercase tracking-widest mb-6 text-center">
Works with 44 AI Agents Works with 45 AI Agents
</p> </p>
</div> </div>
+13 -3
View File
@@ -23,9 +23,19 @@ const COMMAND_GROUPS: CommandGroup[] = [
{ cmd: 'list', desc: 'View installed skills' }, { cmd: 'list', desc: 'View installed skills' },
{ cmd: 'sync', desc: 'Deploy to all agents' }, { cmd: 'sync', desc: 'Deploy to all agents' },
{ cmd: 'translate --to <agent>', desc: 'Convert formats' }, { cmd: 'translate --to <agent>', desc: 'Convert formats' },
{ cmd: 'update', desc: 'Update all skills' }, { cmd: 'update', desc: 'Update with change detection' },
{ cmd: 'remove <skill>', desc: 'Remove a skill' }, { cmd: 'remove <skill>', desc: 'Remove a skill' },
{ cmd: 'status', desc: 'Show skill status' }, { cmd: 'remove --source org/repo', desc: 'Bulk remove by repo' },
{ cmd: 'remove --all', desc: 'Remove all skills' },
{ cmd: 'check', desc: 'Quality scores & activity' },
],
},
{
name: 'Sources',
commands: [
{ cmd: 'tap add owner/repo', desc: 'Add custom source' },
{ cmd: 'tap list', desc: 'List custom sources' },
{ cmd: 'tap remove owner/repo', desc: 'Remove custom source' },
], ],
}, },
{ {
@@ -67,7 +77,7 @@ const COMMAND_GROUPS: CommandGroup[] = [
{ cmd: 'manifest init', desc: 'Create .skills file' }, { cmd: 'manifest init', desc: 'Create .skills file' },
{ cmd: 'team init', desc: 'Initialize team' }, { cmd: 'team init', desc: 'Initialize team' },
{ cmd: 'team share', desc: 'Share via Git' }, { cmd: 'team share', desc: 'Share via Git' },
{ cmd: 'publish', desc: 'Submit to marketplace' }, { cmd: 'publish submit', desc: 'Submit via CLI' },
{ cmd: 'cicd init', desc: 'CI/CD templates' }, { cmd: 'cicd init', desc: 'CI/CD templates' },
{ cmd: 'team sync', desc: 'Sync team skills' }, { cmd: 'team sync', desc: 'Sync team skills' },
], ],
@@ -246,7 +246,7 @@ export function CompatibilityMatrix(): React.ReactElement {
<div> <div>
<h2 className="text-lg sm:text-xl font-bold text-white mb-1 font-mono">Compatibility Matrix</h2> <h2 className="text-lg sm:text-xl font-bold text-white mb-1 font-mono">Compatibility Matrix</h2>
<p className="text-zinc-500 font-mono text-[10px] sm:text-xs"> <p className="text-zinc-500 font-mono text-[10px] sm:text-xs">
Skill support across all 44 agents and {CATEGORIES.length} categories. Skill support across all 45 agents and {CATEGORIES.length} categories.
</p> </p>
</div> </div>
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
+6 -6
View File
@@ -42,13 +42,13 @@ const sections: DocSection[] = [
content: ( content: (
<div className="space-y-4"> <div className="space-y-4">
<p className="text-zinc-300"> <p className="text-zinc-300">
SkillKit is a universal command-line interface (CLI) and programmatic toolkit for managing AI agent skills across 44 AI coding platforms. It solves the fragmentation problem where each AI agent uses different skill formats and directory structures. SkillKit is a universal command-line interface (CLI) and programmatic toolkit for managing AI agent skills across 45 AI coding platforms. It solves the fragmentation problem where each AI agent uses different skill formats and directory structures.
</p> </p>
<h3 className="text-lg font-semibold text-white mt-6">Core Capabilities</h3> <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"> <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 44 agents</li> <li><span className="text-white">AI Instruction Generation (Primer)</span> - Analyze your codebase and generate customized instruction files for all 45 agents</li>
<li><span className="text-white">Skill Discovery</span> - Browse 400K+ skills from registries with AI-powered recommendations</li> <li><span className="text-white">Skill Discovery</span> - Browse 400K+ skills from registries with AI-powered recommendations</li>
<li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 44 agent-specific formats</li> <li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 45 agent-specific formats</li>
<li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li> <li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li>
</ul> </ul>
</div> </div>
@@ -101,7 +101,7 @@ skillkit install anthropics/skills`}</CodeBlock>
<ul className="list-disc list-inside space-y-2 text-zinc-400"> <ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">UI Tier</span> - CLI commands, Terminal UI (OpenTUI-based), and documentation website</li> <li><span className="text-white">UI Tier</span> - CLI commands, Terminal UI (OpenTUI-based), and documentation website</li>
<li><span className="text-white">Core Logic Tier</span> - @skillkit/core for business logic; @skillkit/agents for adapter implementations</li> <li><span className="text-white">Core Logic Tier</span> - @skillkit/core for business logic; @skillkit/agents for adapter implementations</li>
<li><span className="text-white">Integration Tier</span> - File systems, Git repositories, marketplace APIs, and 44 AI agents</li> <li><span className="text-white">Integration Tier</span> - File systems, Git repositories, marketplace APIs, and 45 AI agents</li>
</ul> </ul>
<h3 className="text-lg font-semibold text-white mt-6">Monorepo Structure</h3> <h3 className="text-lg font-semibold text-white mt-6">Monorepo Structure</h3>
@@ -129,7 +129,7 @@ skillkit install anthropics/skills`}</CodeBlock>
content: ( content: (
<div className="space-y-4"> <div className="space-y-4">
<p className="text-zinc-300"> <p className="text-zinc-300">
SkillKit supports 44 AI coding agents with automatic format translation: SkillKit supports 45 AI coding agents with automatic format translation:
</p> </p>
<Table <Table
@@ -206,7 +206,7 @@ skillkit cicd init # Setup CI/CD integration`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">AI Instruction Generation (Primer)</h3> <h3 className="text-lg font-semibold text-white mt-6">AI Instruction Generation (Primer)</h3>
<CodeBlock>{`skillkit primer # Analyze codebase, generate for detected agents <CodeBlock>{`skillkit primer # Analyze codebase, generate for detected agents
skillkit primer --all-agents # Generate for all 44 agents skillkit primer --all-agents # Generate for all 45 agents
skillkit primer --agent claude-code,cursor # Specific agents only skillkit primer --agent claude-code,cursor # Specific agents only
skillkit primer --analyze-only # Only show codebase analysis skillkit primer --analyze-only # Only show codebase analysis
skillkit primer --dry-run # Preview without writing files skillkit primer --dry-run # Preview without writing files
+5 -5
View File
@@ -18,7 +18,7 @@ const FEATURES: Feature[] = [
}, },
{ {
title: 'Auto Translation', title: 'Auto Translation',
description: 'The npm for agent skills. Write once, auto-translate to 44 formats.', description: 'The npm for agent skills. Write once, auto-translate to 45 formats.',
icon: ( icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor"> <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 7h12m0 0l-4-4m4 4l-4 4m0 6H4m0 0l4 4m-4-4l4-4" /> <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 7h12m0 0l-4-4m4 4l-4 4m0 6H4m0 0l4 4m-4-4l4-4" />
@@ -36,7 +36,7 @@ const FEATURES: Feature[] = [
}, },
{ {
title: 'Primer', title: 'Primer',
description: 'Auto-generate agent instructions for all 44 agents from your codebase.', description: 'Auto-generate agent instructions for all 45 agents from your codebase.',
icon: ( icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor"> <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M13 10V3L4 14h7v7l9-11h-7z" /> <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M13 10V3L4 14h7v7l9-11h-7z" />
@@ -109,9 +109,9 @@ const FEATURES: Feature[] = [
]; ];
const COMPARISONS = [ const COMPARISONS = [
['Agent Support', '1-17 agents', '44 agents'], ['Agent Support', '1-17 agents', '45 agents'],
['Sources', 'Single registry', '34+ aggregated'], ['Sources', 'Single registry', '34+ aggregated'],
['Translation', 'None or limited', 'All 44 formats'], ['Translation', 'None or limited', 'All 45 formats'],
['Memory', 'None', 'Persistent learning'], ['Memory', 'None', 'Persistent learning'],
['Security', 'None', '46-rule scanner'], ['Security', 'None', '46-rule scanner'],
['Team Sync', 'None', '.skills manifest'], ['Team Sync', 'None', '.skills manifest'],
@@ -131,7 +131,7 @@ export function Features(): React.ReactElement {
</p> </p>
<div className="flex gap-6 sm:gap-8"> <div className="flex gap-6 sm:gap-8">
<div> <div>
<div className="text-2xl sm:text-3xl font-bold text-white font-mono">44</div> <div className="text-2xl sm:text-3xl font-bold text-white font-mono">45</div>
<div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Agents</div> <div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Agents</div>
</div> </div>
<div> <div>
+2 -2
View File
@@ -22,7 +22,7 @@ interface TerminalLine {
const TERMINAL_LINES: TerminalLine[] = [ const TERMINAL_LINES: TerminalLine[] = [
{ type: 'cmd', text: 'skillkit install anthropics/skills' }, { type: 'cmd', text: 'skillkit install anthropics/skills' },
{ type: 'out', text: '→ Fetched from github.com/anthropics/skills' }, { type: 'out', text: '→ Fetched from github.com/anthropics/skills' },
{ type: 'out', text: '→ Translated to 44 agent formats' }, { type: 'out', text: '→ Translated to 45 agent formats' },
{ type: 'out', text: '→ Scanned: 0 issues found' }, { type: 'out', text: '→ Scanned: 0 issues found' },
{ type: 'cmd', text: 'skillkit install skills.sh/vercel/agent-skills' }, { type: 'cmd', text: 'skillkit install skills.sh/vercel/agent-skills' },
{ type: 'out', text: '→ Installed 12 skills from skills.sh' }, { type: 'out', text: '→ Installed 12 skills from skills.sh' },
@@ -149,7 +149,7 @@ export function Hero({ version, stars }: HeroProps): React.ReactElement {
<p className="text-sm text-zinc-400 mb-5 max-w-lg font-mono leading-relaxed"> <p className="text-sm text-zinc-400 mb-5 max-w-lg font-mono leading-relaxed">
The open source package manager that aggregates 34+ skill sources, The open source package manager that aggregates 34+ skill sources,
scans 400K+ skills from registries, auto-translates to 44 agent formats, scans 400K+ skills from registries, auto-translates to 45 agent formats,
and adds memory, security scanning, and team workflows. Everything runs locally. and adds memory, security scanning, and team workflows. Everything runs locally.
</p> </p>
+1 -1
View File
@@ -13,7 +13,7 @@ const USE_CASES: UseCase[] = [
{ {
persona: 'Multi-Agent Developer', persona: 'Multi-Agent Developer',
problem: 'You\'ve built skills for Claude Code. Now your team wants Cursor, and you want to try Windsurf.', problem: 'You\'ve built skills for Claude Code. Now your team wants Cursor, and you want to try Windsurf.',
solution: 'SkillKit translates skills between all 44 agents. Write once, deploy everywhere.', solution: 'SkillKit translates skills between all 45 agents. Write once, deploy everywhere.',
command: 'skillkit translate --to cursor,windsurf', command: 'skillkit translate --to cursor,windsurf',
gradient: 'from-violet-500/10 to-purple-500/10', gradient: 'from-violet-500/10 to-purple-500/10',
icon: ( icon: (
+1 -1
View File
@@ -18,7 +18,7 @@ const COMPETITORS: Competitor[] = [
{ name: 'Askill', type: 'Installer', agents: '~40', translate: false, memory: false, security: true, team: false, tui: false, api: false }, { name: 'Askill', type: 'Installer', agents: '~40', translate: false, memory: false, security: true, team: false, tui: false, api: false },
{ name: 'Skild', type: 'Installer', agents: '~7', translate: false, memory: false, security: false, team: false, tui: false, api: false }, { name: 'Skild', type: 'Installer', agents: '~7', translate: false, memory: false, security: false, team: false, tui: false, api: false },
{ name: 'Paks', type: 'Installer', agents: '~6', translate: false, memory: false, security: false, team: false, tui: false, api: false }, { name: 'Paks', type: 'Installer', agents: '~6', translate: false, memory: false, security: false, team: false, tui: false, api: false },
{ name: 'SkillKit', type: 'Platform', agents: '44', translate: true, memory: true, security: true, team: true, tui: true, api: true }, { name: 'SkillKit', type: 'Platform', agents: '45', translate: true, memory: true, security: true, team: true, tui: true, api: true },
]; ];
const SOURCES = [ const SOURCES = [
+3 -3
View File
@@ -4,13 +4,13 @@
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>SkillKit - Universal Skills for AI Coding Agents</title> <title>SkillKit - Universal Skills for AI Coding Agents</title>
<meta name="description" content="Write once, deploy to 44 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more."> <meta name="description" content="Write once, deploy to 45 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more.">
<!-- Open Graph --> <!-- Open Graph -->
<meta property="og:type" content="website"> <meta property="og:type" content="website">
<meta property="og:url" content="https://skillkit.sh/"> <meta property="og:url" content="https://skillkit.sh/">
<meta property="og:title" content="SkillKit - Universal Skills for AI Coding Agents"> <meta property="og:title" content="SkillKit - Universal Skills for AI Coding Agents">
<meta property="og:description" content="Write once, deploy to 44 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more."> <meta property="og:description" content="Write once, deploy to 45 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more.">
<meta property="og:image" content="https://skillkit.sh/og-image.png"> <meta property="og:image" content="https://skillkit.sh/og-image.png">
<meta property="og:image:width" content="1200"> <meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630"> <meta property="og:image:height" content="630">
@@ -20,7 +20,7 @@
<meta name="twitter:card" content="summary_large_image"> <meta name="twitter:card" content="summary_large_image">
<meta name="twitter:url" content="https://skillkit.sh/"> <meta name="twitter:url" content="https://skillkit.sh/">
<meta name="twitter:title" content="SkillKit - Universal Skills for AI Coding Agents"> <meta name="twitter:title" content="SkillKit - Universal Skills for AI Coding Agents">
<meta name="twitter:description" content="Write once, deploy to 44 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more."> <meta name="twitter:description" content="Write once, deploy to 45 AI coding agents. Skills for Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and more.">
<meta name="twitter:image" content="https://skillkit.sh/og-image.png"> <meta name="twitter:image" content="https://skillkit.sh/og-image.png">
<link rel="icon" type="image/svg+xml" href="/favicon.svg" /> <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+1 -1
View File
@@ -1,5 +1,5 @@
{ {
"name": "SkillKit", "name": "SkillKit",
"description": "Supercharge Every AI Coding Agent. Translate, manage, and sync skills across Claude, Cursor, Windsurf, and 44 agents.", "description": "Supercharge Every AI Coding Agent. Translate, manage, and sync skills across Claude, Cursor, Windsurf, and 45 agents.",
"requestFramePermissions": [] "requestFramePermissions": []
} }
+1 -1
View File
@@ -1,7 +1,7 @@
{ {
"name": "skillkit", "name": "skillkit",
"private": true, "private": true,
"version": "1.19.2", "version": "1.21.0",
"type": "module", "type": "module",
"scripts": { "scripts": {
"dev": "vite", "dev": "vite",
+1 -1
View File
@@ -3,7 +3,7 @@
"info": { "info": {
"title": "SkillKit", "title": "SkillKit",
"version": "1.12.0", "version": "1.12.0",
"description": "Skills shouldn't require pre-installation. This API lets any agent, framework, or tool discover and retrieve skills on demand.\n\n400K+ skills across 44 AI coding agents. Results ranked by a multi-signal scoring system (content 40pts, query match 30pts, popularity 15pts, references 15pts).\n\n## Quick Start\n\n```bash\nnpx skillkit serve\n```\n\nThe API is now running at http://localhost:3737\n\n## MCP Server\n\nFor agent-native discovery (Claude Desktop, Cursor):\n\n```json\n{\n \"mcpServers\": {\n \"skillkit\": { \"command\": \"npx\", \"args\": [\"@skillkit/mcp\"] }\n }\n}\n```\n\n## Python Client\n\n```bash\npip install skillkit-client\n```", "description": "Skills shouldn't require pre-installation. This API lets any agent, framework, or tool discover and retrieve skills on demand.\n\n400K+ skills across 45 AI coding agents. Results ranked by a multi-signal scoring system (content 40pts, query match 30pts, popularity 15pts, references 15pts).\n\n## Quick Start\n\n```bash\nnpx skillkit serve\n```\n\nThe API is now running at http://localhost:3737\n\n## MCP Server\n\nFor agent-native discovery (Claude Desktop, Cursor):\n\n```json\n{\n \"mcpServers\": {\n \"skillkit\": { \"command\": \"npx\", \"args\": [\"@skillkit/mcp\"] }\n }\n}\n```\n\n## Python Client\n\n```bash\npip install skillkit-client\n```",
"license": { "license": {
"name": "Apache-2.0", "name": "Apache-2.0",
"url": "https://opensource.org/licenses/Apache-2.0" "url": "https://opensource.org/licenses/Apache-2.0"
Binary file not shown.
+1 -1
View File
@@ -44,7 +44,7 @@ describe('E2E: Onboarding UI', () => {
expect(result.success).toBe(true); expect(result.success).toBe(true);
}); });
it('should display all 44 agents', async () => { it('should display all 45 agents', async () => {
const result = await runCli(['init', '--list']); const result = await runCli(['init', '--list']);
const output = result.stdout + result.stderr; const output = result.stdout + result.stderr;
+1 -1
View File
@@ -28,7 +28,7 @@ import {
type CrossAgentSkill, type CrossAgentSkill,
} from '@skillkit/core'; } from '@skillkit/core';
// All 44 supported agents // All 45 supported agents
const SUPPORTED_AGENTS = [ const SUPPORTED_AGENTS = [
'claude-code', 'claude-code',
'cursor', 'cursor',
+2 -2
View File
@@ -2,7 +2,7 @@
* E2E Tests: Skill Translation Commands * E2E Tests: Skill Translation Commands
* *
* Tests for: translate, context, recommend * Tests for: translate, context, recommend
* Validates translation to all 44 supported agents * Validates translation to all 45 supported agents
*/ */
import { describe, it, expect, beforeEach, afterEach } from 'vitest'; import { describe, it, expect, beforeEach, afterEach } from 'vitest';
@@ -16,7 +16,7 @@ import {
testFileExists, testFileExists,
} from './helpers/cli-runner.js'; } from './helpers/cli-runner.js';
// All 44 supported agents // All 45 supported agents
const SUPPORTED_AGENTS = [ const SUPPORTED_AGENTS = [
'claude-code', 'claude-code',
'cursor', 'cursor',
+2 -1
View File
@@ -1,7 +1,7 @@
{ {
"$schema": "./sources-schema.json", "$schema": "./sources-schema.json",
"version": 1, "version": 1,
"updatedAt": "2026-02-28", "updatedAt": "2026-04-10",
"description": "Curated skill repository sources - THE SINGLE SOURCE OF TRUTH", "description": "Curated skill repository sources - THE SINGLE SOURCE OF TRUTH",
"sources": [ "sources": [
{ "source": "anthropics/skills", "name": "Anthropic Official", "official": true }, { "source": "anthropics/skills", "name": "Anthropic Official", "official": true },
@@ -37,6 +37,7 @@
{ "source": "intellectronica/agent-skills", "name": "Context7" }, { "source": "intellectronica/agent-skills", "name": "Context7" },
{ "source": "muratcankoylan/Agent-Skills-for-Context-Engineering", "name": "Context Engineering" }, { "source": "muratcankoylan/Agent-Skills-for-Context-Engineering", "name": "Context Engineering" },
{ "source": "sickn33/antigravity-awesome-skills", "name": "Antigravity Awesome Skills" }, { "source": "sickn33/antigravity-awesome-skills", "name": "Antigravity Awesome Skills" },
{ "source": "NousResearch/hermes-agent", "name": "Hermes Agent Skills" },
{ "source": "skills.sh", "name": "Skills.sh Leaderboard", "official": true, "registry": "skills-sh" } { "source": "skills.sh", "name": "Skills.sh Leaderboard", "official": true, "registry": "skills-sh" }
] ]
} }
+2 -2
View File
@@ -1,8 +1,8 @@
{ {
"name": "skillkit-monorepo", "name": "skillkit-monorepo",
"version": "1.19.2", "version": "1.21.0",
"private": true, "private": true,
"description": "The package manager for AI agent skills — install, translate, share across 44 coding agents", "description": "The package manager for AI agent skills — install, translate, share across 45 coding agents",
"type": "module", "type": "module",
"scripts": { "scripts": {
"build": "turbo run build", "build": "turbo run build",
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "@skillkit/agents", "name": "@skillkit/agents",
"version": "1.19.2", "version": "1.21.0",
"description": "Agent adapters for SkillKit - supports 32 AI coding agents", "description": "Agent adapters for SkillKit - supports 32 AI coding agents",
"type": "module", "type": "module",
"main": "./dist/index.js", "main": "./dist/index.js",
@@ -35,10 +35,10 @@ const ALL_AGENTS = AgentType.options;
describe('Agent Adapters', () => { describe('Agent Adapters', () => {
describe('getAllAdapters', () => { describe('getAllAdapters', () => {
it('should return all 44 registered adapters', () => { it('should return all 45 registered adapters', () => {
const adapters = getAllAdapters(); const adapters = getAllAdapters();
expect(adapters).toBeInstanceOf(Array); expect(adapters).toBeInstanceOf(Array);
expect(adapters.length).toBe(44); expect(adapters.length).toBe(45);
}); });
it('should include common agents', () => { it('should include common agents', () => {
@@ -236,16 +236,6 @@ describe('ClawdbotAdapter', () => {
}); });
describe('isDetected', () => { describe('isDetected', () => {
it('should detect Clawdbot from workspace skills directory', async () => {
mockExistsSync.mockImplementation((path) => {
return path === join(process.cwd(), 'skills');
});
const detected = await adapter.isDetected();
expect(detected).toBe(true);
});
it('should detect Clawdbot from global directory', async () => { it('should detect Clawdbot from global directory', async () => {
mockExistsSync.mockImplementation((path) => { mockExistsSync.mockImplementation((path) => {
return path === join(homedir(), '.clawdbot'); return path === join(homedir(), '.clawdbot');
@@ -287,7 +277,6 @@ describe('ClawdbotAdapter', () => {
await adapter.isDetected(); await adapter.isDetected();
expect(mockExistsSync).toHaveBeenCalledWith(join(process.cwd(), 'skills'));
expect(mockExistsSync).toHaveBeenCalledWith(join(homedir(), '.clawdbot')); expect(mockExistsSync).toHaveBeenCalledWith(join(homedir(), '.clawdbot'));
expect(mockExistsSync).toHaveBeenCalledWith(join(process.cwd(), 'clawdbot.json')); expect(mockExistsSync).toHaveBeenCalledWith(join(process.cwd(), 'clawdbot.json'));
}); });
+4 -5
View File
@@ -10,9 +10,9 @@ const config = AGENT_CONFIG.clawdbot;
export class ClawdbotAdapter implements AgentAdapter { export class ClawdbotAdapter implements AgentAdapter {
readonly type: AgentType = 'clawdbot'; readonly type: AgentType = 'clawdbot';
readonly name = 'Clawdbot'; readonly name: string = 'Clawdbot';
readonly skillsDir = config.skillsDir; readonly skillsDir: string = config.skillsDir;
readonly configFile = config.configFile; readonly configFile: string = config.configFile;
generateConfig(skills: Skill[]): string { generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled); const enabledSkills = skills.filter(s => s.enabled);
@@ -69,10 +69,9 @@ ${skillsXml}
} }
async isDetected(): Promise<boolean> { async isDetected(): Promise<boolean> {
const projectSkills = join(process.cwd(), 'skills');
const globalClawdbot = join(homedir(), '.clawdbot'); const globalClawdbot = join(homedir(), '.clawdbot');
const clawdbotConfig = join(process.cwd(), 'clawdbot.json'); const clawdbotConfig = join(process.cwd(), 'clawdbot.json');
return existsSync(projectSkills) || existsSync(globalClawdbot) || existsSync(clawdbotConfig); return existsSync(globalClawdbot) || existsSync(clawdbotConfig);
} }
} }
+8
View File
@@ -8,6 +8,7 @@ import { OpenCodeAdapter } from './opencode.js';
import { AntigravityAdapter } from './antigravity.js'; import { AntigravityAdapter } from './antigravity.js';
import { AmpAdapter } from './amp.js'; import { AmpAdapter } from './amp.js';
import { ClawdbotAdapter } from './clawdbot.js'; import { ClawdbotAdapter } from './clawdbot.js';
import { OpenClawAdapter } from './openclaw.js';
import { DroidAdapter } from './droid.js'; import { DroidAdapter } from './droid.js';
import { FactoryAdapter } from './factory.js'; import { FactoryAdapter } from './factory.js';
import { GitHubCopilotAdapter } from './github-copilot.js'; import { GitHubCopilotAdapter } from './github-copilot.js';
@@ -29,6 +30,7 @@ export * from './opencode.js';
export * from './antigravity.js'; export * from './antigravity.js';
export * from './amp.js'; export * from './amp.js';
export * from './clawdbot.js'; export * from './clawdbot.js';
export * from './openclaw.js';
export * from './droid.js'; export * from './droid.js';
export * from './factory.js'; export * from './factory.js';
export * from './github-copilot.js'; export * from './github-copilot.js';
@@ -53,6 +55,7 @@ const adapters: Record<AgentType, AgentAdapter> = {
antigravity: new AntigravityAdapter(), antigravity: new AntigravityAdapter(),
amp: new AmpAdapter(), amp: new AmpAdapter(),
clawdbot: new ClawdbotAdapter(), clawdbot: new ClawdbotAdapter(),
openclaw: new OpenClawAdapter(),
droid: new DroidAdapter(), droid: new DroidAdapter(),
'github-copilot': new GitHubCopilotAdapter(), 'github-copilot': new GitHubCopilotAdapter(),
goose: new GooseAdapter(), goose: new GooseAdapter(),
@@ -107,6 +110,10 @@ export function getAllAdapters(): AgentAdapterWithType[] {
})); }));
} }
export function getAdapterCount(): number {
return Object.keys(adapters).length;
}
export async function detectAgent(): Promise<AgentType> { export async function detectAgent(): Promise<AgentType> {
const checkOrder: AgentType[] = [ const checkOrder: AgentType[] = [
'claude-code', 'claude-code',
@@ -116,6 +123,7 @@ export async function detectAgent(): Promise<AgentType> {
'opencode', 'opencode',
'antigravity', 'antigravity',
'amp', 'amp',
'openclaw',
'clawdbot', 'clawdbot',
'droid', 'droid',
'github-copilot', 'github-copilot',
+22
View File
@@ -0,0 +1,22 @@
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import { ClawdbotAdapter } from './clawdbot.js';
import type { AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.openclaw;
export class OpenClawAdapter extends ClawdbotAdapter {
override readonly type: AgentType = 'openclaw';
override readonly name = 'OpenClaw';
override readonly skillsDir = config.skillsDir;
override readonly configFile = config.configFile;
override async isDetected(): Promise<boolean> {
const globalOpenClaw = join(homedir(), '.openclaw');
const openclawConfig = join(process.cwd(), 'openclaw.json');
return existsSync(globalOpenClaw) || existsSync(openclawConfig);
}
}
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "@skillkit/api", "name": "@skillkit/api",
"version": "1.19.2", "version": "1.21.0",
"description": "REST API server for SkillKit skill discovery", "description": "REST API server for SkillKit skill discovery",
"type": "module", "type": "module",
"main": "./dist/index.js", "main": "./dist/index.js",
+1 -1
View File
@@ -5,7 +5,7 @@ const OPENAPI_SPEC = {
info: { info: {
title: 'SkillKit', title: 'SkillKit',
version: '1.12.0', version: '1.12.0',
description: 'Skill Discovery API for AI coding agents. Search, browse, and retrieve skills from the SkillKit marketplace (400K+ skills across 44 agents).', description: 'Skill Discovery API for AI coding agents. Search, browse, and retrieve skills from the SkillKit marketplace (400K+ skills across 45 agents).',
license: { name: 'Apache-2.0', url: 'https://opensource.org/licenses/Apache-2.0' }, license: { name: 'Apache-2.0', url: 'https://opensource.org/licenses/Apache-2.0' },
contact: { name: 'SkillKit', url: 'https://github.com/rohitg00/skillkit' }, contact: { name: 'SkillKit', url: 'https://github.com/rohitg00/skillkit' },
}, },
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "@skillkit/cli", "name": "@skillkit/cli",
"version": "1.19.2", "version": "1.21.0",
"description": "CLI commands for SkillKit", "description": "CLI commands for SkillKit",
"type": "module", "type": "module",
"main": "./dist/index.js", "main": "./dist/index.js",
@@ -96,10 +96,10 @@ describe('Onboarding Module', () => {
it('should generate full logo with version', async () => { it('should generate full logo with version', async () => {
const { getFullLogo } = await import('../onboarding/logo.js'); const { getFullLogo } = await import('../onboarding/logo.js');
const logo = getFullLogo('1.7.2', 44); const logo = getFullLogo('1.7.2', 45);
expect(logo).toContain('\u2588'); expect(logo).toContain('\u2588');
expect(logo).toContain('v1.7.2'); expect(logo).toContain('v1.7.2');
expect(logo).toContain('44 agents'); expect(logo).toContain('45 agents');
}); });
it('should generate compact logo', async () => { it('should generate compact logo', async () => {
+7 -7
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, warn } from '../onboarding/index.js';
import { ActivityLog } from '@skillkit/core'; import { ActivityLog } from '@skillkit/core';
export class ActivityCommand extends Command { export class ActivityCommand extends Command {
@@ -42,16 +42,16 @@ export class ActivityCommand extends Command {
} }
if (activities.length === 0) { if (activities.length === 0) {
console.log(chalk.yellow('No activity recorded')); warn('No activity recorded');
console.log( console.log(
chalk.dim( colors.muted(
'Activity is recorded when skills are active during git commits.' 'Activity is recorded when skills are active during git commits.'
) )
); );
return 0; return 0;
} }
console.log(chalk.cyan(' Recent Skill Activity\n')); console.log(colors.cyan(' Recent Skill Activity\n'));
const displayed = activities.slice(0, limit); const displayed = activities.slice(0, limit);
@@ -61,10 +61,10 @@ export class ActivityCommand extends Command {
const files = activity.filesChanged.join(', '); const files = activity.filesChanged.join(', ');
const ago = formatTimeAgo(activity.committedAt); const ago = formatTimeAgo(activity.committedAt);
console.log(` ${chalk.bold(shortSha)} ${activity.message}`); console.log(` ${colors.bold(shortSha)} ${activity.message}`);
console.log(` Skills: ${chalk.green(skills)}`); console.log(` Skills: ${colors.success(skills)}`);
console.log( console.log(
` Files: ${files} ${chalk.dim(`(${ago})`)}` ` Files: ${files} ${colors.muted(`(${ago})`)}`
); );
console.log(); console.log();
} }
+110 -110
View File
@@ -4,7 +4,7 @@
* Manage custom AI sub-agents (e.g., .claude/agents/*.md) * Manage custom AI sub-agents (e.g., .claude/agents/*.md)
*/ */
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { existsSync, mkdirSync, writeFileSync } from 'node:fs'; import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
import { join, basename } from 'node:path'; import { join, basename } from 'node:path';
@@ -67,7 +67,7 @@ export class AgentCommand extends Command {
}); });
async execute(): Promise<number> { async execute(): Promise<number> {
console.log(chalk.cyan('Agent management commands:\n')); console.log(colors.cyan('Agent management commands:\n'));
console.log(' agent list List all installed agents'); console.log(' agent list List all installed agents');
console.log(' agent show <name> Show agent details'); console.log(' agent show <name> Show agent details');
console.log(' agent create <name> Create a new agent'); console.log(' agent create <name> Create a new agent');
@@ -76,7 +76,7 @@ export class AgentCommand extends Command {
console.log(' agent sync Sync agents to target AI agent'); console.log(' agent sync Sync agents to target AI agent');
console.log(' agent validate [path] Validate agent definitions'); console.log(' agent validate [path] Validate agent definitions');
console.log(); console.log();
console.log(chalk.dim('Run `skillkit agent <subcommand> --help` for more info')); console.log(colors.muted('Run `skillkit agent <subcommand> --help` for more info'));
return 0; return 0;
} }
} }
@@ -136,18 +136,18 @@ export class AgentListCommand extends Command {
} }
if (agents.length === 0) { if (agents.length === 0) {
console.log(chalk.yellow('No agents found')); console.log(colors.warning('No agents found'));
console.log(chalk.dim('Create an agent with: skillkit agent create <name>')); console.log(colors.muted('Create an agent with: skillkit agent create <name>'));
return 0; return 0;
} }
console.log(chalk.cyan(`Installed agents (${agents.length}):\n`)); console.log(colors.cyan(`Installed agents (${agents.length}):\n`));
const projectAgents = agents.filter((a: CustomAgent) => a.location === 'project'); const projectAgents = agents.filter((a: CustomAgent) => a.location === 'project');
const globalAgents = agents.filter((a: CustomAgent) => a.location === 'global'); const globalAgents = agents.filter((a: CustomAgent) => a.location === 'global');
if (projectAgents.length > 0) { if (projectAgents.length > 0) {
console.log(chalk.blue('Project agents:')); console.log(colors.info('Project agents:'));
for (const agent of projectAgents) { for (const agent of projectAgents) {
printAgent(agent); printAgent(agent);
} }
@@ -155,7 +155,7 @@ export class AgentListCommand extends Command {
} }
if (globalAgents.length > 0) { if (globalAgents.length > 0) {
console.log(chalk.dim('Global agents:')); console.log(colors.muted('Global agents:'));
for (const agent of globalAgents) { for (const agent of globalAgents) {
printAgent(agent); printAgent(agent);
} }
@@ -163,7 +163,7 @@ export class AgentListCommand extends Command {
} }
console.log( console.log(
chalk.dim(`${projectAgents.length} project, ${globalAgents.length} global`) colors.muted(`${projectAgents.length} project, ${globalAgents.length} global`)
); );
return 0; return 0;
@@ -187,47 +187,47 @@ export class AgentShowCommand extends Command {
const agent = findAgent(this.name, searchDirs); const agent = findAgent(this.name, searchDirs);
if (!agent) { if (!agent) {
console.log(chalk.red(`Agent not found: ${this.name}`)); console.log(colors.error(`Agent not found: ${this.name}`));
return 1; return 1;
} }
console.log(chalk.cyan(`Agent: ${agent.name}\n`)); console.log(colors.cyan(`Agent: ${agent.name}\n`));
console.log(`${chalk.dim('Description:')} ${agent.description}`); console.log(`${colors.muted('Description:')} ${agent.description}`);
console.log(`${chalk.dim('Location:')} ${agent.location} (${agent.path})`); console.log(`${colors.muted('Location:')} ${agent.location} (${agent.path})`);
console.log(`${chalk.dim('Enabled:')} ${agent.enabled ? chalk.green('yes') : chalk.red('no')}`); console.log(`${colors.muted('Enabled:')} ${agent.enabled ? colors.success('yes') : colors.error('no')}`);
const fm = agent.frontmatter; const fm = agent.frontmatter;
if (fm.model) { if (fm.model) {
console.log(`${chalk.dim('Model:')} ${fm.model}`); console.log(`${colors.muted('Model:')} ${fm.model}`);
} }
if (fm.permissionMode) { if (fm.permissionMode) {
console.log(`${chalk.dim('Permission Mode:')} ${fm.permissionMode}`); console.log(`${colors.muted('Permission Mode:')} ${fm.permissionMode}`);
} }
if (fm.context) { if (fm.context) {
console.log(`${chalk.dim('Context:')} ${fm.context}`); console.log(`${colors.muted('Context:')} ${fm.context}`);
} }
if (fm.disallowedTools && fm.disallowedTools.length > 0) { if (fm.disallowedTools && fm.disallowedTools.length > 0) {
console.log(`${chalk.dim('Disallowed Tools:')} ${fm.disallowedTools.join(', ')}`); console.log(`${colors.muted('Disallowed Tools:')} ${fm.disallowedTools.join(', ')}`);
} }
if (fm.skills && fm.skills.length > 0) { if (fm.skills && fm.skills.length > 0) {
console.log(`${chalk.dim('Skills:')} ${fm.skills.join(', ')}`); console.log(`${colors.muted('Skills:')} ${fm.skills.join(', ')}`);
} }
if (fm.hooks && fm.hooks.length > 0) { if (fm.hooks && fm.hooks.length > 0) {
console.log(`${chalk.dim('Hooks:')} ${fm.hooks.length} defined`); console.log(`${colors.muted('Hooks:')} ${fm.hooks.length} defined`);
} }
if (fm.tags && fm.tags.length > 0) { if (fm.tags && fm.tags.length > 0) {
console.log(`${chalk.dim('Tags:')} ${fm.tags.join(', ')}`); console.log(`${colors.muted('Tags:')} ${fm.tags.join(', ')}`);
} }
if (fm.author) { if (fm.author) {
console.log(`${chalk.dim('Author:')} ${fm.author}`); console.log(`${colors.muted('Author:')} ${fm.author}`);
} }
if (fm.version) { if (fm.version) {
console.log(`${chalk.dim('Version:')} ${fm.version}`); console.log(`${colors.muted('Version:')} ${fm.version}`);
} }
console.log(); console.log();
console.log(chalk.dim('Content preview:')); console.log(colors.muted('Content preview:'));
console.log(chalk.dim('─'.repeat(40))); console.log(colors.muted('─'.repeat(40)));
const preview = agent.content.slice(0, 500); const preview = agent.content.slice(0, 500);
console.log(preview + (agent.content.length > 500 ? '\n...' : '')); console.log(preview + (agent.content.length > 500 ? '\n...' : ''));
@@ -264,8 +264,8 @@ export class AgentCreateCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
const namePattern = /^[a-z0-9]+(-[a-z0-9]+)*$/; const namePattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
if (!namePattern.test(this.name)) { if (!namePattern.test(this.name)) {
console.log(chalk.red('Invalid agent name: must be lowercase alphanumeric with hyphens')); console.log(colors.error('Invalid agent name: must be lowercase alphanumeric with hyphens'));
console.log(chalk.dim('Examples: my-agent, code-reviewer, security-expert')); console.log(colors.muted('Examples: my-agent, code-reviewer, security-expert'));
return 1; return 1;
} }
@@ -282,7 +282,7 @@ export class AgentCreateCommand extends Command {
const agentPath = join(targetDir, `${this.name}.md`); const agentPath = join(targetDir, `${this.name}.md`);
if (existsSync(agentPath)) { if (existsSync(agentPath)) {
console.log(chalk.red(`Agent already exists: ${agentPath}`)); console.log(colors.error(`Agent already exists: ${agentPath}`));
return 1; return 1;
} }
@@ -291,10 +291,10 @@ export class AgentCreateCommand extends Command {
writeFileSync(agentPath, content); writeFileSync(agentPath, content);
console.log(chalk.green(`Created agent: ${agentPath}`)); console.log(colors.success(`Created agent: ${agentPath}`));
console.log(); console.log();
console.log(chalk.dim('Edit the file to customize the agent system prompt.')); console.log(colors.muted('Edit the file to customize the agent system prompt.'));
console.log(chalk.dim(`Invoke with: @${this.name}`)); console.log(colors.muted(`Invoke with: @${this.name}`));
return 0; return 0;
} }
@@ -360,23 +360,23 @@ export class AgentTranslateCommand extends Command {
: join(process.cwd(), this.source); : join(process.cwd(), this.source);
if (!existsSync(sourcePath)) { if (!existsSync(sourcePath)) {
console.log(chalk.red(`Source path not found: ${sourcePath}`)); console.log(colors.error(`Source path not found: ${sourcePath}`));
return 1; return 1;
} }
agents = discoverAgentsFromPath(sourcePath, this.recursive); agents = discoverAgentsFromPath(sourcePath, this.recursive);
if (agents.length === 0) { if (agents.length === 0) {
console.log(chalk.yellow(`No agents found in: ${sourcePath}`)); console.log(colors.warning(`No agents found in: ${sourcePath}`));
if (!this.recursive) { if (!this.recursive) {
console.log(chalk.dim('Tip: Use --recursive to scan subdirectories')); console.log(colors.muted('Tip: Use --recursive to scan subdirectories'));
} }
return 0; return 0;
} }
} else if (this.name) { } else if (this.name) {
const agent = findAgent(this.name, searchDirs); const agent = findAgent(this.name, searchDirs);
if (!agent) { if (!agent) {
console.log(chalk.red(`Agent not found: ${this.name}`)); console.log(colors.error(`Agent not found: ${this.name}`));
return 1; return 1;
} }
agents = [agent]; agents = [agent];
@@ -387,13 +387,13 @@ export class AgentTranslateCommand extends Command {
} }
if (agents.length === 0) { if (agents.length === 0) {
console.log(chalk.yellow('No agents found to translate')); console.log(colors.warning('No agents found to translate'));
return 0; return 0;
} }
const outputDir = this.output || getAgentTargetDirectory(process.cwd(), targetAgent); const outputDir = this.output || getAgentTargetDirectory(process.cwd(), targetAgent);
console.log(chalk.cyan(`Translating ${agents.length} agent(s) to ${targetAgent} format...\n`)); console.log(colors.cyan(`Translating ${agents.length} agent(s) to ${targetAgent} format...\n`));
let successCount = 0; let successCount = 0;
let errorCount = 0; let errorCount = 0;
@@ -403,7 +403,7 @@ export class AgentTranslateCommand extends Command {
const result = translateAgent(agent, targetAgent, { addMetadata: true }); const result = translateAgent(agent, targetAgent, { addMetadata: true });
if (!result.success) { if (!result.success) {
console.log(chalk.red(`✗ ${agent.name}: Translation failed`)); console.log(colors.error(`✗ ${agent.name}: Translation failed`));
errorCount++; errorCount++;
continue; continue;
} }
@@ -411,15 +411,15 @@ export class AgentTranslateCommand extends Command {
const outputPath = join(outputDir, result.filename); const outputPath = join(outputDir, result.filename);
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.blue(`Would write: ${outputPath}`)); console.log(colors.info(`Would write: ${outputPath}`));
if (result.warnings.length > 0) { if (result.warnings.length > 0) {
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`)); console.log(colors.warning(` ⚠ ${warning}`));
} }
} }
if (result.incompatible.length > 0) { if (result.incompatible.length > 0) {
for (const incompat of result.incompatible) { for (const incompat of result.incompatible) {
console.log(chalk.dim(` ○ ${incompat}`)); console.log(colors.muted(` ○ ${incompat}`));
} }
} }
} else { } else {
@@ -427,21 +427,21 @@ export class AgentTranslateCommand extends Command {
mkdirSync(outputDir, { recursive: true }); mkdirSync(outputDir, { recursive: true });
} }
writeFileSync(outputPath, result.content); writeFileSync(outputPath, result.content);
console.log(chalk.green(`✓ ${agent.name} → ${outputPath}`)); console.log(colors.success(`✓ ${agent.name} → ${outputPath}`));
} }
successCount++; successCount++;
} catch (error) { } catch (error) {
console.log(chalk.red(`✗ ${agent.name}: ${error instanceof Error ? error.message : 'Unknown error'}`)); console.log(colors.error(`✗ ${agent.name}: ${error instanceof Error ? error.message : 'Unknown error'}`));
errorCount++; errorCount++;
} }
} }
console.log(); console.log();
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.dim(`Would translate ${successCount} agent(s)`)); console.log(colors.muted(`Would translate ${successCount} agent(s)`));
} else { } else {
console.log(chalk.dim(`Translated ${successCount} agent(s)${errorCount > 0 ? `, ${errorCount} failed` : ''}`)); console.log(colors.muted(`Translated ${successCount} agent(s)${errorCount > 0 ? `, ${errorCount} failed` : ''}`));
} }
return errorCount > 0 ? 1 : 0; return errorCount > 0 ? 1 : 0;
@@ -468,7 +468,7 @@ export class AgentSyncCommand extends Command {
const agents = findAllAgents(searchDirs); const agents = findAllAgents(searchDirs);
if (agents.length === 0) { if (agents.length === 0) {
console.log(chalk.yellow('No agents found to sync')); console.log(colors.warning('No agents found to sync'));
return 0; return 0;
} }
@@ -476,12 +476,12 @@ export class AgentSyncCommand extends Command {
? this.agent.split(',').map(a => a.trim() as AgentType) ? this.agent.split(',').map(a => a.trim() as AgentType)
: ['claude-code' as AgentType]; : ['claude-code' as AgentType];
console.log(chalk.cyan(`Syncing ${agents.length} agent(s)...\n`)); console.log(colors.cyan(`Syncing ${agents.length} agent(s)...\n`));
for (const targetAgent of targetAgents) { for (const targetAgent of targetAgents) {
const outputDir = getAgentTargetDirectory(process.cwd(), targetAgent); const outputDir = getAgentTargetDirectory(process.cwd(), targetAgent);
console.log(chalk.blue(`→ ${targetAgent} (${outputDir})`)); console.log(colors.info(`→ ${targetAgent} (${outputDir})`));
if (!existsSync(outputDir)) { if (!existsSync(outputDir)) {
mkdirSync(outputDir, { recursive: true }); mkdirSync(outputDir, { recursive: true });
@@ -492,15 +492,15 @@ export class AgentSyncCommand extends Command {
if (result.success) { if (result.success) {
const outputPath = join(outputDir, result.filename); const outputPath = join(outputDir, result.filename);
writeFileSync(outputPath, result.content); writeFileSync(outputPath, result.content);
console.log(chalk.green(` ✓ ${agent.name}`)); console.log(colors.success(` ✓ ${agent.name}`));
} else { } else {
console.log(chalk.red(` ✗ ${agent.name}`)); console.log(colors.error(` ✗ ${agent.name}`));
} }
} }
} }
console.log(); console.log();
console.log(chalk.dim('Sync complete')); console.log(colors.muted('Sync complete'));
return 0; return 0;
} }
@@ -535,11 +535,11 @@ export class AgentValidateCommand extends Command {
const agents = findAllAgents(searchDirs); const agents = findAllAgents(searchDirs);
if (agents.length === 0) { if (agents.length === 0) {
console.log(chalk.yellow('No agents found')); console.log(colors.warning('No agents found'));
return 0; return 0;
} }
console.log(chalk.cyan(`Validating ${agents.length} agent(s)...\n`)); console.log(colors.cyan(`Validating ${agents.length} agent(s)...\n`));
for (const agent of agents) { for (const agent of agents) {
const result = validateAgent(agent.path); const result = validateAgent(agent.path);
@@ -547,7 +547,7 @@ export class AgentValidateCommand extends Command {
if (!result.valid) hasErrors = true; if (!result.valid) hasErrors = true;
} }
} else { } else {
console.log(chalk.yellow('Specify a path or use --all to validate all agents')); console.log(colors.warning('Specify a path or use --all to validate all agents'));
return 1; return 1;
} }
@@ -556,10 +556,10 @@ export class AgentValidateCommand extends Command {
} }
function printAgent(agent: CustomAgent): void { function printAgent(agent: CustomAgent): void {
const status = agent.enabled ? chalk.green('✓') : chalk.red('○'); const status = agent.enabled ? colors.success('✓') : colors.error('○');
const name = agent.enabled ? agent.name : chalk.dim(agent.name); const name = agent.enabled ? agent.name : colors.muted(agent.name);
const model = agent.frontmatter.model ? chalk.blue(`[${agent.frontmatter.model}]`) : ''; const model = agent.frontmatter.model ? colors.info(`[${agent.frontmatter.model}]`) : '';
const desc = chalk.dim(truncate(agent.description, 40)); const desc = colors.muted(truncate(agent.description, 40));
console.log(` ${status} ${name} ${model}`); console.log(` ${status} ${name} ${model}`);
if (agent.description) { if (agent.description) {
@@ -572,17 +572,17 @@ function printValidationResult(
result: { valid: boolean; errors: string[]; warnings: string[] } result: { valid: boolean; errors: string[]; warnings: string[] }
): void { ): void {
if (result.valid) { if (result.valid) {
console.log(chalk.green(`✓ ${name}`)); console.log(colors.success(`✓ ${name}`));
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`)); console.log(colors.warning(` ⚠ ${warning}`));
} }
} else { } else {
console.log(chalk.red(`✗ ${name}`)); console.log(colors.error(`✗ ${name}`));
for (const error of result.errors) { for (const err of result.errors) {
console.log(chalk.red(` • ${error}`)); console.log(colors.error(` • ${err}`));
} }
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`)); console.log(colors.warning(` ⚠ ${warning}`));
} }
} }
} }
@@ -671,15 +671,15 @@ export class AgentInstallCommand extends Command {
} }
if (!this.name) { if (!this.name) {
console.log(chalk.yellow('Please specify an agent name or use --all')); console.log(colors.warning('Please specify an agent name or use --all'));
console.log(chalk.dim('Run `skillkit agent available` to see available agents')); console.log(colors.muted('Run `skillkit agent available` to see available agents'));
return 1; return 1;
} }
const agent = getBundledAgent(this.name); const agent = getBundledAgent(this.name);
if (!agent) { if (!agent) {
console.log(chalk.red(`Bundled agent not found: ${this.name}`)); console.log(colors.error(`Bundled agent not found: ${this.name}`));
console.log(chalk.dim('Run `skillkit agent available` to see available agents')); console.log(colors.muted('Run `skillkit agent available` to see available agents'));
return 1; return 1;
} }
@@ -689,11 +689,11 @@ export class AgentInstallCommand extends Command {
}); });
if (result.success) { if (result.success) {
console.log(chalk.green(`✓ Installed: ${agent.name}`)); console.log(colors.success(`✓ Installed: ${agent.name}`));
console.log(chalk.dim(` Path: ${result.path}`)); console.log(colors.muted(` Path: ${result.path}`));
console.log(chalk.dim(` Invoke with: @${agent.id}`)); console.log(colors.muted(` Invoke with: @${agent.id}`));
} else { } else {
console.log(chalk.red(`✗ Failed: ${result.message}`)); console.log(colors.error(`✗ Failed: ${result.message}`));
return 1; return 1;
} }
@@ -702,7 +702,7 @@ export class AgentInstallCommand extends Command {
private async installAll(): Promise<number> { private async installAll(): Promise<number> {
const agents = getBundledAgents(); const agents = getBundledAgents();
console.log(chalk.cyan(`Installing ${agents.length} bundled agents...\n`)); console.log(colors.cyan(`Installing ${agents.length} bundled agents...\n`));
let successCount = 0; let successCount = 0;
let skipCount = 0; let skipCount = 0;
@@ -715,20 +715,20 @@ export class AgentInstallCommand extends Command {
}); });
if (result.success) { if (result.success) {
console.log(chalk.green(` ✓ ${agent.name}`)); console.log(colors.success(` ✓ ${agent.name}`));
successCount++; successCount++;
} else if (result.message.includes('already exists')) { } else if (result.message.includes('already exists')) {
console.log(chalk.yellow(` ○ ${agent.name} (already installed)`)); console.log(colors.warning(` ○ ${agent.name} (already installed)`));
skipCount++; skipCount++;
} else { } else {
console.log(chalk.red(` ✗ ${agent.name}: ${result.message}`)); console.log(colors.error(` ✗ ${agent.name}: ${result.message}`));
errorCount++; errorCount++;
} }
} }
console.log(); console.log();
console.log( console.log(
chalk.dim( colors.muted(
`Installed: ${successCount}, Skipped: ${skipCount}, Errors: ${errorCount}` `Installed: ${successCount}, Skipped: ${skipCount}, Errors: ${errorCount}`
) )
); );
@@ -781,10 +781,10 @@ export class AgentAvailableCommand extends Command {
if (agents.length === 0) { if (agents.length === 0) {
if (this.installed) { if (this.installed) {
console.log(chalk.yellow('No bundled agents installed')); console.log(colors.warning('No bundled agents installed'));
console.log(chalk.dim('Run `skillkit agent install <name>` to install')); console.log(colors.muted('Run `skillkit agent install <name>` to install'));
} else { } else {
console.log(chalk.green('All bundled agents are already installed!')); console.log(colors.success('All bundled agents are already installed!'));
} }
return 0; return 0;
} }
@@ -793,7 +793,7 @@ export class AgentAvailableCommand extends Command {
? 'Installed Bundled Agents' ? 'Installed Bundled Agents'
: 'Available Bundled Agents'; : 'Available Bundled Agents';
console.log(chalk.cyan(`${title} (${agents.length}):\n`)); console.log(colors.cyan(`${title} (${agents.length}):\n`));
const categories = new Map<string, BundledAgent[]>(); const categories = new Map<string, BundledAgent[]>();
for (const agent of agents) { for (const agent of agents) {
@@ -805,20 +805,20 @@ export class AgentAvailableCommand extends Command {
} }
for (const [category, catAgents] of categories) { for (const [category, catAgents] of categories) {
console.log(chalk.blue(` ${formatCategoryName(category)}`)); console.log(colors.info(` ${formatCategoryName(category)}`));
for (const agent of catAgents) { for (const agent of catAgents) {
const installed = isAgentInstalled(agent.id); const installed = isAgentInstalled(agent.id);
const status = installed ? chalk.green('✓') : chalk.dim('○'); const status = installed ? colors.success('✓') : colors.muted('○');
const model = agent.model ? chalk.blue(`[${agent.model}]`) : ''; const model = agent.model ? colors.info(`[${agent.model}]`) : '';
console.log(` ${status} ${chalk.bold(agent.id)} ${model}`); console.log(` ${status} ${colors.bold(agent.id)} ${model}`);
console.log(` ${chalk.dim(agent.description)}`); console.log(` ${colors.muted(agent.description)}`);
} }
console.log(); console.log();
} }
if (!this.installed) { if (!this.installed) {
console.log(chalk.dim('Install with: skillkit agent install <name>')); console.log(colors.muted('Install with: skillkit agent install <name>'));
console.log(chalk.dim('Install all: skillkit agent install --all')); console.log(colors.muted('Install all: skillkit agent install --all'));
} }
return 0; return 0;
@@ -877,20 +877,20 @@ export class AgentFromSkillCommand extends Command {
const skill = skills.find((s: Skill) => s.name === this.skillName); const skill = skills.find((s: Skill) => s.name === this.skillName);
if (!skill) { if (!skill) {
console.log(chalk.red(`Skill not found: ${this.skillName}`)); console.log(colors.error(`Skill not found: ${this.skillName}`));
console.log(chalk.dim('Available skills:')); console.log(colors.muted('Available skills:'));
for (const s of skills.slice(0, 10)) { for (const s of skills.slice(0, 10)) {
console.log(chalk.dim(` - ${s.name}`)); console.log(colors.muted(` - ${s.name}`));
} }
if (skills.length > 10) { if (skills.length > 10) {
console.log(chalk.dim(` ... and ${skills.length - 10} more`)); console.log(colors.muted(` ... and ${skills.length - 10} more`));
} }
return 1; return 1;
} }
const skillContent = readSkillContent(skill.path); const skillContent = readSkillContent(skill.path);
if (!skillContent) { if (!skillContent) {
console.log(chalk.red(`Could not read skill content: ${skill.path}`)); console.log(colors.error(`Could not read skill content: ${skill.path}`));
return 1; return 1;
} }
@@ -901,8 +901,8 @@ export class AgentFromSkillCommand extends Command {
if (this.model) { if (this.model) {
const validModels = ['sonnet', 'opus', 'haiku', 'inherit']; const validModels = ['sonnet', 'opus', 'haiku', 'inherit'];
if (!validModels.includes(this.model)) { if (!validModels.includes(this.model)) {
console.log(chalk.red(`Invalid model: ${this.model}`)); console.log(colors.error(`Invalid model: ${this.model}`));
console.log(chalk.dim(`Valid options: ${validModels.join(', ')}`)); console.log(colors.muted(`Valid options: ${validModels.join(', ')}`));
return 1; return 1;
} }
options.model = this.model as 'sonnet' | 'opus' | 'haiku' | 'inherit'; options.model = this.model as 'sonnet' | 'opus' | 'haiku' | 'inherit';
@@ -911,8 +911,8 @@ export class AgentFromSkillCommand extends Command {
if (this.permission) { if (this.permission) {
const validModes = ['default', 'plan', 'auto-edit', 'full-auto', 'bypassPermissions']; const validModes = ['default', 'plan', 'auto-edit', 'full-auto', 'bypassPermissions'];
if (!validModes.includes(this.permission)) { if (!validModes.includes(this.permission)) {
console.log(chalk.red(`Invalid permission mode: ${this.permission}`)); console.log(colors.error(`Invalid permission mode: ${this.permission}`));
console.log(chalk.dim(`Valid options: ${validModes.join(', ')}`)); console.log(colors.muted(`Valid options: ${validModes.join(', ')}`));
return 1; return 1;
} }
options.permissionMode = this.permission as AgentPermissionMode; options.permissionMode = this.permission as AgentPermissionMode;
@@ -928,16 +928,16 @@ export class AgentFromSkillCommand extends Command {
if (this.output) { if (this.output) {
const sanitized = sanitizeFilename(this.output); const sanitized = sanitizeFilename(this.output);
if (!sanitized) { if (!sanitized) {
console.log(chalk.red(`Invalid output filename: ${this.output}`)); console.log(colors.error(`Invalid output filename: ${this.output}`));
console.log(chalk.dim('Filename must contain only alphanumeric characters, hyphens, and underscores')); console.log(colors.muted('Filename must contain only alphanumeric characters, hyphens, and underscores'));
return 1; return 1;
} }
filename = `${sanitized}.md`; filename = `${sanitized}.md`;
} else { } else {
const sanitized = sanitizeFilename(skill.name); const sanitized = sanitizeFilename(skill.name);
if (!sanitized) { if (!sanitized) {
console.log(chalk.red(`Invalid skill name for filename: ${skill.name}`)); console.log(colors.error(`Invalid skill name for filename: ${skill.name}`));
console.log(chalk.dim('Skill name must contain only alphanumeric characters, hyphens, and underscores')); console.log(colors.muted('Skill name must contain only alphanumeric characters, hyphens, and underscores'));
return 1; return 1;
} }
filename = `${sanitized}.md`; filename = `${sanitized}.md`;
@@ -946,11 +946,11 @@ export class AgentFromSkillCommand extends Command {
const outputPath = join(targetDir, filename); const outputPath = join(targetDir, filename);
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.cyan('Preview (dry run):\n')); console.log(colors.cyan('Preview (dry run):\n'));
console.log(chalk.dim(`Would write to: ${outputPath}`)); console.log(colors.muted(`Would write to: ${outputPath}`));
console.log(chalk.dim('─'.repeat(50))); console.log(colors.muted('─'.repeat(50)));
console.log(content); console.log(content);
console.log(chalk.dim('─'.repeat(50))); console.log(colors.muted('─'.repeat(50)));
return 0; return 0;
} }
@@ -959,18 +959,18 @@ export class AgentFromSkillCommand extends Command {
} }
if (existsSync(outputPath)) { if (existsSync(outputPath)) {
console.log(chalk.yellow(`Overwriting existing file: ${outputPath}`)); console.log(colors.warning(`Overwriting existing file: ${outputPath}`));
} }
writeFileSync(outputPath, content); writeFileSync(outputPath, content);
console.log(chalk.green(`Created subagent: ${outputPath}`)); console.log(colors.success(`Created subagent: ${outputPath}`));
console.log(); console.log();
console.log(chalk.dim(`Invoke with: @${skill.name}`)); console.log(colors.muted(`Invoke with: @${skill.name}`));
if (!this.inline) { if (!this.inline) {
console.log(chalk.dim(`Skills referenced: ${skill.name}`)); console.log(colors.muted(`Skills referenced: ${skill.name}`));
} else { } else {
console.log(chalk.dim('Skill content embedded inline')); console.log(colors.muted('Skill content embedded inline'));
} }
return 0; return 0;
+10 -10
View File
@@ -1,6 +1,6 @@
import { existsSync, readFileSync, writeFileSync } from 'node:fs'; import { existsSync, readFileSync, writeFileSync } from 'node:fs';
import { join } from 'node:path'; import { join } from 'node:path';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { Command } from 'clipanion'; import { Command } from 'clipanion';
import { AgentsMdGenerator, AgentsMdParser } from '@skillkit/core'; import { AgentsMdGenerator, AgentsMdParser } from '@skillkit/core';
@@ -40,7 +40,7 @@ export class AgentsMdInitCommand extends Command {
const agentsPath = join(projectPath, 'AGENTS.md'); const agentsPath = join(projectPath, 'AGENTS.md');
if (existsSync(agentsPath)) { if (existsSync(agentsPath)) {
console.log(chalk.yellow('AGENTS.md already exists. Use `skillkit agents sync` to update.')); warn('AGENTS.md already exists. Use `skillkit agents sync` to update.');
return 1; return 1;
} }
@@ -48,15 +48,15 @@ export class AgentsMdInitCommand extends Command {
const generator = new AgentsMdGenerator({ projectPath }); const generator = new AgentsMdGenerator({ projectPath });
const result = generator.generate(); const result = generator.generate();
console.log(chalk.dim('Preview:')); console.log(colors.muted('Preview:'));
console.log(''); console.log('');
console.log(result.content); console.log(result.content);
writeFileSync(agentsPath, result.content, 'utf-8'); writeFileSync(agentsPath, result.content, 'utf-8');
console.log(chalk.green(`Created ${agentsPath}`)); success(`Created ${agentsPath}`);
return 0; return 0;
} catch (err) { } catch (err) {
console.log(chalk.red(`Failed to generate AGENTS.md: ${err instanceof Error ? err.message : String(err)}`)); error(`Failed to generate AGENTS.md: ${err instanceof Error ? err.message : String(err)}`);
return 1; return 1;
} }
} }
@@ -74,7 +74,7 @@ export class AgentsMdSyncCommand extends Command {
const agentsPath = join(projectPath, 'AGENTS.md'); const agentsPath = join(projectPath, 'AGENTS.md');
if (!existsSync(agentsPath)) { if (!existsSync(agentsPath)) {
console.log(chalk.yellow('No AGENTS.md found. Run `skillkit agents init` first.')); warn('No AGENTS.md found. Run `skillkit agents init` first.');
return 1; return 1;
} }
@@ -83,7 +83,7 @@ export class AgentsMdSyncCommand extends Command {
const parser = new AgentsMdParser(); const parser = new AgentsMdParser();
if (!parser.hasManagedSections(existing)) { if (!parser.hasManagedSections(existing)) {
console.log(chalk.yellow('No managed sections found in AGENTS.md. Nothing to update.')); warn('No managed sections found in AGENTS.md. Nothing to update.');
return 0; return 0;
} }
@@ -93,10 +93,10 @@ export class AgentsMdSyncCommand extends Command {
const updated = parser.updateManagedSections(existing, managedSections); const updated = parser.updateManagedSections(existing, managedSections);
writeFileSync(agentsPath, updated, 'utf-8'); writeFileSync(agentsPath, updated, 'utf-8');
console.log(chalk.green(`Updated ${managedSections.length} managed section(s) in AGENTS.md`)); success(`Updated ${managedSections.length} managed section(s) in AGENTS.md`);
return 0; return 0;
} catch (err) { } catch (err) {
console.log(chalk.red(`Failed to sync AGENTS.md: ${err instanceof Error ? err.message : String(err)}`)); error(`Failed to sync AGENTS.md: ${err instanceof Error ? err.message : String(err)}`);
return 1; return 1;
} }
} }
@@ -113,7 +113,7 @@ export class AgentsMdShowCommand extends Command {
const agentsPath = join(process.cwd(), 'AGENTS.md'); const agentsPath = join(process.cwd(), 'AGENTS.md');
if (!existsSync(agentsPath)) { if (!existsSync(agentsPath)) {
console.log(chalk.yellow('No AGENTS.md found. Run `skillkit agents init` to create one.')); warn('No AGENTS.md found. Run `skillkit agents init` to create one.');
return 1; return 1;
} }
+65 -63
View File
@@ -1,8 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { promises as fs } from 'fs'; import { promises as fs } from 'fs';
import chalk from 'chalk'; import { colors, spinner } from '../onboarding/index.js';
import ora from 'ora';
import { import {
type SearchableSkill, type SearchableSkill,
type SkillExample, type SkillExample,
@@ -88,7 +87,7 @@ export class AICommand extends Command {
const providerName = manager.getProviderName(); const providerName = manager.getProviderName();
if (providerName === 'mock') { if (providerName === 'mock') {
console.log( console.log(
chalk.yellow( colors.warning(
'⚠ Using mock AI provider (limited functionality)\n' + '⚠ Using mock AI provider (limited functionality)\n' +
' Set ANTHROPIC_API_KEY or OPENAI_API_KEY for real AI features\n' ' Set ANTHROPIC_API_KEY or OPENAI_API_KEY for real AI features\n'
) )
@@ -110,7 +109,7 @@ export class AICommand extends Command {
return this.handleProviders(); return this.handleProviders();
default: default:
console.error( console.error(
chalk.red(`Unknown subcommand: ${this.subcommand}\n`) colors.error(`Unknown subcommand: ${this.subcommand}\n`)
); );
console.log('Valid subcommands: search, generate, similar, wizard, providers'); console.log('Valid subcommands: search, generate, similar, wizard, providers');
return 1; return 1;
@@ -120,19 +119,20 @@ export class AICommand extends Command {
private async handleSearch(manager: AIManager): Promise<number> { private async handleSearch(manager: AIManager): Promise<number> {
const query = this.query || this.skillName; const query = this.query || this.skillName;
if (!query) { if (!query) {
console.error(chalk.red('Search query required (--query or positional argument)')); console.error(colors.error('Search query required (--query or positional argument)'));
return 1; return 1;
} }
const skills = await this.loadSkills(); const skills = await this.loadSkills();
if (skills.length === 0) { if (skills.length === 0) {
console.log( console.log(
chalk.yellow('No skills found. Run "skillkit recommend --update" first.') colors.warning('No skills found. Run "skillkit recommend --update" first.')
); );
return 0; return 0;
} }
const spinner = ora('Searching with AI...').start(); const s = spinner();
s.start('Searching with AI...');
try { try {
const results = await manager.searchSkills(query, skills, { const results = await manager.searchSkills(query, skills, {
@@ -143,7 +143,7 @@ export class AICommand extends Command {
includeReasoning: !this.json, includeReasoning: !this.json,
}); });
spinner.stop(); s.stop();
if (this.json) { if (this.json) {
console.log(JSON.stringify(results, null, 2)); console.log(JSON.stringify(results, null, 2));
@@ -151,37 +151,37 @@ export class AICommand extends Command {
} }
if (results.length === 0) { if (results.length === 0) {
console.log(chalk.yellow(`No skills found matching "${query}"`)); console.log(colors.warning(`No skills found matching "${query}"`));
return 0; return 0;
} }
console.log(chalk.cyan(`\nAI Search Results (${results.length} found):\n`)); console.log(colors.cyan(`\nAI Search Results (${results.length} found):\n`));
for (const result of results) { for (const result of results) {
const score = Math.round(result.relevance * 100); const score = Math.round(result.relevance * 100);
const scoreColor = const scoreColor =
score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.dim; score >= 70 ? colors.success : score >= 50 ? colors.warning : colors.muted;
console.log( console.log(
` ${scoreColor(`${score}%`)} ${chalk.bold(result.skill.name)}` ` ${scoreColor(`${score}%`)} ${colors.bold(result.skill.name)}`
); );
if (result.skill.description) { if (result.skill.description) {
console.log(` ${chalk.dim(result.skill.description)}`); console.log(` ${colors.muted(result.skill.description)}`);
} }
if (result.reasoning) { if (result.reasoning) {
console.log(` ${chalk.dim('→ ' + result.reasoning)}`); console.log(` ${colors.muted('→ ' + result.reasoning)}`);
} }
console.log(); console.log();
} }
return 0; return 0;
} catch (error) { } catch (err) {
spinner.fail('Search failed'); s.stop(colors.error('Search failed'));
console.error( console.error(
chalk.red(error instanceof Error ? error.message : String(error)) colors.error(err instanceof Error ? err.message : String(err))
); );
return 1; return 1;
} }
@@ -190,7 +190,7 @@ export class AICommand extends Command {
private async handleGenerate(manager: AIManager): Promise<number> { private async handleGenerate(manager: AIManager): Promise<number> {
const description = this.description; const description = this.description;
if (!description) { if (!description) {
console.error(chalk.red('Description required (--description)')); console.error(colors.error('Description required (--description)'));
return 1; return 1;
} }
@@ -201,7 +201,7 @@ export class AICommand extends Command {
const code = await fs.readFile(codePath, 'utf-8'); const code = await fs.readFile(codePath, 'utf-8');
codeExamples = [code]; codeExamples = [code];
} catch { } catch {
console.error(chalk.red(`Failed to read code file: ${codePath}`)); console.error(colors.error(`Failed to read code file: ${codePath}`));
return 1; return 1;
} }
} }
@@ -213,7 +213,8 @@ export class AICommand extends Command {
targetAgent: this.targetAgent, targetAgent: this.targetAgent,
}; };
const spinner = ora('Generating skill with AI...').start(); const s = spinner();
s.start('Generating skill with AI...');
try { try {
const generated = await manager.generateSkill(example, { const generated = await manager.generateSkill(example, {
@@ -222,13 +223,13 @@ export class AICommand extends Command {
includeDocumentation: true, includeDocumentation: true,
}); });
spinner.stop(); s.stop();
const validation = manager.validateGenerated(generated); const validation = manager.validateGenerated(generated);
if (!validation.valid) { if (!validation.valid) {
console.log(chalk.yellow('\n⚠ Generated skill has validation warnings:')); console.log(colors.warning('\n⚠ Generated skill has validation warnings:'));
for (const error of validation.errors) { for (const err of validation.errors) {
console.log(chalk.dim(` • ${error}`)); console.log(colors.muted(` • ${err}`));
} }
console.log(); console.log();
} }
@@ -238,41 +239,41 @@ export class AICommand extends Command {
return 0; return 0;
} }
console.log(chalk.green('\n✓ Generated skill successfully\n')); console.log(colors.success('\n✓ Generated skill successfully\n'));
console.log(chalk.cyan('Name:') + ` ${generated.name}`); console.log(colors.cyan('Name:') + ` ${generated.name}`);
console.log(chalk.cyan('Description:') + ` ${generated.description}`); console.log(colors.cyan('Description:') + ` ${generated.description}`);
console.log( console.log(
chalk.cyan('Tags:') + ` ${generated.tags.join(', ')}` colors.cyan('Tags:') + ` ${generated.tags.join(', ')}`
); );
console.log( console.log(
chalk.cyan('Confidence:') + colors.cyan('Confidence:') +
` ${Math.round(generated.confidence * 100)}%` ` ${Math.round(generated.confidence * 100)}%`
); );
if (generated.reasoning) { if (generated.reasoning) {
console.log(chalk.cyan('Reasoning:') + ` ${generated.reasoning}`); console.log(colors.cyan('Reasoning:') + ` ${generated.reasoning}`);
} }
console.log('\n' + chalk.dim('Content:')); console.log('\n' + colors.muted('Content:'));
console.log(chalk.dim('─'.repeat(60))); console.log(colors.muted('─'.repeat(60)));
console.log(generated.content); console.log(generated.content);
console.log(chalk.dim('─'.repeat(60))); console.log(colors.muted('─'.repeat(60)));
if (this.output) { if (this.output) {
const outputPath = resolve(this.output); const outputPath = resolve(this.output);
await fs.writeFile(outputPath, generated.content, 'utf-8'); await fs.writeFile(outputPath, generated.content, 'utf-8');
console.log(chalk.green(`\n✓ Saved to: ${outputPath}`)); console.log(colors.success(`\n✓ Saved to: ${outputPath}`));
} else { } else {
console.log( console.log(
chalk.dim('\nSave with: --output <filename>') colors.muted('\nSave with: --output <filename>')
); );
} }
return 0; return 0;
} catch (error) { } catch (err) {
spinner.fail('Generation failed'); s.stop(colors.error('Generation failed'));
console.error( console.error(
chalk.red(error instanceof Error ? error.message : String(error)) colors.error(err instanceof Error ? err.message : String(err))
); );
return 1; return 1;
} }
@@ -281,14 +282,14 @@ export class AICommand extends Command {
private async handleSimilar(manager: AIManager): Promise<number> { private async handleSimilar(manager: AIManager): Promise<number> {
const skillName = this.skillName; const skillName = this.skillName;
if (!skillName) { if (!skillName) {
console.error(chalk.red('Skill name required')); console.error(colors.error('Skill name required'));
return 1; return 1;
} }
const skills = await this.loadSkills(); const skills = await this.loadSkills();
if (skills.length === 0) { if (skills.length === 0) {
console.log( console.log(
chalk.yellow('No skills found. Run "skillkit recommend --update" first.') colors.warning('No skills found. Run "skillkit recommend --update" first.')
); );
return 0; return 0;
} }
@@ -298,11 +299,12 @@ export class AICommand extends Command {
); );
if (!targetSkill) { if (!targetSkill) {
console.error(chalk.red(`Skill not found: ${skillName}`)); console.error(colors.error(`Skill not found: ${skillName}`));
return 1; return 1;
} }
const spinner = ora('Finding similar skills...').start(); const s = spinner();
s.start('Finding similar skills...');
try { try {
const results = await manager.findSimilar(targetSkill, skills, { const results = await manager.findSimilar(targetSkill, skills, {
@@ -313,7 +315,7 @@ export class AICommand extends Command {
includeReasoning: !this.json, includeReasoning: !this.json,
}); });
spinner.stop(); s.stop();
if (this.json) { if (this.json) {
console.log(JSON.stringify(results, null, 2)); console.log(JSON.stringify(results, null, 2));
@@ -322,40 +324,40 @@ export class AICommand extends Command {
if (results.length === 0) { if (results.length === 0) {
console.log( console.log(
chalk.yellow(`No similar skills found for "${skillName}"`) colors.warning(`No similar skills found for "${skillName}"`)
); );
return 0; return 0;
} }
console.log( console.log(
chalk.cyan(`\nSkills similar to "${skillName}" (${results.length} found):\n`) colors.cyan(`\nSkills similar to "${skillName}" (${results.length} found):\n`)
); );
for (const result of results) { for (const result of results) {
const score = Math.round(result.relevance * 100); const score = Math.round(result.relevance * 100);
const scoreColor = const scoreColor =
score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.dim; score >= 70 ? colors.success : score >= 50 ? colors.warning : colors.muted;
console.log( console.log(
` ${scoreColor(`${score}%`)} ${chalk.bold(result.skill.name)}` ` ${scoreColor(`${score}%`)} ${colors.bold(result.skill.name)}`
); );
if (result.skill.description) { if (result.skill.description) {
console.log(` ${chalk.dim(result.skill.description)}`); console.log(` ${colors.muted(result.skill.description)}`);
} }
if (result.reasoning) { if (result.reasoning) {
console.log(` ${chalk.dim('→ ' + result.reasoning)}`); console.log(` ${colors.muted('→ ' + result.reasoning)}`);
} }
console.log(); console.log();
} }
return 0; return 0;
} catch (error) { } catch (err) {
spinner.fail('Search failed'); s.stop(colors.error('Search failed'));
console.error( console.error(
chalk.red(error instanceof Error ? error.message : String(error)) colors.error(err instanceof Error ? err.message : String(err))
); );
return 1; return 1;
} }
@@ -377,8 +379,8 @@ export class AICommand extends Command {
} }
private async handleWizard(): Promise<number> { private async handleWizard(): Promise<number> {
console.log(chalk.cyan('\nLaunching Smart Generate Wizard...\n')); console.log(colors.cyan('\nLaunching Smart Generate Wizard...\n'));
console.log(chalk.dim('For the full wizard experience, use: skillkit generate\n')); console.log(colors.muted('For the full wizard experience, use: skillkit generate\n'));
const { GenerateCommand } = await import('./generate.js'); const { GenerateCommand } = await import('./generate.js');
const generateCmd = new GenerateCommand(); const generateCmd = new GenerateCommand();
@@ -389,31 +391,31 @@ export class AICommand extends Command {
const detected = detectProviders(); const detected = detectProviders();
const defaultProvider = getDefaultProvider(); const defaultProvider = getDefaultProvider();
console.log(chalk.cyan('\nAvailable LLM Providers:\n')); console.log(colors.cyan('\nAvailable LLM Providers:\n'));
for (const provider of detected) { for (const provider of detected) {
const isDefault = provider.provider === defaultProvider; const isDefault = provider.provider === defaultProvider;
const status = provider.configured const status = provider.configured
? chalk.green('✓ Configured') ? colors.success('✓ Configured')
: chalk.dim('○ Not configured'); : colors.muted('○ Not configured');
const defaultBadge = isDefault ? chalk.yellow(' (default)') : ''; const defaultBadge = isDefault ? colors.warning(' (default)') : '';
console.log(` ${provider.displayName}${defaultBadge}`); console.log(` ${provider.displayName}${defaultBadge}`);
console.log(` ${status}`); console.log(` ${status}`);
if (provider.envVar) { if (provider.envVar) {
console.log(` ${chalk.dim(`Set ${provider.envVar} to configure`)}`); console.log(` ${colors.muted(`Set ${provider.envVar} to configure`)}`);
} }
console.log(); console.log();
} }
if (defaultProvider === 'mock') { if (defaultProvider === 'mock') {
console.log(` Mock Provider${chalk.yellow(' (default)')}`); console.log(` Mock Provider${colors.warning(' (default)')}`);
console.log(` ${chalk.green('✓ Always available')}`); console.log(` ${colors.success('✓ Always available')}`);
console.log(` ${chalk.dim('Basic functionality without API keys')}`); console.log(` ${colors.muted('Basic functionality without API keys')}`);
console.log(); console.log();
} }
console.log(chalk.dim('Use "skillkit generate --provider <name>" to use a specific provider\n')); console.log(colors.muted('Use "skillkit generate --provider <name>" to use a specific provider\n'));
return 0; return 0;
} }
+25 -29
View File
@@ -2,7 +2,7 @@ import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { promises as fs } from 'fs'; import { promises as fs } from 'fs';
import path from 'path'; import path from 'path';
import chalk from 'chalk'; import { colors, warn, success } from '../onboarding/index.js';
import { AuditLogger, type AuditQuery, type AuditEventType } from '@skillkit/core'; import { AuditLogger, type AuditQuery, type AuditEventType } from '@skillkit/core';
export class AuditCommand extends Command { export class AuditCommand extends Command {
@@ -104,7 +104,7 @@ export class AuditCommand extends Command {
case 'clear': case 'clear':
return await this.handleClear(logger); return await this.handleClear(logger);
default: default:
console.error(chalk.red(`Unknown subcommand: ${this.subcommand}\n`)); console.error(colors.error(`Unknown subcommand: ${this.subcommand}\n`));
console.log('Valid subcommands: log, export, stats, clear'); console.log('Valid subcommands: log, export, stats, clear');
return 1; return 1;
} }
@@ -123,37 +123,37 @@ export class AuditCommand extends Command {
} }
if (events.length === 0) { if (events.length === 0) {
console.log(chalk.yellow('No audit events found')); warn('No audit events found');
return 0; return 0;
} }
console.log(chalk.cyan(`\nAudit Log (${events.length} entries):\n`)); console.log(colors.cyan(`\nAudit Log (${events.length} entries):\n`));
for (const event of events) { for (const event of events) {
const statusIcon = event.success ? chalk.green('✓') : chalk.red('✗'); const statusIcon = event.success ? colors.success('✓') : colors.error('✗');
const timestamp = event.timestamp.toLocaleString(); const timestamp = event.timestamp.toLocaleString();
console.log( console.log(
`${statusIcon} ${chalk.dim(timestamp)} ${chalk.bold(event.type)}` `${statusIcon} ${colors.muted(timestamp)} ${colors.bold(event.type)}`
); );
console.log( console.log(
` ${event.action} on ${chalk.cyan(event.resource)}` ` ${event.action} on ${colors.cyan(event.resource)}`
); );
if (event.user) { if (event.user) {
console.log(` ${chalk.dim('User:')} ${event.user}`); console.log(` ${colors.muted('User:')} ${event.user}`);
} }
if (event.duration) { if (event.duration) {
console.log(` ${chalk.dim('Duration:')} ${event.duration}ms`); console.log(` ${colors.muted('Duration:')} ${event.duration}ms`);
} }
if (event.error) { if (event.error) {
console.log(` ${chalk.red('Error:')} ${event.error}`); console.log(` ${colors.error('Error:')} ${event.error}`);
} }
if (event.details && Object.keys(event.details).length > 0) { if (event.details && Object.keys(event.details).length > 0) {
console.log(` ${chalk.dim('Details:')} ${JSON.stringify(event.details)}`); console.log(` ${colors.muted('Details:')} ${JSON.stringify(event.details)}`);
} }
console.log(); console.log();
@@ -171,7 +171,7 @@ export class AuditCommand extends Command {
if (this.output) { if (this.output) {
const outputPath = resolve(this.output); const outputPath = resolve(this.output);
await fs.writeFile(outputPath, content, 'utf-8'); await fs.writeFile(outputPath, content, 'utf-8');
console.log(chalk.green(`✓ Exported audit log to: ${outputPath}`)); success(`✓ Exported audit log to: ${outputPath}`);
} else { } else {
console.log(content); console.log(content);
} }
@@ -187,14 +187,14 @@ export class AuditCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan('\nAudit Statistics:\n')); console.log(colors.cyan('\nAudit Statistics:\n'));
console.log(`Total Events: ${chalk.bold(stats.totalEvents.toString())}`); console.log(`Total Events: ${colors.bold(stats.totalEvents.toString())}`);
console.log( console.log(
`Success Rate: ${chalk.bold(`${(stats.successRate * 100).toFixed(1)}%`)}` `Success Rate: ${colors.bold(`${(stats.successRate * 100).toFixed(1)}%`)}`
); );
if (Object.keys(stats.eventsByType).length > 0) { if (Object.keys(stats.eventsByType).length > 0) {
console.log(chalk.cyan('\nEvents by Type:')); console.log(colors.cyan('\nEvents by Type:'));
const sorted = Object.entries(stats.eventsByType).sort( const sorted = Object.entries(stats.eventsByType).sort(
([, a], [, b]) => b - a ([, a], [, b]) => b - a
); );
@@ -204,21 +204,21 @@ export class AuditCommand extends Command {
} }
if (stats.topResources.length > 0) { if (stats.topResources.length > 0) {
console.log(chalk.cyan('\nTop Resources:')); console.log(colors.cyan('\nTop Resources:'));
for (const { resource, count } of stats.topResources) { for (const { resource, count } of stats.topResources) {
console.log(` ${resource.padEnd(40)} ${count}`); console.log(` ${resource.padEnd(40)} ${count}`);
} }
} }
if (stats.recentErrors.length > 0) { if (stats.recentErrors.length > 0) {
console.log(chalk.cyan(`\nRecent Errors (${stats.recentErrors.length}):`)); console.log(colors.cyan(`\nRecent Errors (${stats.recentErrors.length}):`));
for (const error of stats.recentErrors.slice(0, 5)) { for (const err of stats.recentErrors.slice(0, 5)) {
const timestamp = error.timestamp.toLocaleString(); const timestamp = err.timestamp.toLocaleString();
console.log( console.log(
` ${chalk.red('✗')} ${chalk.dim(timestamp)} ${error.type}` ` ${colors.error('✗')} ${colors.muted(timestamp)} ${err.type}`
); );
if (error.error) { if (err.error) {
console.log(` ${chalk.dim(error.error)}`); console.log(` ${colors.muted(err.error)}`);
} }
} }
} }
@@ -229,7 +229,7 @@ export class AuditCommand extends Command {
private async handleClear(logger: AuditLogger): Promise<number> { private async handleClear(logger: AuditLogger): Promise<number> {
if (!this.days) { if (!this.days) {
console.error(chalk.red('--days option required')); console.error(colors.error('--days option required'));
return 1; return 1;
} }
@@ -239,11 +239,7 @@ export class AuditCommand extends Command {
const cleared = await logger.clear(cutoffDate); const cleared = await logger.clear(cutoffDate);
console.log( success(`✓ Cleared ${cleared} audit entries older than ${daysAgo} days`);
chalk.green(
`✓ Cleared ${cleared} audit entries older than ${daysAgo} days`
)
);
return 0; return 0;
} }
+78 -15
View File
@@ -1,8 +1,8 @@
import { existsSync } from 'node:fs'; import { existsSync, statSync } from 'node:fs';
import { join } from 'node:path'; import { join } from 'node:path';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { findAllSkills, findSkill, detectProvider, isLocalPath } from '@skillkit/core'; import { findAllSkills, findSkill, detectProvider, isLocalPath, evaluateSkillDirectory } from '@skillkit/core';
import { getSearchDirs, loadSkillMetadata } from '../helpers.js'; import { getSearchDirs, loadSkillMetadata, formatCount, timeAgo, fetchGitHubActivity } from '../helpers.js';
import { import {
colors, colors,
symbols, symbols,
@@ -11,6 +11,8 @@ import {
success, success,
warn, warn,
header, header,
formatQualityBadge,
getQualityGradeFromScore,
} from '../onboarding/index.js'; } from '../onboarding/index.js';
interface UpdateInfo { interface UpdateInfo {
@@ -18,15 +20,19 @@ interface UpdateInfo {
currentVersion?: string; currentVersion?: string;
hasUpdate: boolean; hasUpdate: boolean;
error?: string; error?: string;
qualityScore?: number | null;
stars?: number | null;
pushedAt?: string | null;
} }
export class CheckCommand extends Command { export class CheckCommand extends Command {
static override paths = [['check']]; static override paths = [['check']];
static override usage = Command.Usage({ static override usage = Command.Usage({
description: 'Check for available skill updates (dry-run)', description: 'Check installed skills for updates, quality, and activity',
details: ` details: `
Checks if installed skills have updates available from their sources. Checks if installed skills have updates available from their sources.
Shows quality scores and GitHub activity for each skill.
Does not modify any files - just reports what would be updated. Does not modify any files - just reports what would be updated.
`, `,
examples: [ examples: [
@@ -89,12 +95,15 @@ export class CheckCommand extends Command {
for (const skill of skillsToCheck) { for (const skill of skillsToCheck) {
const metadata = loadSkillMetadata(skill.path); const metadata = loadSkillMetadata(skill.path);
const quality = evaluateSkillDirectory(skill.path);
const qualityScore = quality?.overall ?? null;
if (!metadata) { if (!metadata) {
results.push({ results.push({
name: skill.name, name: skill.name,
hasUpdate: false, hasUpdate: false,
error: 'No metadata (reinstall needed)', error: 'No metadata (reinstall needed)',
qualityScore,
}); });
continue; continue;
} }
@@ -114,6 +123,7 @@ export class CheckCommand extends Command {
name: skill.name, name: skill.name,
hasUpdate: false, hasUpdate: false,
error: 'Local source missing', error: 'Local source missing',
qualityScore,
}); });
if (this.verbose) s.stop(`${skill.name}: source missing`); if (this.verbose) s.stop(`${skill.name}: source missing`);
continue; continue;
@@ -123,20 +133,19 @@ export class CheckCommand extends Command {
const installedSkillMd = join(skill.path, 'SKILL.md'); const installedSkillMd = join(skill.path, 'SKILL.md');
if (existsSync(sourceSkillMd) && existsSync(installedSkillMd)) { if (existsSync(sourceSkillMd) && existsSync(installedSkillMd)) {
const { statSync } = await import('node:fs');
const sourceTime = statSync(sourceSkillMd).mtime; const sourceTime = statSync(sourceSkillMd).mtime;
const installedTime = statSync(installedSkillMd).mtime; const installedTime = statSync(installedSkillMd).mtime;
if (sourceTime > installedTime) { if (sourceTime > installedTime) {
results.push({ name: skill.name, hasUpdate: true }); results.push({ name: skill.name, hasUpdate: true, qualityScore });
updatesAvailable++; updatesAvailable++;
if (this.verbose) s.stop(`${skill.name}: update available`); if (this.verbose) s.stop(`${skill.name}: update available`);
} else { } else {
results.push({ name: skill.name, hasUpdate: false }); results.push({ name: skill.name, hasUpdate: false, qualityScore });
if (this.verbose) s.stop(`${skill.name}: up to date`); if (this.verbose) s.stop(`${skill.name}: up to date`);
} }
} else { } else {
results.push({ name: skill.name, hasUpdate: false }); results.push({ name: skill.name, hasUpdate: false, qualityScore });
if (this.verbose) s.stop(`${skill.name}: up to date`); if (this.verbose) s.stop(`${skill.name}: up to date`);
} }
} else { } else {
@@ -147,15 +156,31 @@ export class CheckCommand extends Command {
name: skill.name, name: skill.name,
hasUpdate: false, hasUpdate: false,
error: 'Unknown provider', error: 'Unknown provider',
qualityScore,
}); });
if (this.verbose) s.stop(`${skill.name}: unknown provider`); if (this.verbose) s.stop(`${skill.name}: unknown provider`);
continue; continue;
} }
const parsed = provider.parseSource(metadata.source);
let stars: number | null = null;
let pushedAt: string | null = null;
if (parsed && provider.name === 'GitHub') {
const activity = await fetchGitHubActivity(parsed.owner, parsed.repo);
if (activity) {
stars = activity.stars;
pushedAt = activity.pushedAt;
}
}
results.push({ results.push({
name: skill.name, name: skill.name,
hasUpdate: false, hasUpdate: false,
currentVersion: metadata.updatedAt || metadata.installedAt, currentVersion: metadata.updatedAt || metadata.installedAt,
qualityScore,
stars,
pushedAt,
}); });
if (this.verbose) s.stop(`${skill.name}: remote source (run update to sync)`); if (this.verbose) s.stop(`${skill.name}: remote source (run update to sync)`);
} }
@@ -164,6 +189,7 @@ export class CheckCommand extends Command {
name: skill.name, name: skill.name,
hasUpdate: false, hasUpdate: false,
error: err instanceof Error ? err.message : 'Check failed', error: err instanceof Error ? err.message : 'Check failed',
qualityScore,
}); });
if (this.verbose) s.stop(`${skill.name}: error`); if (this.verbose) s.stop(`${skill.name}: error`);
} }
@@ -178,27 +204,46 @@ export class CheckCommand extends Command {
if (withUpdates.length > 0) { if (withUpdates.length > 0) {
console.log(colors.primary('Updates available:')); console.log(colors.primary('Updates available:'));
for (const r of withUpdates) { for (const r of withUpdates) {
console.log(` ${colors.success(symbols.arrowUp)} ${colors.primary(r.name)}`); const badge = this.qualityBadgeFor(r.qualityScore);
console.log(` ${colors.success(symbols.arrowUp)} ${colors.primary(r.name)}${badge}`);
} }
console.log(''); console.log('');
} }
if (upToDate.length > 0 && this.verbose) { if (upToDate.length > 0) {
console.log(colors.muted('Up to date:')); if (this.verbose) {
for (const r of upToDate) { console.log(colors.muted('Up to date:'));
console.log(` ${colors.muted(symbols.success)} ${colors.muted(r.name)}`);
} }
console.log(''); for (const r of upToDate) {
const badge = this.qualityBadgeFor(r.qualityScore);
const activityStr = this.formatActivity(r);
if (this.verbose) {
console.log(` ${colors.muted(symbols.success)} ${colors.muted(r.name)}${badge}${activityStr}`);
}
}
if (this.verbose) console.log('');
} }
if (withErrors.length > 0) { if (withErrors.length > 0) {
console.log(colors.warning('Could not check:')); console.log(colors.warning('Could not check:'));
for (const r of withErrors) { for (const r of withErrors) {
console.log(` ${colors.warning(symbols.warning)} ${r.name}: ${colors.muted(r.error || 'unknown')}`); const badge = this.qualityBadgeFor(r.qualityScore);
console.log(` ${colors.warning(symbols.warning)} ${r.name}${badge}: ${colors.muted(r.error || 'unknown')}`);
} }
console.log(''); console.log('');
} }
if (!this.quiet) {
const qualityScores = results
.map(r => r.qualityScore)
.filter((s): s is number => typeof s === 'number');
if (qualityScores.length > 0) {
const avg = Math.round(qualityScores.reduce((a, b) => a + b, 0) / qualityScores.length);
const grade = getQualityGradeFromScore(avg);
console.log(colors.muted(`Average quality: ${avg}/100 (${grade})`));
}
}
if (updatesAvailable > 0) { if (updatesAvailable > 0) {
success(`${updatesAvailable} update(s) available`); success(`${updatesAvailable} update(s) available`);
console.log(colors.muted('Run `skillkit update` to install updates')); console.log(colors.muted('Run `skillkit update` to install updates'));
@@ -208,4 +253,22 @@ export class CheckCommand extends Command {
return 0; return 0;
} }
private qualityBadgeFor(score: number | null | undefined): string {
if (typeof score !== 'number') return '';
return ` ${formatQualityBadge(score)}`;
}
private formatActivity(r: UpdateInfo): string {
const parts: string[] = [];
if (typeof r.stars === 'number' && r.stars > 0) {
parts.push(`${formatCount(r.stars)} stars`);
}
if (r.pushedAt) {
parts.push(`pushed ${timeAgo(r.pushedAt)}`);
}
if (parts.length === 0) return '';
return ` ${colors.muted(`(${parts.join(', ')})`)}`;
}
} }
+9 -9
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs'; import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
import { join } from 'node:path'; import { join } from 'node:path';
@@ -247,7 +247,7 @@ export class CICDCommand extends Command {
? ['github', 'gitlab', 'circleci'] ? ['github', 'gitlab', 'circleci']
: [this.provider as CICDProvider]; : [this.provider as CICDProvider];
console.log(chalk.cyan('Initializing CI/CD workflows...')); console.log(colors.cyan('Initializing CI/CD workflows...'));
console.log(); console.log();
let success = true; let success = true;
@@ -256,29 +256,29 @@ export class CICDCommand extends Command {
for (const provider of providers) { for (const provider of providers) {
const result = this.createWorkflow(projectPath, provider); const result = this.createWorkflow(projectPath, provider);
if (result.skipped) { if (result.skipped) {
console.log(chalk.yellow(` ${result.message}`)); console.log(colors.warning(` ${result.message}`));
continue; continue;
} }
if (!result.success) { if (!result.success) {
success = false; success = false;
console.error(chalk.red(` ${result.message}`)); console.error(colors.error(` ${result.message}`));
continue; continue;
} }
created = true; created = true;
console.log(chalk.green(` ✓ ${result.message}`)); console.log(colors.success(` ✓ ${result.message}`));
} }
if (success) { if (success) {
console.log(); console.log();
console.log( console.log(
created created
? chalk.green('CI/CD workflows initialized successfully!') ? colors.success('CI/CD workflows initialized successfully!')
: chalk.yellow('CI/CD workflows already exist; nothing to do.') : colors.warning('CI/CD workflows already exist; nothing to do.')
); );
console.log(); console.log();
if (created) { if (created) {
console.log(chalk.dim('The workflows will run on push/PR to validate your skills.')); console.log(colors.muted('The workflows will run on push/PR to validate your skills.'));
console.log(chalk.dim('Commit the generated files to enable CI/CD.')); console.log(colors.muted('Commit the generated files to enable CI/CD.'));
} }
} }
+60 -62
View File
@@ -1,7 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { existsSync, readFileSync, writeFileSync } from 'node:fs'; import { existsSync, readFileSync, writeFileSync } from 'node:fs';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { import {
type AgentType, type AgentType,
type ProjectContext, type ProjectContext,
@@ -103,8 +103,8 @@ export class ContextCommand extends Command {
case 'agents': case 'agents':
return this.listAgents(); return this.listAgents();
default: default:
console.error(chalk.red(`Unknown action: ${action}`)); console.error(colors.error(`Unknown action: ${action}`));
console.log(chalk.gray('Available actions: init, show, export, import, sync, detect, agents')); console.log(colors.muted('Available actions: init, show, export, import, sync, detect, agents'));
return 1; return 1;
} }
} }
@@ -116,16 +116,16 @@ export class ContextCommand extends Command {
const manager = new ContextManager(process.cwd()); const manager = new ContextManager(process.cwd());
if (manager.exists() && !this.force) { if (manager.exists() && !this.force) {
console.log(chalk.yellow('Context already exists. Use --force to reinitialize.')); console.log(colors.warning('Context already exists. Use --force to reinitialize.'));
return this.showContext(); return this.showContext();
} }
console.log(chalk.cyan('Initializing project context...\n')); console.log(colors.cyan('Initializing project context...\n'));
const context = manager.init({ force: this.force }); const context = manager.init({ force: this.force });
console.log(chalk.green('✓ Context initialized\n')); console.log(colors.success('✓ Context initialized\n'));
console.log(chalk.gray(` Location: .skillkit/context.yaml\n`)); console.log(colors.muted(` Location: .skillkit/context.yaml\n`));
// Show summary // Show summary
this.printContextSummary(context); this.printContextSummary(context);
@@ -134,9 +134,9 @@ export class ContextCommand extends Command {
const sync = createContextSync(process.cwd()); const sync = createContextSync(process.cwd());
const detected = sync.detectAgents(); const detected = sync.detectAgents();
if (detected.length > 0) { if (detected.length > 0) {
console.log(chalk.cyan('\nDetected agents:')); console.log(colors.cyan('\nDetected agents:'));
for (const agent of detected) { for (const agent of detected) {
console.log(` ${chalk.green('•')} ${agent}`); console.log(` ${colors.success('•')} ${agent}`);
} }
// Update context with detected agents // Update context with detected agents
@@ -146,7 +146,7 @@ export class ContextCommand extends Command {
}); });
} }
console.log(chalk.gray('\nRun `skillkit context sync` to sync skills to all agents.')); console.log(colors.muted('\nRun `skillkit context sync` to sync skills to all agents.'));
return 0; return 0;
} }
@@ -159,7 +159,7 @@ export class ContextCommand extends Command {
const context = manager.load(); const context = manager.load();
if (!context) { if (!context) {
console.log(chalk.yellow('No context found. Run `skillkit context init` first.')); console.log(colors.warning('No context found. Run `skillkit context init` first.'));
return 1; return 1;
} }
@@ -171,8 +171,8 @@ export class ContextCommand extends Command {
this.printContextSummary(context); this.printContextSummary(context);
if (this.verbose) { if (this.verbose) {
console.log(chalk.gray('\nFull context:')); console.log(colors.muted('\nFull context:'));
console.log(chalk.gray(JSON.stringify(context, null, 2))); console.log(colors.muted(JSON.stringify(context, null, 2)));
} }
return 0; return 0;
@@ -186,7 +186,7 @@ export class ContextCommand extends Command {
const context = manager.get(); const context = manager.get();
if (!context) { if (!context) {
console.error(chalk.red('No context found. Run `skillkit context init` first.')); console.error(colors.error('No context found. Run `skillkit context init` first.'));
return 1; return 1;
} }
@@ -200,12 +200,12 @@ export class ContextCommand extends Command {
if (this.output) { if (this.output) {
const outputPath = resolve(this.output); const outputPath = resolve(this.output);
if (existsSync(outputPath) && !this.force) { if (existsSync(outputPath) && !this.force) {
console.error(chalk.red(`File exists: ${outputPath}. Use --force to overwrite.`)); console.error(colors.error(`File exists: ${outputPath}. Use --force to overwrite.`));
return 1; return 1;
} }
writeFileSync(outputPath, content, 'utf-8'); writeFileSync(outputPath, content, 'utf-8');
console.log(chalk.green(`✓ Context exported to ${outputPath}`)); console.log(colors.success(`✓ Context exported to ${outputPath}`));
} else { } else {
// Print to stdout // Print to stdout
console.log(content); console.log(content);
@@ -219,13 +219,13 @@ export class ContextCommand extends Command {
*/ */
private async importContext(): Promise<number> { private async importContext(): Promise<number> {
if (!this.input) { if (!this.input) {
console.error(chalk.red('Error: --input/-i file path is required')); console.error(colors.error('Error: --input/-i file path is required'));
return 1; return 1;
} }
const inputPath = resolve(this.input); const inputPath = resolve(this.input);
if (!existsSync(inputPath)) { if (!existsSync(inputPath)) {
console.error(chalk.red(`File not found: ${inputPath}`)); console.error(colors.error(`File not found: ${inputPath}`));
return 1; return 1;
} }
@@ -238,11 +238,11 @@ export class ContextCommand extends Command {
overwrite: this.force, overwrite: this.force,
}); });
console.log(chalk.green('✓ Context imported successfully')); console.log(colors.success('✓ Context imported successfully'));
this.printContextSummary(context); this.printContextSummary(context);
return 0; return 0;
} catch (error) { } catch (error) {
console.error(chalk.red(`Import failed: ${error}`)); console.error(colors.error(`Import failed: ${error}`));
return 1; return 1;
} }
} }
@@ -255,13 +255,13 @@ export class ContextCommand extends Command {
const context = manager.get(); const context = manager.get();
if (!context) { if (!context) {
console.log(chalk.yellow('No context found. Initializing...')); console.log(colors.warning('No context found. Initializing...'));
manager.init(); manager.init();
} }
const sync = createContextSync(process.cwd()); const sync = createContextSync(process.cwd());
console.log(chalk.cyan('Syncing skills across agents...\n')); console.log(colors.cyan('Syncing skills across agents...\n'));
// Determine target agents // Determine target agents
const agents = this.agent ? [this.agent as AgentType] : undefined; const agents = this.agent ? [this.agent as AgentType] : undefined;
@@ -274,33 +274,33 @@ export class ContextCommand extends Command {
// Print results // Print results
for (const result of report.results) { for (const result of report.results) {
const status = result.success ? chalk.green('✓') : chalk.red('✗'); const status = result.success ? colors.success('✓') : colors.error('✗');
console.log(`${status} ${result.agent}: ${result.skillsSynced} synced, ${result.skillsSkipped} skipped`); console.log(`${status} ${result.agent}: ${result.skillsSynced} synced, ${result.skillsSkipped} skipped`);
if (this.verbose && result.files.length > 0) { if (this.verbose && result.files.length > 0) {
for (const file of result.files) { for (const file of result.files) {
console.log(chalk.gray(` → ${file}`)); console.log(colors.muted(` → ${file}`));
} }
} }
if (result.warnings.length > 0) { if (result.warnings.length > 0) {
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`)); console.log(colors.warning(` ⚠ ${warning}`));
} }
} }
if (result.errors.length > 0) { if (result.errors.length > 0) {
for (const error of result.errors) { for (const error of result.errors) {
console.log(chalk.red(` ✗ ${error}`)); console.log(colors.error(` ✗ ${error}`));
} }
} }
} }
console.log(); console.log();
console.log(chalk.bold(`Summary: ${report.successfulAgents}/${report.totalAgents} agents, ${report.totalSkills} skills`)); console.log(colors.bold(`Summary: ${report.successfulAgents}/${report.totalAgents} agents, ${report.totalSkills} skills`));
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray('\n(Dry run - no files were written)')); console.log(colors.muted('\n(Dry run - no files were written)'));
} }
return report.successfulAgents === report.totalAgents ? 0 : 1; return report.successfulAgents === report.totalAgents ? 0 : 1;
@@ -310,86 +310,86 @@ export class ContextCommand extends Command {
* Detect project stack * Detect project stack
*/ */
private async detectProject(): Promise<number> { private async detectProject(): Promise<number> {
console.log(chalk.cyan('Analyzing project...\n')); console.log(colors.cyan('Analyzing project...\n'));
const stack = analyzeProject(process.cwd()); const stack = analyzeProject(process.cwd());
const tags = getStackTags(stack); const tags = getStackTags(stack);
// Languages // Languages
if (stack.languages.length > 0) { if (stack.languages.length > 0) {
console.log(chalk.bold('Languages:')); console.log(colors.bold('Languages:'));
for (const lang of stack.languages) { for (const lang of stack.languages) {
const version = lang.version ? ` (${lang.version})` : ''; const version = lang.version ? ` (${lang.version})` : '';
console.log(` ${chalk.green('•')} ${lang.name}${version}`); console.log(` ${colors.success('•')} ${lang.name}${version}`);
} }
console.log(); console.log();
} }
// Frameworks // Frameworks
if (stack.frameworks.length > 0) { if (stack.frameworks.length > 0) {
console.log(chalk.bold('Frameworks:')); console.log(colors.bold('Frameworks:'));
for (const fw of stack.frameworks) { for (const fw of stack.frameworks) {
const version = fw.version ? ` (${fw.version})` : ''; const version = fw.version ? ` (${fw.version})` : '';
console.log(` ${chalk.green('•')} ${fw.name}${version}`); console.log(` ${colors.success('•')} ${fw.name}${version}`);
} }
console.log(); console.log();
} }
// Libraries // Libraries
if (stack.libraries.length > 0) { if (stack.libraries.length > 0) {
console.log(chalk.bold('Libraries:')); console.log(colors.bold('Libraries:'));
for (const lib of stack.libraries) { for (const lib of stack.libraries) {
const version = lib.version ? ` (${lib.version})` : ''; const version = lib.version ? ` (${lib.version})` : '';
console.log(` ${chalk.green('•')} ${lib.name}${version}`); console.log(` ${colors.success('•')} ${lib.name}${version}`);
} }
console.log(); console.log();
} }
// Styling // Styling
if (stack.styling.length > 0) { if (stack.styling.length > 0) {
console.log(chalk.bold('Styling:')); console.log(colors.bold('Styling:'));
for (const style of stack.styling) { for (const style of stack.styling) {
console.log(` ${chalk.green('•')} ${style.name}`); console.log(` ${colors.success('•')} ${style.name}`);
} }
console.log(); console.log();
} }
// Testing // Testing
if (stack.testing.length > 0) { if (stack.testing.length > 0) {
console.log(chalk.bold('Testing:')); console.log(colors.bold('Testing:'));
for (const test of stack.testing) { for (const test of stack.testing) {
console.log(` ${chalk.green('•')} ${test.name}`); console.log(` ${colors.success('•')} ${test.name}`);
} }
console.log(); console.log();
} }
// Databases // Databases
if (stack.databases.length > 0) { if (stack.databases.length > 0) {
console.log(chalk.bold('Databases:')); console.log(colors.bold('Databases:'));
for (const db of stack.databases) { for (const db of stack.databases) {
console.log(` ${chalk.green('•')} ${db.name}`); console.log(` ${colors.success('•')} ${db.name}`);
} }
console.log(); console.log();
} }
// Tools // Tools
if (stack.tools.length > 0) { if (stack.tools.length > 0) {
console.log(chalk.bold('Tools:')); console.log(colors.bold('Tools:'));
for (const tool of stack.tools) { for (const tool of stack.tools) {
console.log(` ${chalk.green('•')} ${tool.name}`); console.log(` ${colors.success('•')} ${tool.name}`);
} }
console.log(); console.log();
} }
// Tags // Tags
if (tags.length > 0) { if (tags.length > 0) {
console.log(chalk.bold('Recommended skill tags:')); console.log(colors.bold('Recommended skill tags:'));
console.log(` ${chalk.cyan(tags.join(', '))}`); console.log(` ${colors.cyan(tags.join(', '))}`);
console.log(); console.log();
} }
if (this.json) { if (this.json) {
console.log(chalk.gray('\nJSON:')); console.log(colors.muted('\nJSON:'));
console.log(JSON.stringify(stack, null, 2)); console.log(JSON.stringify(stack, null, 2));
} }
@@ -405,27 +405,27 @@ export class ContextCommand extends Command {
const status = sync.checkStatus(); const status = sync.checkStatus();
const adapters = getAllAdapters(); const adapters = getAllAdapters();
console.log(chalk.bold('\nAgent Status:\n')); console.log(colors.bold('\nAgent Status:\n'));
for (const [agent, info] of Object.entries(status)) { for (const [agent, info] of Object.entries(status)) {
const adapter = adapters.find(a => a.type === agent); const adapter = adapters.find(a => a.type === agent);
const name = adapter?.name || agent; const name = adapter?.name || agent;
const isDetected = detected.includes(agent as AgentType); const isDetected = detected.includes(agent as AgentType);
const statusIcon = info.hasSkills ? chalk.green('●') : isDetected ? chalk.yellow('○') : chalk.gray('○'); const statusIcon = info.hasSkills ? colors.success('●') : isDetected ? colors.warning('○') : colors.muted('○');
const skillInfo = info.skillCount > 0 ? chalk.gray(` (${info.skillCount} skills)`) : ''; const skillInfo = info.skillCount > 0 ? colors.muted(` (${info.skillCount} skills)`) : '';
console.log(` ${statusIcon} ${name.padEnd(20)} ${chalk.gray(agent)}${skillInfo}`); console.log(` ${statusIcon} ${name.padEnd(20)} ${colors.muted(agent)}${skillInfo}`);
if (this.verbose && info.skills.length > 0) { if (this.verbose && info.skills.length > 0) {
for (const skill of info.skills) { for (const skill of info.skills) {
console.log(chalk.gray(` └─ ${skill}`)); console.log(colors.muted(` └─ ${skill}`));
} }
} }
} }
console.log(); console.log();
console.log(chalk.gray('Legend: ● has skills, ○ detected/configured, ○ not detected')); console.log(colors.muted('Legend: ● has skills, ○ detected/configured, ○ not detected'));
console.log(); console.log();
return 0; return 0;
@@ -435,8 +435,8 @@ export class ContextCommand extends Command {
* Print context summary * Print context summary
*/ */
private printContextSummary(context: ProjectContext): void { private printContextSummary(context: ProjectContext): void {
console.log(chalk.bold('Project:')); console.log(colors.bold('Project:'));
console.log(` Name: ${chalk.cyan(context.project.name)}`); console.log(` Name: ${colors.cyan(context.project.name)}`);
if (context.project.type) { if (context.project.type) {
console.log(` Type: ${context.project.type}`); console.log(` Type: ${context.project.type}`);
} }
@@ -460,32 +460,30 @@ export class ContextCommand extends Command {
} }
if (stackItems.length > 0) { if (stackItems.length > 0) {
console.log(`\n${chalk.bold('Stack:')} ${stackItems.join(', ')}`); console.log(`\n${colors.bold('Stack:')} ${stackItems.join(', ')}`);
// Show top items
const topFrameworks = context.stack.frameworks.slice(0, 3).map(f => f.name); const topFrameworks = context.stack.frameworks.slice(0, 3).map(f => f.name);
if (topFrameworks.length > 0) { if (topFrameworks.length > 0) {
console.log(` Frameworks: ${chalk.cyan(topFrameworks.join(', '))}`); console.log(` Frameworks: ${colors.cyan(topFrameworks.join(', '))}`);
} }
const topLibs = context.stack.libraries.slice(0, 3).map(l => l.name); const topLibs = context.stack.libraries.slice(0, 3).map(l => l.name);
if (topLibs.length > 0) { if (topLibs.length > 0) {
console.log(` Libraries: ${chalk.cyan(topLibs.join(', '))}`); console.log(` Libraries: ${colors.cyan(topLibs.join(', '))}`);
} }
} }
// Skills summary // Skills summary
if (context.skills) { if (context.skills) {
console.log(`\n${chalk.bold('Skills:')}`); console.log(`\n${colors.bold('Skills:')}`);
console.log(` Installed: ${context.skills.installed?.length || 0}`); console.log(` Installed: ${context.skills.installed?.length || 0}`);
console.log(` Auto-sync: ${context.skills.autoSync ? 'enabled' : 'disabled'}`); console.log(` Auto-sync: ${context.skills.autoSync ? 'enabled' : 'disabled'}`);
} }
// Agents summary
if (context.agents) { if (context.agents) {
console.log(`\n${chalk.bold('Agents:')}`); console.log(`\n${colors.bold('Agents:')}`);
if (context.agents.primary) { if (context.agents.primary) {
console.log(` Primary: ${chalk.cyan(context.agents.primary)}`); console.log(` Primary: ${colors.cyan(context.agents.primary)}`);
} }
if (context.agents.synced?.length) { if (context.agents.synced?.length) {
console.log(` Synced: ${context.agents.synced.join(', ')}`); console.log(` Synced: ${context.agents.synced.join(', ')}`);
+18 -18
View File
@@ -1,6 +1,6 @@
import { existsSync, mkdirSync, writeFileSync } from 'node:fs'; import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
import { join } from 'node:path'; import { join } from 'node:path';
import chalk from 'chalk'; import { colors, success, error, step } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
export class CreateCommand extends Command { export class CreateCommand extends Command {
@@ -41,8 +41,8 @@ export class CreateCommand extends Command {
const skillName = this.name.toLowerCase(); const skillName = this.name.toLowerCase();
if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(skillName)) { if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(skillName)) {
console.error(chalk.red('Invalid skill name')); error('Invalid skill name');
console.error(chalk.dim('Must be lowercase alphanumeric with hyphens (e.g., my-skill)')); console.log(colors.muted('Must be lowercase alphanumeric with hyphens (e.g., my-skill)'));
return 1; return 1;
} }
@@ -50,7 +50,7 @@ export class CreateCommand extends Command {
const skillDir = join(parentDir, skillName); const skillDir = join(parentDir, skillName);
if (existsSync(skillDir)) { if (existsSync(skillDir)) {
console.error(chalk.red(`Directory already exists: ${skillDir}`)); error(`Directory already exists: ${skillDir}`);
return 1; return 1;
} }
@@ -78,24 +78,24 @@ export class CreateCommand extends Command {
writeFileSync(join(assetsDir, '.gitkeep'), ''); writeFileSync(join(assetsDir, '.gitkeep'), '');
} }
console.log(chalk.green(`Created skill: ${skillName}`)); success(`Created skill: ${skillName}`);
console.log(); console.log();
console.log(chalk.dim('Structure:')); console.log(colors.muted('Structure:'));
console.log(chalk.dim(` ${skillDir}/`)); console.log(colors.muted(` ${skillDir}/`));
console.log(chalk.dim(' ├── SKILL.md')); console.log(colors.muted(' ├── SKILL.md'));
if (this.full || this.references) console.log(chalk.dim(' ├── references/')); if (this.full || this.references) console.log(colors.muted(' ├── references/'));
if (this.full || this.scripts) console.log(chalk.dim(' ├── scripts/')); if (this.full || this.scripts) console.log(colors.muted(' ├── scripts/'));
if (this.full || this.assets) console.log(chalk.dim(' └── assets/')); if (this.full || this.assets) console.log(colors.muted(' └── assets/'));
console.log(); console.log();
console.log(chalk.cyan('Next steps:')); step('Next steps:');
console.log(chalk.dim(' 1. Edit SKILL.md with your instructions')); console.log(colors.muted(' 1. Edit SKILL.md with your instructions'));
console.log(chalk.dim(' 2. Validate: skillkit validate ' + skillDir)); console.log(colors.muted(' 2. Validate: skillkit validate ' + skillDir));
console.log(chalk.dim(' 3. Test: skillkit read ' + skillName)); console.log(colors.muted(' 3. Test: skillkit read ' + skillName));
return 0; return 0;
} catch (error) { } catch (err) {
console.error(chalk.red('Failed to create skill')); error('Failed to create skill');
console.error(chalk.dim(error instanceof Error ? error.message : String(error))); console.log(colors.muted(err instanceof Error ? err.message : String(err)));
return 1; return 1;
} }
} }
+17 -17
View File
@@ -1,4 +1,4 @@
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { setSkillEnabled, findSkill } from '@skillkit/core'; import { setSkillEnabled, findSkill } from '@skillkit/core';
import { getSearchDirs } from '../helpers.js'; import { getSearchDirs } from '../helpers.js';
@@ -18,36 +18,36 @@ export class EnableCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
const searchDirs = getSearchDirs(); const searchDirs = getSearchDirs();
let success = 0; let successCount = 0;
let failed = 0; let failed = 0;
for (const skillName of this.skills) { for (const skillName of this.skills) {
const skill = findSkill(skillName, searchDirs); const skill = findSkill(skillName, searchDirs);
if (!skill) { if (!skill) {
console.log(chalk.red(`Skill not found: ${skillName}`)); error(`Skill not found: ${skillName}`);
failed++; failed++;
continue; continue;
} }
if (skill.enabled) { if (skill.enabled) {
console.log(chalk.dim(`Already enabled: ${skillName}`)); console.log(colors.muted(`Already enabled: ${skillName}`));
continue; continue;
} }
const result = setSkillEnabled(skill.path, true); const result = setSkillEnabled(skill.path, true);
if (result) { if (result) {
console.log(chalk.green(`Enabled: ${skillName}`)); success(`Enabled: ${skillName}`);
success++; successCount++;
} else { } else {
console.log(chalk.red(`Failed to enable: ${skillName}`)); error(`Failed to enable: ${skillName}`);
failed++; failed++;
} }
} }
if (success > 0) { if (successCount > 0) {
console.log(chalk.dim('\nRun `skillkit sync` to update your agent config')); console.log(colors.muted('\nRun `skillkit sync` to update your agent config'));
} }
return failed > 0 ? 1 : 0; return failed > 0 ? 1 : 0;
@@ -69,36 +69,36 @@ export class DisableCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
const searchDirs = getSearchDirs(); const searchDirs = getSearchDirs();
let success = 0; let successCount = 0;
let failed = 0; let failed = 0;
for (const skillName of this.skills) { for (const skillName of this.skills) {
const skill = findSkill(skillName, searchDirs); const skill = findSkill(skillName, searchDirs);
if (!skill) { if (!skill) {
console.log(chalk.red(`Skill not found: ${skillName}`)); error(`Skill not found: ${skillName}`);
failed++; failed++;
continue; continue;
} }
if (!skill.enabled) { if (!skill.enabled) {
console.log(chalk.dim(`Already disabled: ${skillName}`)); console.log(colors.muted(`Already disabled: ${skillName}`));
continue; continue;
} }
const result = setSkillEnabled(skill.path, false); const result = setSkillEnabled(skill.path, false);
if (result) { if (result) {
console.log(chalk.yellow(`Disabled: ${skillName}`)); warn(`Disabled: ${skillName}`);
success++; successCount++;
} else { } else {
console.log(chalk.red(`Failed to disable: ${skillName}`)); error(`Failed to disable: ${skillName}`);
failed++; failed++;
} }
} }
if (success > 0) { if (successCount > 0) {
console.log(chalk.dim('\nRun `skillkit sync` to update your agent config')); console.log(colors.muted('\nRun `skillkit sync` to update your agent config'));
} }
return failed > 0 ? 1 : 0; return failed > 0 ? 1 : 0;
+19 -4
View File
@@ -13,7 +13,7 @@ import {
GitHubSkillRegistry, GitHubSkillRegistry,
SkillsShRegistry, SkillsShRegistry,
} from "@skillkit/core"; } from "@skillkit/core";
import { formatCount } from "../helpers.js"; import { formatCount, loadTaps } from "../helpers.js";
interface SkillResult { interface SkillResult {
name: string; name: string;
@@ -60,8 +60,9 @@ export class FindCommand extends Command {
description: "Minimal output (just list skills)", description: "Minimal output (just list skills)",
}); });
federated = Option.Boolean("--federated,-f", false, { federated = Option.Boolean("--federated,-f", true, {
description: "Search external registries (GitHub SKILL.md files)", description: "Search external registries (enabled by default)",
hidden: true,
}); });
async execute(): Promise<number> { async execute(): Promise<number> {
@@ -86,6 +87,20 @@ export class FindCommand extends Command {
}), }),
); );
const taps = loadTaps();
for (const tap of taps.taps) {
const tapLabel = tap.name || tap.source;
const exists = allSkills.some((s) => s.source === tap.source);
if (!exists) {
allSkills.push({
name: tapLabel,
description: `Custom tap: ${tap.source}`,
source: tap.source,
repoName: tap.source.split("/").pop() || "",
});
}
}
let results: SkillResult[]; let results: SkillResult[];
let searchTerm: string | undefined; let searchTerm: string | undefined;
@@ -246,7 +261,7 @@ export class FindCommand extends Command {
); );
console.log( console.log(
colors.muted( colors.muted(
" skillkit find -f <query> # Also search GitHub SKILL.md files", " skillkit find <query> # Search marketplace + GitHub",
), ),
); );
console.log(colors.muted(" skillkit ui # Browse in TUI")); console.log(colors.muted(" skillkit ui # Browse in TUI"));
+5 -2
View File
@@ -33,7 +33,7 @@ export class GenerateCommand extends Command {
['Interactive wizard', '$0 generate'], ['Interactive wizard', '$0 generate'],
['Use specific provider', '$0 generate --provider openai'], ['Use specific provider', '$0 generate --provider openai'],
['Compose from existing skills', '$0 generate --compose "testing patterns for vitest"'], ['Compose from existing skills', '$0 generate --compose "testing patterns for vitest"'],
['Target specific agents', '$0 generate --agents claude-code,cursor'], ['Target specific agents', '$0 generate --agent claude-code,cursor'],
['Skip memory context', '$0 generate --no-memory'], ['Skip memory context', '$0 generate --no-memory'],
], ],
}); });
@@ -50,7 +50,7 @@ export class GenerateCommand extends Command {
description: 'Natural language search to find skills to compose', description: 'Natural language search to find skills to compose',
}); });
agents = Option.String('--agents,-a', { agents = Option.String('--agent,--agents,-a', {
description: 'Target agents (comma-separated)', description: 'Target agents (comma-separated)',
}); });
@@ -536,6 +536,9 @@ ${trustScore.warnings.length > 0 ? `\nWarnings:\n${trustScore.warnings.map((w) =
let targetAgents: string[]; let targetAgents: string[];
if (this.agents) { if (this.agents) {
if (process.argv.includes('--agents')) {
console.warn('Warning: --agents is deprecated, use --agent instead (--agents will be removed in v2.0)');
}
targetAgents = this.agents.split(',').map((a) => a.trim()); targetAgents = this.agents.split(',').map((a) => a.trim());
} else { } else {
const agentOptions = [ const agentOptions = [
+25 -25
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { import {
getAllGuidelines, getAllGuidelines,
getEnabledGuidelines, getEnabledGuidelines,
@@ -31,7 +31,7 @@ export class GuidelineCommand extends Command {
}); });
async execute(): Promise<number> { async execute(): Promise<number> {
console.log(chalk.cyan('Guideline commands:\n')); console.log(colors.cyan('Guideline commands:\n'));
console.log(' guideline list List all guidelines'); console.log(' guideline list List all guidelines');
console.log(' guideline show <id> Show guideline content'); console.log(' guideline show <id> Show guideline content');
console.log(' guideline enable Enable a guideline'); console.log(' guideline enable Enable a guideline');
@@ -70,7 +70,7 @@ export class GuidelineListCommand extends Command {
} }
const title = this.enabled ? 'Enabled Guidelines' : 'All Guidelines'; const title = this.enabled ? 'Enabled Guidelines' : 'All Guidelines';
console.log(chalk.cyan(`${title} (${guidelines.length}):\n`)); console.log(colors.cyan(`${title} (${guidelines.length}):\n`));
const byCategory = new Map<GuidelineCategory, Guideline[]>(); const byCategory = new Map<GuidelineCategory, Guideline[]>();
for (const guideline of guidelines) { for (const guideline of guidelines) {
@@ -81,22 +81,22 @@ export class GuidelineListCommand extends Command {
} }
for (const [category, catGuidelines] of byCategory) { for (const [category, catGuidelines] of byCategory) {
console.log(chalk.blue(` ${formatCategoryName(category)}`)); console.log(colors.info(` ${formatCategoryName(category)}`));
for (const guideline of catGuidelines) { for (const guideline of catGuidelines) {
const enabled = isGuidelineEnabled(guideline.id); const enabled = isGuidelineEnabled(guideline.id);
const status = enabled ? chalk.green('●') : chalk.dim('○'); const status = enabled ? colors.success('●') : colors.muted('○');
const custom = isBuiltinGuideline(guideline.id) ? '' : chalk.dim(' (custom)'); const custom = isBuiltinGuideline(guideline.id) ? '' : colors.muted(' (custom)');
const priority = chalk.dim(`[${guideline.priority}]`); const priority = colors.muted(`[${guideline.priority}]`);
console.log(` ${status} ${chalk.bold(guideline.id)} ${priority}${custom}`); console.log(` ${status} ${colors.bold(guideline.id)} ${priority}${custom}`);
console.log(` ${chalk.dim(guideline.description)}`); console.log(` ${colors.muted(guideline.description)}`);
} }
console.log(); console.log();
} }
console.log(chalk.dim('Enable with: skillkit guideline enable <id>')); console.log(colors.muted('Enable with: skillkit guideline enable <id>'));
console.log(chalk.dim('Show content: skillkit guideline show <id>')); console.log(colors.muted('Show content: skillkit guideline show <id>'));
return 0; return 0;
} }
@@ -116,20 +116,20 @@ export class GuidelineShowCommand extends Command {
const guideline = getGuideline(this.id); const guideline = getGuideline(this.id);
if (!guideline) { if (!guideline) {
console.log(chalk.red(`Guideline not found: ${this.id}`)); console.log(colors.error(`Guideline not found: ${this.id}`));
return 1; return 1;
} }
const enabled = isGuidelineEnabled(this.id); const enabled = isGuidelineEnabled(this.id);
const status = enabled ? chalk.green('enabled') : chalk.dim('disabled'); const status = enabled ? colors.success('enabled') : colors.muted('disabled');
console.log(chalk.cyan(`Guideline: ${guideline.name}\n`)); console.log(colors.cyan(`Guideline: ${guideline.name}\n`));
console.log(`ID: ${guideline.id}`); console.log(`ID: ${guideline.id}`);
console.log(`Category: ${guideline.category}`); console.log(`Category: ${guideline.category}`);
console.log(`Priority: ${guideline.priority}`); console.log(`Priority: ${guideline.priority}`);
console.log(`Status: ${status}`); console.log(`Status: ${status}`);
console.log(); console.log();
console.log(chalk.bold('Content:')); console.log(colors.bold('Content:'));
console.log(guideline.content); console.log(guideline.content);
return 0; return 0;
@@ -150,11 +150,11 @@ export class GuidelineEnableCommand extends Command {
const success = enableGuideline(this.id); const success = enableGuideline(this.id);
if (!success) { if (!success) {
console.log(chalk.red(`Guideline not found: ${this.id}`)); console.log(colors.error(`Guideline not found: ${this.id}`));
return 1; return 1;
} }
console.log(chalk.green(`✓ Enabled guideline: ${this.id}`)); console.log(colors.success(`✓ Enabled guideline: ${this.id}`));
return 0; return 0;
} }
} }
@@ -173,11 +173,11 @@ export class GuidelineDisableCommand extends Command {
const success = disableGuideline(this.id); const success = disableGuideline(this.id);
if (!success) { if (!success) {
console.log(chalk.yellow(`Guideline not found or already disabled: ${this.id}`)); console.log(colors.warning(`Guideline not found or already disabled: ${this.id}`));
return 0; return 0;
} }
console.log(chalk.green(`✓ Disabled guideline: ${this.id}`)); console.log(colors.success(`✓ Disabled guideline: ${this.id}`));
return 0; return 0;
} }
} }
@@ -216,7 +216,7 @@ export class GuidelineCreateCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (isBuiltinGuideline(this.id)) { if (isBuiltinGuideline(this.id)) {
console.log(chalk.red(`Cannot create: ${this.id} is a built-in guideline`)); console.log(colors.error(`Cannot create: ${this.id} is a built-in guideline`));
return 1; return 1;
} }
@@ -234,8 +234,8 @@ export class GuidelineCreateCommand extends Command {
addCustomGuideline(guideline); addCustomGuideline(guideline);
enableGuideline(this.id); enableGuideline(this.id);
console.log(chalk.green(`✓ Created guideline: ${this.id}`)); console.log(colors.success(`✓ Created guideline: ${this.id}`));
console.log(chalk.dim('Edit ~/.skillkit/guidelines.yaml to customize content')); console.log(colors.muted('Edit ~/.skillkit/guidelines.yaml to customize content'));
return 0; return 0;
} }
@@ -253,18 +253,18 @@ export class GuidelineRemoveCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (isBuiltinGuideline(this.id)) { if (isBuiltinGuideline(this.id)) {
console.log(chalk.red(`Cannot remove built-in guideline: ${this.id}`)); console.log(colors.error(`Cannot remove built-in guideline: ${this.id}`));
return 1; return 1;
} }
const removed = removeCustomGuideline(this.id); const removed = removeCustomGuideline(this.id);
if (!removed) { if (!removed) {
console.log(chalk.yellow(`Guideline not found: ${this.id}`)); console.log(colors.warning(`Guideline not found: ${this.id}`));
return 1; return 1;
} }
console.log(chalk.green(`✓ Removed guideline: ${this.id}`)); console.log(colors.success(`✓ Removed guideline: ${this.id}`));
return 0; return 0;
} }
} }
+3 -3
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { writeFileSync } from 'node:fs'; import { writeFileSync } from 'node:fs';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { SessionHandoff } from '@skillkit/core'; import { SessionHandoff } from '@skillkit/core';
export class SessionHandoffCommand extends Command { export class SessionHandoffCommand extends Command {
@@ -41,9 +41,9 @@ export class SessionHandoffCommand extends Command {
if (this.out) { if (this.out) {
try { try {
writeFileSync(this.out, output, 'utf-8'); writeFileSync(this.out, output, 'utf-8');
console.log(chalk.green(`Handoff saved to ${this.out}`)); console.log(colors.success(`Handoff saved to ${this.out}`));
} catch (error) { } catch (error) {
console.error(chalk.red(`Failed to write file: ${(error as Error).message}`)); console.error(colors.error(`Failed to write file: ${(error as Error).message}`));
return 1; return 1;
} }
} else { } else {
+41 -41
View File
@@ -5,7 +5,7 @@
*/ */
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { createHookManager, type HookEvent, type InjectionMode } from '@skillkit/core'; import { createHookManager, type HookEvent, type InjectionMode } from '@skillkit/core';
import { import {
getHookTemplates, getHookTemplates,
@@ -60,12 +60,12 @@ export class HookCommand extends Command {
case 'info': case 'info':
return await this.showHookInfo(projectPath); return await this.showHookInfo(projectPath);
default: default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`)); this.context.stderr.write(colors.error(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: list, add, remove, enable, disable, generate, info\n'); this.context.stderr.write('Available actions: list, add, remove, enable, disable, generate, info\n');
return 1; return 1;
} }
} catch (err) { } catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`)); this.context.stderr.write(colors.error(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1; return 1;
} }
} }
@@ -76,11 +76,11 @@ export class HookCommand extends Command {
if (hooks.length === 0) { if (hooks.length === 0) {
this.context.stdout.write('No hooks configured.\n'); this.context.stdout.write('No hooks configured.\n');
this.context.stdout.write(chalk.gray('Run `skillkit hook add <event> <skill>` to add a hook.\n')); this.context.stdout.write(colors.muted('Run `skillkit hook add <event> <skill>` to add a hook.\n'));
return 0; return 0;
} }
this.context.stdout.write(chalk.cyan('Configured Hooks:\n\n')); this.context.stdout.write(colors.cyan('Configured Hooks:\n\n'));
// Group by event // Group by event
const eventGroups = new Map<string, typeof hooks>(); const eventGroups = new Map<string, typeof hooks>();
@@ -91,15 +91,15 @@ export class HookCommand extends Command {
} }
for (const [event, eventHooks] of eventGroups) { for (const [event, eventHooks] of eventGroups) {
this.context.stdout.write(chalk.yellow(`${event}:\n`)); this.context.stdout.write(colors.warning(`${event}:\n`));
for (const hook of eventHooks) { for (const hook of eventHooks) {
const status = hook.enabled ? chalk.green('●') : chalk.gray('○'); const status = hook.enabled ? colors.success('●') : colors.muted('○');
this.context.stdout.write(` ${status} ${chalk.white(hook.id.slice(0, 8))} → ${hook.skills.join(', ')}\n`); this.context.stdout.write(` ${status} ${colors.primary(hook.id.slice(0, 8))} → ${hook.skills.join(', ')}\n`);
if (hook.matcher) { if (hook.matcher) {
this.context.stdout.write(chalk.gray(` Pattern: ${hook.matcher}\n`)); this.context.stdout.write(colors.muted(` Pattern: ${hook.matcher}\n`));
} }
if (this.verbose) { if (this.verbose) {
this.context.stdout.write(chalk.gray(` Inject: ${hook.inject}, Priority: ${hook.priority || 0}\n`)); this.context.stdout.write(colors.muted(` Inject: ${hook.inject}, Priority: ${hook.priority || 0}\n`));
} }
} }
} }
@@ -110,14 +110,14 @@ export class HookCommand extends Command {
private async addHook(projectPath: string): Promise<number> { private async addHook(projectPath: string): Promise<number> {
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Event type required.\n')); this.context.stderr.write(colors.error('Event type required.\n'));
this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n'); this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n');
this.context.stderr.write('Events: session:start, session:end, file:save, file:open, task:start, commit:pre, commit:post, error:occur, test:fail, build:fail\n'); this.context.stderr.write('Events: session:start, session:end, file:save, file:open, task:start, commit:pre, commit:post, error:occur, test:fail, build:fail\n');
return 1; return 1;
} }
if (!this.skill) { if (!this.skill) {
this.context.stderr.write(chalk.red('Skill name required.\n')); this.context.stderr.write(colors.error('Skill name required.\n'));
this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n'); this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n');
return 1; return 1;
} }
@@ -133,7 +133,7 @@ export class HookCommand extends Command {
]; ];
if (!validEvents.includes(event)) { if (!validEvents.includes(event)) {
this.context.stderr.write(chalk.red(`Invalid event: ${this.target}\n`)); this.context.stderr.write(colors.error(`Invalid event: ${this.target}\n`));
this.context.stderr.write(`Valid events: ${validEvents.join(', ')}\n`); this.context.stderr.write(`Valid events: ${validEvents.join(', ')}\n`);
return 1; return 1;
} }
@@ -151,7 +151,7 @@ export class HookCommand extends Command {
manager.save(); manager.save();
this.context.stdout.write(chalk.green(`✓ Hook added: ${hook.id.slice(0, 8)}\n`)); this.context.stdout.write(colors.success(`✓ Hook added: ${hook.id.slice(0, 8)}\n`));
this.context.stdout.write(` Event: ${event}\n`); this.context.stdout.write(` Event: ${event}\n`);
this.context.stdout.write(` Skill: ${this.skill}\n`); this.context.stdout.write(` Skill: ${this.skill}\n`);
if (this.pattern) { if (this.pattern) {
@@ -163,7 +163,7 @@ export class HookCommand extends Command {
private async removeHook(projectPath: string): Promise<number> { private async removeHook(projectPath: string): Promise<number> {
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n')); this.context.stderr.write(colors.error('Hook ID required.\n'));
this.context.stderr.write('Usage: skillkit hook remove <hook-id>\n'); this.context.stderr.write('Usage: skillkit hook remove <hook-id>\n');
return 1; return 1;
} }
@@ -174,20 +174,20 @@ export class HookCommand extends Command {
// Find hook by ID prefix // Find hook by ID prefix
const hook = hooks.find((h) => h.id.startsWith(this.target!)); const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) { if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`)); this.context.stderr.write(colors.error(`Hook not found: ${this.target}\n`));
return 1; return 1;
} }
manager.unregisterHook(hook.id); manager.unregisterHook(hook.id);
manager.save(); manager.save();
this.context.stdout.write(chalk.green(`✓ Hook removed: ${hook.id.slice(0, 8)}\n`)); this.context.stdout.write(colors.success(`✓ Hook removed: ${hook.id.slice(0, 8)}\n`));
return 0; return 0;
} }
private async enableHook(projectPath: string): Promise<number> { private async enableHook(projectPath: string): Promise<number> {
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n')); this.context.stderr.write(colors.error('Hook ID required.\n'));
return 1; return 1;
} }
@@ -196,20 +196,20 @@ export class HookCommand extends Command {
const hook = hooks.find((h) => h.id.startsWith(this.target!)); const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) { if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`)); this.context.stderr.write(colors.error(`Hook not found: ${this.target}\n`));
return 1; return 1;
} }
manager.enableHook(hook.id); manager.enableHook(hook.id);
manager.save(); manager.save();
this.context.stdout.write(chalk.green(`✓ Hook enabled: ${hook.id.slice(0, 8)}\n`)); this.context.stdout.write(colors.success(`✓ Hook enabled: ${hook.id.slice(0, 8)}\n`));
return 0; return 0;
} }
private async disableHook(projectPath: string): Promise<number> { private async disableHook(projectPath: string): Promise<number> {
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n')); this.context.stderr.write(colors.error('Hook ID required.\n'));
return 1; return 1;
} }
@@ -218,14 +218,14 @@ export class HookCommand extends Command {
const hook = hooks.find((h) => h.id.startsWith(this.target!)); const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) { if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`)); this.context.stderr.write(colors.error(`Hook not found: ${this.target}\n`));
return 1; return 1;
} }
manager.disableHook(hook.id); manager.disableHook(hook.id);
manager.save(); manager.save();
this.context.stdout.write(chalk.yellow(`○ Hook disabled: ${hook.id.slice(0, 8)}\n`)); this.context.stdout.write(colors.warning(`○ Hook disabled: ${hook.id.slice(0, 8)}\n`));
return 0; return 0;
} }
@@ -241,7 +241,7 @@ export class HookCommand extends Command {
const agent = this.agent || 'claude-code'; const agent = this.agent || 'claude-code';
const generated = manager.generateAgentHooks(agent as any); const generated = manager.generateAgentHooks(agent as any);
this.context.stdout.write(chalk.cyan(`Generated hooks for ${agent}:\n\n`)); this.context.stdout.write(colors.cyan(`Generated hooks for ${agent}:\n\n`));
if (typeof generated === 'string') { if (typeof generated === 'string') {
this.context.stdout.write(generated); this.context.stdout.write(generated);
@@ -255,7 +255,7 @@ export class HookCommand extends Command {
private async showHookInfo(projectPath: string): Promise<number> { private async showHookInfo(projectPath: string): Promise<number> {
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n')); this.context.stderr.write(colors.error('Hook ID required.\n'));
return 1; return 1;
} }
@@ -264,11 +264,11 @@ export class HookCommand extends Command {
const hook = hooks.find((h) => h.id.startsWith(this.target!)); const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) { if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`)); this.context.stderr.write(colors.error(`Hook not found: ${this.target}\n`));
return 1; return 1;
} }
this.context.stdout.write(chalk.cyan(`\nHook: ${hook.id}\n`)); this.context.stdout.write(colors.cyan(`\nHook: ${hook.id}\n`));
this.context.stdout.write(`Event: ${hook.event}\n`); this.context.stdout.write(`Event: ${hook.event}\n`);
this.context.stdout.write(`Skills: ${hook.skills.join(', ')}\n`); this.context.stdout.write(`Skills: ${hook.skills.join(', ')}\n`);
this.context.stdout.write(`Enabled: ${hook.enabled ? 'Yes' : 'No'}\n`); this.context.stdout.write(`Enabled: ${hook.enabled ? 'Yes' : 'No'}\n`);
@@ -317,7 +317,7 @@ export class HookTemplateListCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan(`Hook Templates (${templates.length}):\n`)); console.log(colors.cyan(`Hook Templates (${templates.length}):\n`));
const byCategory = new Map<HookTemplateCategory, HookTemplate[]>(); const byCategory = new Map<HookTemplateCategory, HookTemplate[]>();
for (const template of templates) { for (const template of templates) {
@@ -328,17 +328,17 @@ export class HookTemplateListCommand extends Command {
} }
for (const [category, catTemplates] of byCategory) { for (const [category, catTemplates] of byCategory) {
console.log(chalk.blue(` ${formatCategory(category)}`)); console.log(colors.info(` ${formatCategory(category)}`));
for (const template of catTemplates) { for (const template of catTemplates) {
const blocking = template.blocking ? chalk.yellow(' [blocking]') : ''; const blocking = template.blocking ? colors.warning(' [blocking]') : '';
console.log(` ${chalk.bold(template.id)}${blocking}`); console.log(` ${colors.bold(template.id)}${blocking}`);
console.log(` ${chalk.dim(template.description)}`); console.log(` ${colors.muted(template.description)}`);
console.log(` Event: ${template.event}`); console.log(` Event: ${template.event}`);
} }
console.log(); console.log();
} }
console.log(chalk.dim('Apply with: skillkit hook template apply <id>')); console.log(colors.muted('Apply with: skillkit hook template apply <id>'));
return 0; return 0;
} }
@@ -361,8 +361,8 @@ export class HookTemplateApplyCommand extends Command {
const template = getHookTemplate(this.id); const template = getHookTemplate(this.id);
if (!template) { if (!template) {
console.log(chalk.red(`Template not found: ${this.id}`)); console.log(colors.error(`Template not found: ${this.id}`));
console.log(chalk.dim('Run `skillkit hook template list` to see available templates')); console.log(colors.muted('Run `skillkit hook template list` to see available templates'));
return 1; return 1;
} }
@@ -385,12 +385,12 @@ export class HookTemplateApplyCommand extends Command {
manager.save(); manager.save();
console.log(chalk.green(`✓ Applied template: ${template.name}`)); console.log(colors.success(`✓ Applied template: ${template.name}`));
console.log(` Hook ID: ${hook.id.slice(0, 8)}`); console.log(` Hook ID: ${hook.id.slice(0, 8)}`);
console.log(` Event: ${template.event}`); console.log(` Event: ${template.event}`);
console.log(` Command: ${chalk.dim(template.command)}`); console.log(` Command: ${colors.muted(template.command)}`);
if (template.blocking) { if (template.blocking) {
console.log(chalk.yellow(` Blocking: yes`)); console.log(colors.warning(` Blocking: yes`));
} }
return 0; return 0;
@@ -411,11 +411,11 @@ export class HookTemplateShowCommand extends Command {
const template = getHookTemplate(this.id); const template = getHookTemplate(this.id);
if (!template) { if (!template) {
console.log(chalk.red(`Template not found: ${this.id}`)); console.log(colors.error(`Template not found: ${this.id}`));
return 1; return 1;
} }
console.log(chalk.cyan(`Template: ${template.name}\n`)); console.log(colors.cyan(`Template: ${template.name}\n`));
console.log(`ID: ${template.id}`); console.log(`ID: ${template.id}`);
console.log(`Category: ${template.category}`); console.log(`Category: ${template.category}`);
console.log(`Description: ${template.description}`); console.log(`Description: ${template.description}`);
@@ -426,7 +426,7 @@ export class HookTemplateShowCommand extends Command {
console.log(`Blocking: ${template.blocking ? 'yes' : 'no'}`); console.log(`Blocking: ${template.blocking ? 'yes' : 'no'}`);
console.log(`Timeout: ${template.timeout || 30000}ms`); console.log(`Timeout: ${template.timeout || 30000}ms`);
console.log(); console.log();
console.log(chalk.bold('Command:')); console.log(colors.bold('Command:'));
console.log(` ${template.command}`); console.log(` ${template.command}`);
return 0; return 0;
+1
View File
@@ -132,6 +132,7 @@ export { TimelineCommand } from './timeline.js';
export { SessionHandoffCommand } from './handoff.js'; export { SessionHandoffCommand } from './handoff.js';
export { LineageCommand } from './lineage.js'; export { LineageCommand } from './lineage.js';
export { SaveCommand } from './save.js'; export { SaveCommand } from './save.js';
export { TapAddCommand, TapRemoveCommand, TapListCommand } from './tap.js';
export { export {
AgentsMdCommand, AgentsMdCommand,
AgentsMdInitCommand, AgentsMdInitCommand,
File diff suppressed because it is too large Load Diff
+49 -49
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { import {
analyzeGitHistory, analyzeGitHistory,
loadPatternStore, loadPatternStore,
@@ -73,7 +73,7 @@ export class LearnCommand extends Command {
return this.showPatterns(); return this.showPatterns();
} }
console.log(chalk.cyan('Analyzing git history for learnable patterns...\n')); console.log(colors.cyan('Analyzing git history for learnable patterns...\n'));
const result = analyzeGitHistory(projectPath, { const result = analyzeGitHistory(projectPath, {
commits: this.commits ? parseInt(this.commits) : 100, commits: this.commits ? parseInt(this.commits) : 100,
@@ -88,8 +88,8 @@ export class LearnCommand extends Command {
this.printAnalysisResult(result); this.printAnalysisResult(result);
if (result.patterns.length === 0) { if (result.patterns.length === 0) {
console.log(chalk.yellow('\nNo learnable patterns found.')); console.log(colors.warning('\nNo learnable patterns found.'));
console.log(chalk.dim('Try analyzing more commits or a different date range.')); console.log(colors.muted('Try analyzing more commits or a different date range.'));
return 0; return 0;
} }
@@ -105,12 +105,12 @@ export class LearnCommand extends Command {
} }
console.log(); console.log();
console.log(chalk.green(`✓ Extracted ${added} patterns`)); console.log(colors.success(`✓ Extracted ${added} patterns`));
if (!this.approve) { if (!this.approve) {
console.log(chalk.dim('Patterns are pending approval. Use:')); console.log(colors.muted('Patterns are pending approval. Use:'));
console.log(chalk.dim(' skillkit pattern approve <id> - to approve')); console.log(colors.muted(' skillkit pattern approve <id> - to approve'));
console.log(chalk.dim(' skillkit pattern status - to view all')); console.log(colors.muted(' skillkit pattern status - to view all'));
} }
return 0; return 0;
@@ -119,21 +119,21 @@ export class LearnCommand extends Command {
private printAnalysisResult(result: GitAnalysisResult): void { private printAnalysisResult(result: GitAnalysisResult): void {
const { summary, dateRange, languages, frameworks } = result; const { summary, dateRange, languages, frameworks } = result;
console.log(chalk.bold('Analysis Summary')); console.log(colors.bold('Analysis Summary'));
console.log(` Commits analyzed: ${summary.totalCommits}`); console.log(` Commits analyzed: ${summary.totalCommits}`);
console.log(` Files changed: ${summary.totalFilesChanged}`); console.log(` Files changed: ${summary.totalFilesChanged}`);
console.log(` Date range: ${dateRange.from || 'N/A'} to ${dateRange.to || 'N/A'}`); console.log(` Date range: ${dateRange.from || 'N/A'} to ${dateRange.to || 'N/A'}`);
console.log(); console.log();
if (languages.length > 0) { if (languages.length > 0) {
console.log(` Languages: ${chalk.cyan(languages.join(', '))}`); console.log(` Languages: ${colors.cyan(languages.join(', '))}`);
} }
if (frameworks.length > 0) { if (frameworks.length > 0) {
console.log(` Frameworks: ${chalk.cyan(frameworks.join(', '))}`); console.log(` Frameworks: ${colors.cyan(frameworks.join(', '))}`);
} }
console.log(); console.log();
console.log(chalk.bold('Commit Categories')); console.log(colors.bold('Commit Categories'));
console.log(` Error fixes: ${summary.errorFixes}`); console.log(` Error fixes: ${summary.errorFixes}`);
console.log(` Refactors: ${summary.refactors}`); console.log(` Refactors: ${summary.refactors}`);
console.log(` Features: ${summary.features}`); console.log(` Features: ${summary.features}`);
@@ -141,15 +141,15 @@ export class LearnCommand extends Command {
console.log(` Tests: ${summary.tests}`); console.log(` Tests: ${summary.tests}`);
console.log(); console.log();
console.log(chalk.bold(`Patterns Extracted: ${result.patterns.length}`)); console.log(colors.bold(`Patterns Extracted: ${result.patterns.length}`));
for (const pattern of result.patterns.slice(0, 5)) { for (const pattern of result.patterns.slice(0, 5)) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`); const confidence = colors.info(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} [${pattern.category}] ${confidence}`); console.log(` ${colors.muted('○')} ${pattern.title} [${pattern.category}] ${confidence}`);
} }
if (result.patterns.length > 5) { if (result.patterns.length > 5) {
console.log(chalk.dim(` ... and ${result.patterns.length - 5} more`)); console.log(colors.muted(` ... and ${result.patterns.length - 5} more`));
} }
} }
@@ -162,18 +162,18 @@ export class LearnCommand extends Command {
} }
if (patterns.length === 0) { if (patterns.length === 0) {
console.log(chalk.yellow('No patterns stored yet.')); console.log(colors.warning('No patterns stored yet.'));
console.log(chalk.dim('Run `skillkit learn` to extract patterns from git history.')); console.log(colors.muted('Run `skillkit learn` to extract patterns from git history.'));
return 0; return 0;
} }
console.log(chalk.cyan(`Stored Patterns (${patterns.length}):\n`)); console.log(colors.cyan(`Stored Patterns (${patterns.length}):\n`));
const approved = patterns.filter(p => p.approved); const approved = patterns.filter(p => p.approved);
const pending = patterns.filter(p => !p.approved); const pending = patterns.filter(p => !p.approved);
if (approved.length > 0) { if (approved.length > 0) {
console.log(chalk.green('Approved:')); console.log(colors.success('Approved:'));
for (const pattern of approved) { for (const pattern of approved) {
this.printPattern(pattern); this.printPattern(pattern);
} }
@@ -181,7 +181,7 @@ export class LearnCommand extends Command {
} }
if (pending.length > 0) { if (pending.length > 0) {
console.log(chalk.yellow('Pending Approval:')); console.log(colors.warning('Pending Approval:'));
for (const pattern of pending) { for (const pattern of pending) {
this.printPattern(pattern); this.printPattern(pattern);
} }
@@ -191,11 +191,11 @@ export class LearnCommand extends Command {
} }
private printPattern(pattern: LearnedPattern): void { private printPattern(pattern: LearnedPattern): void {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`); const confidence = colors.info(`${(pattern.confidence * 100).toFixed(0)}%`);
const status = pattern.approved ? chalk.green('✓') : chalk.yellow('○'); const status = pattern.approved ? colors.success('✓') : colors.warning('○');
console.log(` ${status} ${chalk.bold(pattern.id)}`); console.log(` ${status} ${colors.bold(pattern.id)}`);
console.log(` ${pattern.title} [${pattern.category}] ${confidence}`); console.log(` ${pattern.title} [${pattern.category}] ${confidence}`);
console.log(chalk.dim(` ${truncate(pattern.problem, 60)}`)); console.log(colors.muted(` ${truncate(pattern.problem, 60)}`));
} }
} }
@@ -226,18 +226,18 @@ export class PatternStatusCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan('Pattern Statistics\n')); console.log(colors.cyan('Pattern Statistics\n'));
console.log(`Total patterns: ${stats.total}`); console.log(`Total patterns: ${stats.total}`);
console.log(); console.log();
console.log(chalk.bold('By Confidence:')); console.log(colors.bold('By Confidence:'));
console.log(` High (>70%): ${stats.byConfidenceRange.high}`); console.log(` High (>70%): ${stats.byConfidenceRange.high}`);
console.log(` Medium (40-70%): ${stats.byConfidenceRange.medium}`); console.log(` Medium (40-70%): ${stats.byConfidenceRange.medium}`);
console.log(` Low (<40%): ${stats.byConfidenceRange.low}`); console.log(` Low (<40%): ${stats.byConfidenceRange.low}`);
console.log(); console.log();
if (stats.byDomain.size > 0) { if (stats.byDomain.size > 0) {
console.log(chalk.bold('By Domain:')); console.log(colors.bold('By Domain:'));
for (const [domain, count] of stats.byDomain) { for (const [domain, count] of stats.byDomain) {
console.log(` ${domain}: ${count}`); console.log(` ${domain}: ${count}`);
} }
@@ -245,7 +245,7 @@ export class PatternStatusCommand extends Command {
} }
if (stats.mostUsed) { if (stats.mostUsed) {
console.log(chalk.bold('Most Used Pattern:')); console.log(colors.bold('Most Used Pattern:'));
console.log(` ${stats.mostUsed.title} (${stats.mostUsed.useCount} uses)`); console.log(` ${stats.mostUsed.title} (${stats.mostUsed.useCount} uses)`);
} }
@@ -276,7 +276,7 @@ export class PatternFeedbackCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (!this.success && !this.failure) { if (!this.success && !this.failure) {
console.log(chalk.yellow('Please specify --success or --failure')); console.log(colors.warning('Please specify --success or --failure'));
return 1; return 1;
} }
@@ -285,12 +285,12 @@ export class PatternFeedbackCommand extends Command {
: recordFailure(this.id); : recordFailure(this.id);
if (!result) { if (!result) {
console.log(chalk.red(`Pattern not found: ${this.id}`)); console.log(colors.error(`Pattern not found: ${this.id}`));
return 1; return 1;
} }
const change = result.change === 'increased' ? chalk.green('↑') : chalk.red('↓'); const change = result.change === 'increased' ? colors.success('↑') : colors.error('↓');
console.log(chalk.green(`✓ Feedback recorded`)); console.log(colors.success(`✓ Feedback recorded`));
console.log(` Confidence: ${(result.previousConfidence * 100).toFixed(0)}% ${change} ${(result.newConfidence * 100).toFixed(0)}%`); console.log(` Confidence: ${(result.previousConfidence * 100).toFixed(0)}% ${change} ${(result.newConfidence * 100).toFixed(0)}%`);
console.log(` Total uses: ${result.pattern.useCount}`); console.log(` Total uses: ${result.pattern.useCount}`);
@@ -312,11 +312,11 @@ export class PatternApproveCommand extends Command {
const pattern = approvePattern(this.id); const pattern = approvePattern(this.id);
if (!pattern) { if (!pattern) {
console.log(chalk.red(`Pattern not found: ${this.id}`)); console.log(colors.error(`Pattern not found: ${this.id}`));
return 1; return 1;
} }
console.log(chalk.green(`✓ Approved: ${pattern.title}`)); console.log(colors.success(`✓ Approved: ${pattern.title}`));
return 0; return 0;
} }
} }
@@ -335,11 +335,11 @@ export class PatternRejectCommand extends Command {
const removed = rejectPattern(this.id); const removed = rejectPattern(this.id);
if (!removed) { if (!removed) {
console.log(chalk.red(`Pattern not found: ${this.id}`)); console.log(colors.error(`Pattern not found: ${this.id}`));
return 1; return 1;
} }
console.log(chalk.green(`✓ Removed pattern: ${this.id}`)); console.log(colors.success(`✓ Removed pattern: ${this.id}`));
return 0; return 0;
} }
} }
@@ -371,7 +371,7 @@ export class PatternExportCommand extends Command {
const patterns = this.approvedOnly ? getApprovedPatterns() : getAllPatterns(); const patterns = this.approvedOnly ? getApprovedPatterns() : getAllPatterns();
if (patterns.length === 0) { if (patterns.length === 0) {
console.log(chalk.yellow('No patterns to export')); console.log(colors.warning('No patterns to export'));
return 0; return 0;
} }
@@ -386,7 +386,7 @@ export class PatternExportCommand extends Command {
if (this.output) { if (this.output) {
writeFileSync(this.output, content); writeFileSync(this.output, content);
console.log(chalk.green(`✓ Exported ${patterns.length} patterns to ${this.output}`)); console.log(colors.success(`✓ Exported ${patterns.length} patterns to ${this.output}`));
} else { } else {
console.log(content); console.log(content);
} }
@@ -407,7 +407,7 @@ export class PatternImportCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (!existsSync(this.file)) { if (!existsSync(this.file)) {
console.log(chalk.red(`File not found: ${this.file}`)); console.log(colors.error(`File not found: ${this.file}`));
return 1; return 1;
} }
@@ -415,7 +415,7 @@ export class PatternImportCommand extends Command {
const patterns = importPatternsFromJson(content); const patterns = importPatternsFromJson(content);
if (patterns.length === 0) { if (patterns.length === 0) {
console.log(chalk.yellow('No patterns found in file')); console.log(colors.warning('No patterns found in file'));
return 1; return 1;
} }
@@ -423,7 +423,7 @@ export class PatternImportCommand extends Command {
addPattern(pattern); addPattern(pattern);
} }
console.log(chalk.green(`✓ Imported ${patterns.length} patterns`)); console.log(colors.success(`✓ Imported ${patterns.length} patterns`));
return 0; return 0;
} }
} }
@@ -451,21 +451,21 @@ export class PatternClusterCommand extends Command {
const patterns = getApprovedPatterns(); const patterns = getApprovedPatterns();
if (patterns.length === 0) { if (patterns.length === 0) {
console.log(chalk.yellow('No approved patterns to cluster')); console.log(colors.warning('No approved patterns to cluster'));
console.log(chalk.dim('Approve patterns first with: skillkit pattern approve <id>')); console.log(colors.muted('Approve patterns first with: skillkit pattern approve <id>'));
return 0; return 0;
} }
const clusters = clusterPatterns(patterns); const clusters = clusterPatterns(patterns);
console.log(chalk.cyan(`Pattern Clusters (${clusters.size}):\n`)); console.log(colors.cyan(`Pattern Clusters (${clusters.size}):\n`));
for (const [category, categoryPatterns] of clusters) { for (const [category, categoryPatterns] of clusters) {
console.log(chalk.bold(`${category.replace('_', ' ')} (${categoryPatterns.length}):`)); console.log(colors.bold(`${category.replace('_', ' ')} (${categoryPatterns.length}):`));
for (const pattern of categoryPatterns) { for (const pattern of categoryPatterns) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`); const confidence = colors.info(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} ${confidence}`); console.log(` ${colors.muted('○')} ${pattern.title} ${confidence}`);
} }
console.log(); console.log();
@@ -476,7 +476,7 @@ export class PatternClusterCommand extends Command {
if (skill) { if (skill) {
const filepath = saveGeneratedSkill(skill); const filepath = saveGeneratedSkill(skill);
console.log(chalk.green(` → Generated skill: ${filepath}`)); console.log(colors.success(` → Generated skill: ${filepath}`));
} }
} }
} }
+3 -3
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { SkillLineage } from '@skillkit/core'; import { SkillLineage } from '@skillkit/core';
export class LineageCommand extends Command { export class LineageCommand extends Command {
@@ -55,8 +55,8 @@ export class LineageCommand extends Command {
} }
if (data.skills.length === 0) { if (data.skills.length === 0) {
console.log(chalk.yellow('No skill lineage found.')); console.log(colors.warning('No skill lineage found.'));
console.log(chalk.dim('Lineage is built from skill execution history and activity logs.')); console.log(colors.muted('Lineage is built from skill execution history and activity logs.'));
return 0; return 0;
} }
+10 -11
View File
@@ -1,8 +1,7 @@
import chalk from 'chalk';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { findAllSkills, evaluateSkillDirectory } from '@skillkit/core'; import { findAllSkills, evaluateSkillDirectory } from '@skillkit/core';
import { getSearchDirs } from '../helpers.js'; import { getSearchDirs } from '../helpers.js';
import { formatQualityBadge, colors } from '../onboarding/index.js'; import { formatQualityBadge, colors, warn } from '../onboarding/index.js';
export class ListCommand extends Command { export class ListCommand extends Command {
static override paths = [['list'], ['ls'], ['l']]; static override paths = [['list'], ['ls'], ['l']];
@@ -65,18 +64,18 @@ export class ListCommand extends Command {
} }
if (skills.length === 0) { if (skills.length === 0) {
console.log(chalk.yellow('No skills installed')); warn('No skills installed');
console.log(chalk.dim('Install skills with: skillkit install <source>')); console.log(colors.muted('Install skills with: skillkit install <source>'));
return 0; return 0;
} }
console.log(chalk.cyan(`Installed skills (${skills.length}):\n`)); console.log(colors.cyan(`Installed skills (${skills.length}):\n`));
const projectSkills = skillsWithQuality.filter(s => s.location === 'project'); const projectSkills = skillsWithQuality.filter(s => s.location === 'project');
const globalSkills = skillsWithQuality.filter(s => s.location === 'global'); const globalSkills = skillsWithQuality.filter(s => s.location === 'global');
if (projectSkills.length > 0) { if (projectSkills.length > 0) {
console.log(chalk.blue('Project skills:')); console.log(colors.info('Project skills:'));
for (const skill of projectSkills) { for (const skill of projectSkills) {
printSkill(skill, this.quality); printSkill(skill, this.quality);
} }
@@ -84,7 +83,7 @@ export class ListCommand extends Command {
} }
if (globalSkills.length > 0) { if (globalSkills.length > 0) {
console.log(chalk.dim('Global skills:')); console.log(colors.muted('Global skills:'));
for (const skill of globalSkills) { for (const skill of globalSkills) {
printSkill(skill, this.quality); printSkill(skill, this.quality);
} }
@@ -95,7 +94,7 @@ export class ListCommand extends Command {
const disabledCount = skills.length - enabledCount; const disabledCount = skills.length - enabledCount;
console.log( console.log(
chalk.dim( colors.muted(
`${projectSkills.length} project, ${globalSkills.length} global` + `${projectSkills.length} project, ${globalSkills.length} global` +
(disabledCount > 0 ? `, ${disabledCount} disabled` : '') (disabledCount > 0 ? `, ${disabledCount} disabled` : '')
) )
@@ -117,9 +116,9 @@ function printSkill(
skill: { name: string; description: string; enabled: boolean; location: string; quality: number | null }, skill: { name: string; description: string; enabled: boolean; location: string; quality: number | null },
showQuality = false showQuality = false
) { ) {
const status = skill.enabled ? chalk.green('✓') : chalk.red('○'); const status = skill.enabled ? colors.success('✓') : colors.error('○');
const name = skill.enabled ? skill.name : chalk.dim(skill.name); const name = skill.enabled ? skill.name : colors.muted(skill.name);
const desc = chalk.dim(truncate(skill.description, 50)); const desc = colors.muted(truncate(skill.description, 50));
const qualityBadge = showQuality && skill.quality !== null ? ` ${formatQualityBadge(skill.quality)}` : ''; const qualityBadge = showQuality && skill.quality !== null ? ` ${formatQualityBadge(skill.quality)}` : '';
console.log(` ${status} ${name}${qualityBadge}`); console.log(` ${status} ${name}${qualityBadge}`);
+4 -1
View File
@@ -147,7 +147,7 @@ export class ManifestAddCommand extends Command {
description: 'Specific skills to include (comma-separated)', description: 'Specific skills to include (comma-separated)',
}); });
agents = Option.String('--agents,-a', { agents = Option.String('--agent,--agents,-a', {
description: 'Target agents (comma-separated)', description: 'Target agents (comma-separated)',
}); });
@@ -159,6 +159,9 @@ export class ManifestAddCommand extends Command {
} }
if (this.agents) { if (this.agents) {
if (process.argv.includes('--agents')) {
console.warn('Warning: --agents is deprecated, use --agent instead (--agents will be removed in v2.0)');
}
options.agents = this.agents.split(',').map(s => s.trim()); options.agents = this.agents.split(',').map(s => s.trim());
} }
+119 -119
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, error, warn } from '../onboarding/index.js';
import { import {
ObservationStore, ObservationStore,
LearningStore, LearningStore,
@@ -158,8 +158,8 @@ export class MemoryCommand extends Command {
case 'index': case 'index':
return this.showIndex(); return this.showIndex();
default: default:
console.error(chalk.red(`Unknown action: ${action}`)); error(`Unknown action: ${action}`);
console.log(chalk.gray('Available actions: status, search, list, show, compress, export, import, clear, add, rate, sync-claude, index, config')); console.log(colors.muted('Available actions: status, search, list, show, compress, export, import, clear, add, rate, sync-claude, index, config'));
return 1; return 1;
} }
} }
@@ -194,32 +194,32 @@ export class MemoryCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nMemory Status\n')); console.log(colors.bold('\nMemory Status\n'));
// Session observations // Session observations
console.log(chalk.cyan('Session:')); console.log(colors.cyan('Session:'));
console.log(` Observations: ${sessionObservations}`); console.log(` Observations: ${sessionObservations}`);
if (sessionId) { if (sessionId) {
console.log(` Session ID: ${chalk.gray(sessionId.slice(0, 8))}`); console.log(` Session ID: ${colors.muted(sessionId.slice(0, 8))}`);
} }
console.log(); console.log();
// Project learnings // Project learnings
console.log(chalk.cyan('Project:')); console.log(colors.cyan('Project:'));
console.log(` Learnings: ${projectLearnings}`); console.log(` Learnings: ${projectLearnings}`);
console.log(` Path: ${chalk.gray(status.projectMemoryExists ? paths.projectMemoryDir : 'Not initialized')}`); console.log(` Path: ${colors.muted(status.projectMemoryExists ? paths.projectMemoryDir : 'Not initialized')}`);
console.log(); console.log();
// Global learnings // Global learnings
console.log(chalk.cyan('Global:')); console.log(colors.cyan('Global:'));
console.log(` Learnings: ${globalLearnings}`); console.log(` Learnings: ${globalLearnings}`);
console.log(` Path: ${chalk.gray(status.globalMemoryExists ? paths.globalMemoryDir : 'Not initialized')}`); console.log(` Path: ${colors.muted(status.globalMemoryExists ? paths.globalMemoryDir : 'Not initialized')}`);
console.log(); console.log();
// Recommendations // Recommendations
if (sessionObservations >= 50) { if (sessionObservations >= 50) {
console.log(chalk.yellow('💡 You have many uncompressed observations. Consider running:')); warn('💡 You have many uncompressed observations. Consider running:');
console.log(chalk.gray(' skillkit memory compress')); console.log(colors.muted(' skillkit memory compress'));
} }
return 0; return 0;
@@ -231,8 +231,8 @@ export class MemoryCommand extends Command {
private async searchMemories(): Promise<number> { private async searchMemories(): Promise<number> {
const query = this.arg; const query = this.arg;
if (!query) { if (!query) {
console.error(chalk.red('Error: Search query is required')); error('Error: Search query is required');
console.log(chalk.gray('Usage: skillkit memory search "your query"')); console.log(colors.muted('Usage: skillkit memory search "your query"'));
return 1; return 1;
} }
@@ -244,7 +244,7 @@ export class MemoryCommand extends Command {
if (this.limit) { if (this.limit) {
const parsed = parseInt(this.limit, 10); const parsed = parseInt(this.limit, 10);
if (isNaN(parsed) || parsed <= 0) { if (isNaN(parsed) || parsed <= 0) {
console.log(chalk.red('Invalid --limit value. Must be a positive number.')); console.log(colors.error('Invalid --limit value. Must be a positive number.'));
return 1; return 1;
} }
maxLearnings = parsed; maxLearnings = parsed;
@@ -269,15 +269,15 @@ export class MemoryCommand extends Command {
} }
if (results.length === 0) { if (results.length === 0) {
console.log(chalk.yellow(`No memories found for: "${query}"`)); console.log(colors.warning(`No memories found for: "${query}"`));
return 0; return 0;
} }
console.log(chalk.bold(`\nFound ${results.length} memories:\n`)); console.log(colors.bold(`\nFound ${results.length} memories:\n`));
for (const { learning, relevanceScore, matchedBy } of results) { for (const { learning, relevanceScore, matchedBy } of results) {
console.log(`${chalk.cyan('●')} ${chalk.bold(learning.title)}`); console.log(`${colors.cyan('●')} ${colors.bold(learning.title)}`);
console.log(` ID: ${chalk.gray(learning.id.slice(0, 8))}`); console.log(` ID: ${colors.muted(learning.id.slice(0, 8))}`);
console.log(` Relevance: ${this.formatScore(relevanceScore)}%`); console.log(` Relevance: ${this.formatScore(relevanceScore)}%`);
console.log(` Tags: ${learning.tags.join(', ')}`); console.log(` Tags: ${learning.tags.join(', ')}`);
console.log(` Scope: ${learning.scope}`); console.log(` Scope: ${learning.scope}`);
@@ -290,7 +290,7 @@ export class MemoryCommand extends Command {
// Show excerpt // Show excerpt
const excerpt = learning.content.slice(0, 100); const excerpt = learning.content.slice(0, 100);
console.log(` ${chalk.gray(excerpt)}${learning.content.length > 100 ? '...' : ''}`); console.log(` ${colors.muted(excerpt)}${learning.content.length > 100 ? '...' : ''}`);
console.log(); console.log();
} }
@@ -327,12 +327,12 @@ export class MemoryCommand extends Command {
} }
const scope = this.global ? 'Global' : 'Project'; const scope = this.global ? 'Global' : 'Project';
console.log(chalk.bold(`\n${scope} Learnings (${learnings.length}):\n`)); console.log(colors.bold(`\n${scope} Learnings (${learnings.length}):\n`));
if (learnings.length === 0) { if (learnings.length === 0) {
console.log(chalk.gray('No learnings found.')); console.log(colors.muted('No learnings found.'));
console.log(chalk.gray('\nCapture learnings by running skills or add manually:')); console.log(colors.muted('\nCapture learnings by running skills or add manually:'));
console.log(chalk.gray(' skillkit memory add --title "..." --content "..."')); console.log(colors.muted(' skillkit memory add --title "..." --content "..."'));
return 0; return 0;
} }
@@ -341,12 +341,12 @@ export class MemoryCommand extends Command {
? ` [${this.formatScore(learning.effectiveness)}%]` ? ` [${this.formatScore(learning.effectiveness)}%]`
: ''; : '';
console.log(`${chalk.cyan('●')} ${learning.title}${chalk.green(effectiveness)}`); console.log(`${colors.cyan('●')} ${learning.title}${colors.success(effectiveness)}`);
console.log(` ${chalk.gray(learning.id.slice(0, 8))} | ${learning.tags.join(', ')} | ${learning.useCount} uses`); console.log(` ${colors.muted(learning.id.slice(0, 8))} | ${learning.tags.join(', ')} | ${learning.useCount} uses`);
if (this.verbose) { if (this.verbose) {
const excerpt = learning.content.slice(0, 80); const excerpt = learning.content.slice(0, 80);
console.log(` ${chalk.gray(excerpt)}${learning.content.length > 80 ? '...' : ''}`); console.log(` ${colors.muted(excerpt)}${learning.content.length > 80 ? '...' : ''}`);
} }
} }
@@ -360,8 +360,8 @@ export class MemoryCommand extends Command {
private async showLearning(): Promise<number> { private async showLearning(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Learning ID is required')); error('Error: Learning ID is required');
console.log(chalk.gray('Usage: skillkit memory show <id>')); console.log(colors.muted('Usage: skillkit memory show <id>'));
return 1; return 1;
} }
@@ -385,7 +385,7 @@ export class MemoryCommand extends Command {
} }
if (!learning) { if (!learning) {
console.error(chalk.red(`Learning not found: ${id}`)); error(`Learning not found: ${id}`);
return 1; return 1;
} }
@@ -394,29 +394,29 @@ export class MemoryCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold(`\n${learning.title}\n`)); console.log(colors.bold(`\n${learning.title}\n`));
console.log(chalk.gray(`ID: ${learning.id}`)); console.log(colors.muted(`ID: ${learning.id}`));
console.log(chalk.gray(`Scope: ${learning.scope}`)); console.log(colors.muted(`Scope: ${learning.scope}`));
console.log(chalk.gray(`Source: ${learning.source}`)); console.log(colors.muted(`Source: ${learning.source}`));
console.log(chalk.gray(`Tags: ${learning.tags.join(', ')}`)); console.log(colors.muted(`Tags: ${learning.tags.join(', ')}`));
if (learning.frameworks?.length) { if (learning.frameworks?.length) {
console.log(chalk.gray(`Frameworks: ${learning.frameworks.join(', ')}`)); console.log(colors.muted(`Frameworks: ${learning.frameworks.join(', ')}`));
} }
if (learning.patterns?.length) { if (learning.patterns?.length) {
console.log(chalk.gray(`Patterns: ${learning.patterns.join(', ')}`)); console.log(colors.muted(`Patterns: ${learning.patterns.join(', ')}`));
} }
console.log(chalk.gray(`Created: ${new Date(learning.createdAt).toLocaleString()}`)); console.log(colors.muted(`Created: ${new Date(learning.createdAt).toLocaleString()}`));
console.log(chalk.gray(`Updated: ${new Date(learning.updatedAt).toLocaleString()}`)); console.log(colors.muted(`Updated: ${new Date(learning.updatedAt).toLocaleString()}`));
console.log(chalk.gray(`Uses: ${learning.useCount}`)); console.log(colors.muted(`Uses: ${learning.useCount}`));
if (learning.effectiveness !== undefined) { if (learning.effectiveness !== undefined) {
console.log(chalk.gray(`Effectiveness: ${this.formatScore(learning.effectiveness)}%`)); console.log(colors.muted(`Effectiveness: ${this.formatScore(learning.effectiveness)}%`));
} }
console.log(chalk.bold('\nContent:\n')); console.log(colors.bold('\nContent:\n'));
console.log(learning.content); console.log(learning.content);
console.log(); console.log();
@@ -436,11 +436,11 @@ export class MemoryCommand extends Command {
const observations = observationStore.getAll(); const observations = observationStore.getAll();
if (observations.length === 0) { if (observations.length === 0) {
console.log(chalk.yellow('No observations to compress.')); console.log(colors.warning('No observations to compress.'));
return 0; return 0;
} }
console.log(chalk.cyan(`Found ${observations.length} observations to compress...\n`)); console.log(colors.cyan(`Found ${observations.length} observations to compress...\n`));
const compressor = createMemoryCompressor(projectPath); const compressor = createMemoryCompressor(projectPath);
const compressionOptions = { const compressionOptions = {
@@ -449,17 +449,17 @@ export class MemoryCommand extends Command {
}; };
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray('(Dry run - no changes will be made)\n')); console.log(colors.muted('(Dry run - no changes will be made)\n'));
// For dry-run, only compress without storing // For dry-run, only compress without storing
const result = await compressor.compress(observations, compressionOptions); const result = await compressor.compress(observations, compressionOptions);
console.log(chalk.green(`✓ Would compress ${result.stats.inputCount} observations into ${result.stats.outputCount} learnings\n`)); console.log(colors.success(`✓ Would compress ${result.stats.inputCount} observations into ${result.stats.outputCount} learnings\n`));
if (result.learnings.length > 0) { if (result.learnings.length > 0) {
console.log(chalk.bold('Learnings that would be created:')); console.log(colors.bold('Learnings that would be created:'));
for (const learning of result.learnings) { for (const learning of result.learnings) {
console.log(` ${chalk.cyan('●')} ${learning.title}`); console.log(` ${colors.cyan('●')} ${learning.title}`);
console.log(` Tags: ${learning.tags.join(', ')}`); console.log(` Tags: ${learning.tags.join(', ')}`);
} }
console.log(); console.log();
@@ -471,12 +471,12 @@ export class MemoryCommand extends Command {
// Actual compression with storage // Actual compression with storage
const { learnings, result } = await compressor.compressAndStore(observations, compressionOptions); const { learnings, result } = await compressor.compressAndStore(observations, compressionOptions);
console.log(chalk.green(`✓ Compressed ${result.stats.inputCount} observations into ${result.stats.outputCount} learnings\n`)); console.log(colors.success(`✓ Compressed ${result.stats.inputCount} observations into ${result.stats.outputCount} learnings\n`));
if (learnings.length > 0) { if (learnings.length > 0) {
console.log(chalk.bold('New Learnings:')); console.log(colors.bold('New Learnings:'));
for (const learning of learnings) { for (const learning of learnings) {
console.log(` ${chalk.cyan('●')} ${learning.title}`); console.log(` ${colors.cyan('●')} ${learning.title}`);
console.log(` Tags: ${learning.tags.join(', ')}`); console.log(` Tags: ${learning.tags.join(', ')}`);
} }
console.log(); console.log();
@@ -485,7 +485,7 @@ export class MemoryCommand extends Command {
if (result.processedObservationIds.length > 0) { if (result.processedObservationIds.length > 0) {
// Remove processed observations // Remove processed observations
const deleted = observationStore.deleteMany(result.processedObservationIds); const deleted = observationStore.deleteMany(result.processedObservationIds);
console.log(chalk.gray(`Cleared ${deleted} processed observations.`)); console.log(colors.muted(`Cleared ${deleted} processed observations.`));
} }
return 0; return 0;
@@ -497,8 +497,8 @@ export class MemoryCommand extends Command {
private async exportLearning(): Promise<number> { private async exportLearning(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Learning ID is required')); error('Error: Learning ID is required');
console.log(chalk.gray('Usage: skillkit memory export <id> --name my-skill')); console.log(colors.muted('Usage: skillkit memory export <id> --name my-skill'));
return 1; return 1;
} }
@@ -519,7 +519,7 @@ export class MemoryCommand extends Command {
} }
if (!learning) { if (!learning) {
console.error(chalk.red(`Learning not found: ${id}`)); error(`Learning not found: ${id}`);
return 1; return 1;
} }
@@ -530,7 +530,7 @@ export class MemoryCommand extends Command {
const skillContent = this.generateSkillContent(learning, skillName); const skillContent = this.generateSkillContent(learning, skillName);
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray('(Dry run preview)\n')); console.log(colors.muted('(Dry run preview)\n'));
console.log(skillContent); console.log(skillContent);
return 0; return 0;
} }
@@ -547,8 +547,8 @@ export class MemoryCommand extends Command {
writeFileSync(outputPath, skillContent, 'utf-8'); writeFileSync(outputPath, skillContent, 'utf-8');
console.log(chalk.green(`✓ Exported learning as skill: ${skillName}`)); console.log(colors.success(`✓ Exported learning as skill: ${skillName}`));
console.log(chalk.gray(` Path: ${outputPath}`)); console.log(colors.muted(` Path: ${outputPath}`));
return 0; return 0;
} }
@@ -559,8 +559,8 @@ export class MemoryCommand extends Command {
private async importMemories(): Promise<number> { private async importMemories(): Promise<number> {
const inputPath = this.input || this.arg; const inputPath = this.input || this.arg;
if (!inputPath) { if (!inputPath) {
console.error(chalk.red('Error: Input path is required')); error('Error: Input path is required');
console.log(chalk.gray('Usage: skillkit memory import --input <path>')); console.log(colors.muted('Usage: skillkit memory import --input <path>'));
return 1; return 1;
} }
@@ -569,7 +569,7 @@ export class MemoryCommand extends Command {
const fullPath = resolve(inputPath); const fullPath = resolve(inputPath);
if (!existsSync(fullPath)) { if (!existsSync(fullPath)) {
console.error(chalk.red(`File not found: ${fullPath}`)); error(`File not found: ${fullPath}`);
return 1; return 1;
} }
@@ -585,14 +585,14 @@ export class MemoryCommand extends Command {
const data = parseYaml(content) as { learnings?: Learning[] }; const data = parseYaml(content) as { learnings?: Learning[] };
if (!data.learnings || !Array.isArray(data.learnings)) { if (!data.learnings || !Array.isArray(data.learnings)) {
console.error(chalk.red('Invalid memory file format')); error('Invalid memory file format');
return 1; return 1;
} }
let imported = 0; let imported = 0;
for (const learning of data.learnings) { for (const learning of data.learnings) {
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray(`Would import: ${learning.title}`)); console.log(colors.muted(`Would import: ${learning.title}`));
} else { } else {
store.add({ store.add({
source: 'imported', source: 'imported',
@@ -608,14 +608,14 @@ export class MemoryCommand extends Command {
} }
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray(`\n(Dry run - ${data.learnings.length} learnings would be imported)`)); console.log(colors.muted(`\n(Dry run - ${data.learnings.length} learnings would be imported)`));
} else { } else {
console.log(chalk.green(`✓ Imported ${imported} learnings`)); console.log(colors.success(`✓ Imported ${imported} learnings`));
} }
return 0; return 0;
} catch (error) { } catch (err) {
console.error(chalk.red(`Import failed: ${error}`)); error(`Import failed: ${err}`);
return 1; return 1;
} }
} }
@@ -630,7 +630,7 @@ export class MemoryCommand extends Command {
const observationStore = new ObservationStore(projectPath); const observationStore = new ObservationStore(projectPath);
const learningStore = new LearningStore('project', projectPath); const learningStore = new LearningStore('project', projectPath);
console.log(chalk.gray('(Dry run preview)\n')); console.log(colors.muted('(Dry run preview)\n'));
console.log(`Would clear ${observationStore.count()} observations`); console.log(`Would clear ${observationStore.count()} observations`);
if (!this.keepLearnings) { if (!this.keepLearnings) {
console.log(`Would clear ${learningStore.count()} learnings`); console.log(`Would clear ${learningStore.count()} learnings`);
@@ -640,12 +640,12 @@ export class MemoryCommand extends Command {
const observationStore = new ObservationStore(projectPath); const observationStore = new ObservationStore(projectPath);
observationStore.clear(); observationStore.clear();
console.log(chalk.green('✓ Cleared session observations')); console.log(colors.success('✓ Cleared session observations'));
if (!this.keepLearnings) { if (!this.keepLearnings) {
const learningStore = new LearningStore('project', projectPath); const learningStore = new LearningStore('project', projectPath);
learningStore.clear(); learningStore.clear();
console.log(chalk.green('✓ Cleared project learnings')); console.log(colors.success('✓ Cleared project learnings'));
} }
return 0; return 0;
@@ -656,14 +656,14 @@ export class MemoryCommand extends Command {
*/ */
private async addLearning(): Promise<number> { private async addLearning(): Promise<number> {
if (!this.title) { if (!this.title) {
console.error(chalk.red('Error: --title is required')); error('Error: --title is required');
console.log(chalk.gray('Usage: skillkit memory add --title "..." --content "..."')); console.log(colors.muted('Usage: skillkit memory add --title "..." --content "..."'));
return 1; return 1;
} }
if (!this.content) { if (!this.content) {
console.error(chalk.red('Error: --content is required')); error('Error: --content is required');
console.log(chalk.gray('Usage: skillkit memory add --title "..." --content "..."')); console.log(colors.muted('Usage: skillkit memory add --title "..." --content "..."'));
return 1; return 1;
} }
@@ -682,8 +682,8 @@ export class MemoryCommand extends Command {
tags, tags,
}); });
console.log(chalk.green(`✓ Added learning: ${learning.title}`)); console.log(colors.success(`✓ Added learning: ${learning.title}`));
console.log(chalk.gray(` ID: ${learning.id}`)); console.log(colors.muted(` ID: ${learning.id}`));
return 0; return 0;
} }
@@ -694,15 +694,15 @@ export class MemoryCommand extends Command {
private async rateLearning(): Promise<number> { private async rateLearning(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Learning ID is required')); error('Error: Learning ID is required');
console.log(chalk.gray('Usage: skillkit memory rate <id> <rating>')); console.log(colors.muted('Usage: skillkit memory rate <id> <rating>'));
return 1; return 1;
} }
const rating = parseInt(this.ratingArg || '0', 10); const rating = parseInt(this.ratingArg || '0', 10);
if (isNaN(rating) || rating < 0 || rating > 100) { if (isNaN(rating) || rating < 0 || rating > 100) {
console.error(chalk.red('Error: Rating must be 0-100')); error('Error: Rating must be 0-100');
console.log(chalk.gray('Usage: skillkit memory rate <id> <rating>')); console.log(colors.muted('Usage: skillkit memory rate <id> <rating>'));
return 1; return 1;
} }
@@ -737,12 +737,12 @@ export class MemoryCommand extends Command {
} }
if (!learning) { if (!learning) {
console.error(chalk.red(`Learning not found: ${id}`)); error(`Learning not found: ${id}`);
return 1; return 1;
} }
store.setEffectiveness(learning.id, rating); store.setEffectiveness(learning.id, rating);
console.log(chalk.green(`✓ Rated "${learning.title}" as ${rating}% effective`)); console.log(colors.success(`✓ Rated "${learning.title}" as ${rating}% effective`));
return 0; return 0;
} }
@@ -759,14 +759,14 @@ export class MemoryCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nMemory Configuration\n')); console.log(colors.bold('\nMemory Configuration\n'));
console.log(chalk.cyan('Paths:')); console.log(colors.cyan('Paths:'));
console.log(` Project observations: ${chalk.gray(paths.observationsFile)}`); console.log(` Project observations: ${colors.muted(paths.observationsFile)}`);
console.log(` Project learnings: ${chalk.gray(paths.learningsFile)}`); console.log(` Project learnings: ${colors.muted(paths.learningsFile)}`);
console.log(` Project index: ${chalk.gray(paths.indexFile)}`); console.log(` Project index: ${colors.muted(paths.indexFile)}`);
console.log(` Global learnings: ${chalk.gray(paths.globalLearningsFile)}`); console.log(` Global learnings: ${colors.muted(paths.globalLearningsFile)}`);
console.log(` Global index: ${chalk.gray(paths.globalIndexFile)}`); console.log(` Global index: ${colors.muted(paths.globalIndexFile)}`);
console.log(); console.log();
return 0; return 0;
@@ -780,7 +780,7 @@ export class MemoryCommand extends Command {
if (this.global) { if (this.global) {
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray('(Dry run - previewing global CLAUDE.md sync)\n')); console.log(colors.muted('(Dry run - previewing global CLAUDE.md sync)\n'));
} }
const result = this.dryRun const result = this.dryRun
@@ -792,21 +792,21 @@ export class MemoryCommand extends Command {
const learnings = globalStore.getAll() const learnings = globalStore.getAll()
.filter((l) => (l.effectiveness ?? 0) >= 60 || l.useCount >= 3) .filter((l) => (l.effectiveness ?? 0) >= 60 || l.useCount >= 3)
.slice(0, 20); .slice(0, 20);
console.log(chalk.cyan(`Would add ${learnings.length} learnings to global CLAUDE.md`)); console.log(colors.cyan(`Would add ${learnings.length} learnings to global CLAUDE.md`));
for (const l of learnings.slice(0, 5)) { for (const l of learnings.slice(0, 5)) {
console.log(` ${chalk.gray('●')} ${l.title}`); console.log(` ${colors.muted('●')} ${l.title}`);
} }
if (learnings.length > 5) { if (learnings.length > 5) {
console.log(chalk.gray(` ... and ${learnings.length - 5} more`)); console.log(colors.muted(` ... and ${learnings.length - 5} more`));
} }
return 0; return 0;
} }
if (result.updated) { if (result.updated) {
console.log(chalk.green(`✓ Updated global CLAUDE.md with ${result.learningsAdded} learnings`)); console.log(colors.success(`✓ Updated global CLAUDE.md with ${result.learningsAdded} learnings`));
console.log(chalk.gray(` Path: ${result.path}`)); console.log(colors.muted(` Path: ${result.path}`));
} else { } else {
console.log(chalk.yellow('No learnings to sync to global CLAUDE.md')); console.log(colors.warning('No learnings to sync to global CLAUDE.md'));
} }
return 0; return 0;
@@ -817,28 +817,28 @@ export class MemoryCommand extends Command {
if (this.dryRun) { if (this.dryRun) {
const preview = updater.preview({ minEffectiveness: 60 }); const preview = updater.preview({ minEffectiveness: 60 });
console.log(chalk.gray('(Dry run preview)\n')); console.log(colors.muted('(Dry run preview)\n'));
if (!preview.wouldUpdate) { if (!preview.wouldUpdate) {
console.log(chalk.yellow('No learnings to sync to CLAUDE.md')); console.log(colors.warning('No learnings to sync to CLAUDE.md'));
return 0; return 0;
} }
console.log(chalk.cyan(`Would add ${preview.learnings.length} learnings to CLAUDE.md\n`)); console.log(colors.cyan(`Would add ${preview.learnings.length} learnings to CLAUDE.md\n`));
for (const learning of preview.learnings.slice(0, 5)) { for (const learning of preview.learnings.slice(0, 5)) {
console.log(` ${chalk.gray('●')} ${learning.title}`); console.log(` ${colors.muted('●')} ${learning.title}`);
} }
if (preview.learnings.length > 5) { if (preview.learnings.length > 5) {
console.log(chalk.gray(` ... and ${preview.learnings.length - 5} more`)); console.log(colors.muted(` ... and ${preview.learnings.length - 5} more`));
} }
console.log(chalk.bold('\nFormatted section preview:')); console.log(colors.bold('\nFormatted section preview:'));
console.log(chalk.gray('─'.repeat(50))); console.log(colors.muted('─'.repeat(50)));
console.log(preview.formattedSection.slice(0, 500)); console.log(preview.formattedSection.slice(0, 500));
if (preview.formattedSection.length > 500) { if (preview.formattedSection.length > 500) {
console.log(chalk.gray('...')); console.log(colors.muted('...'));
} }
return 0; return 0;
@@ -847,17 +847,17 @@ export class MemoryCommand extends Command {
const result = updater.update({ minEffectiveness: 60 }); const result = updater.update({ minEffectiveness: 60 });
if (result.updated) { if (result.updated) {
console.log(chalk.green(`✓ Updated CLAUDE.md with ${result.learningsAdded} learnings`)); console.log(colors.success(`✓ Updated CLAUDE.md with ${result.learningsAdded} learnings`));
console.log(chalk.gray(` Path: ${result.path}`)); console.log(colors.muted(` Path: ${result.path}`));
if (this.verbose && result.learningSummaries.length > 0) { if (this.verbose && result.learningSummaries.length > 0) {
console.log(chalk.cyan('\nLearnings added:')); console.log(colors.cyan('\nLearnings added:'));
for (const title of result.learningSummaries.slice(0, 10)) { for (const title of result.learningSummaries.slice(0, 10)) {
console.log(` ${chalk.gray('●')} ${title}`); console.log(` ${colors.muted('●')} ${title}`);
} }
} }
} else { } else {
console.log(chalk.yellow('No learnings to sync to CLAUDE.md')); console.log(colors.warning('No learnings to sync to CLAUDE.md'));
} }
return 0; return 0;
@@ -874,7 +874,7 @@ export class MemoryCommand extends Command {
if (this.limit) { if (this.limit) {
const parsed = parseInt(this.limit, 10); const parsed = parseInt(this.limit, 10);
if (isNaN(parsed) || parsed <= 0) { if (isNaN(parsed) || parsed <= 0) {
console.log(chalk.red('Invalid --limit value. Must be a positive number.')); console.log(colors.error('Invalid --limit value. Must be a positive number.'));
return 1; return 1;
} }
maxResults = parsed; maxResults = parsed;
@@ -887,10 +887,10 @@ export class MemoryCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold(`\nMemory Index (${index.length} entries)\n`)); console.log(colors.bold(`\nMemory Index (${index.length} entries)\n`));
if (index.length === 0) { if (index.length === 0) {
console.log(chalk.gray('No learnings found.')); console.log(colors.muted('No learnings found.'));
return 0; return 0;
} }
@@ -901,17 +901,17 @@ export class MemoryCommand extends Command {
const effectiveness = entry.effectiveness !== undefined const effectiveness = entry.effectiveness !== undefined
? ` [${this.formatScore(entry.effectiveness)}%]` ? ` [${this.formatScore(entry.effectiveness)}%]`
: ''; : '';
const scope = entry.scope === 'global' ? chalk.magenta('[G]') : chalk.blue('[P]'); const scope = entry.scope === 'global' ? colors.magenta('[G]') : colors.info('[P]');
console.log(`${scope} ${chalk.gray(entry.id.slice(0, 8))} ${entry.title}${chalk.green(effectiveness)}`); console.log(`${scope} ${colors.muted(entry.id.slice(0, 8))} ${entry.title}${colors.success(effectiveness)}`);
console.log(` Tags: ${entry.tags.join(', ')} | Uses: ${entry.useCount}`); console.log(` Tags: ${entry.tags.join(', ')} | Uses: ${entry.useCount}`);
} }
if (index.length > displayLimit) { if (index.length > displayLimit) {
console.log(chalk.gray(`\n... and ${index.length - displayLimit} more (use --limit to show more)`)); console.log(colors.muted(`\n... and ${index.length - displayLimit} more (use --limit to show more)`));
} }
console.log(chalk.gray('\nUse "skillkit memory show <id>" to view full details')); console.log(colors.muted('\nUse "skillkit memory show <id>" to view full details'));
return 0; return 0;
} }
@@ -920,9 +920,9 @@ export class MemoryCommand extends Command {
* Format relevance/effectiveness score with color * Format relevance/effectiveness score with color
*/ */
private formatScore(score: number): string { private formatScore(score: number): string {
if (score >= 80) return chalk.green(score.toString()); if (score >= 80) return colors.success(score.toString());
if (score >= 50) return chalk.yellow(score.toString()); if (score >= 50) return colors.warning(score.toString());
return chalk.red(score.toString()); return colors.error(score.toString());
} }
/** /**
+111 -111
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, error } from '../onboarding/index.js';
export class MeshCommand extends Command { export class MeshCommand extends Command {
static override paths = [['mesh']]; static override paths = [['mesh']];
@@ -72,8 +72,8 @@ export class MeshCommand extends Command {
case 'peer': case 'peer':
return this.handlePeer(); return this.handlePeer();
default: default:
console.error(chalk.red(`Unknown action: ${action}`)); error(`Unknown action: ${action}`);
console.log(chalk.gray('Available actions: init, add, remove, list, health, discover, status, security, peer')); console.log(colors.muted('Available actions: init, add, remove, list, health, discover, status, security, peer'));
return 1; return 1;
} }
} }
@@ -86,10 +86,10 @@ export class MeshCommand extends Command {
const localConfig = hostsFile.localHost; const localConfig = hostsFile.localHost;
const localIP = getLocalIPAddress(); const localIP = getLocalIPAddress();
console.log(chalk.green('✓ Mesh network initialized\n')); console.log(colors.success('✓ Mesh network initialized\n'));
console.log(chalk.bold('Local Host Configuration:')); console.log(colors.bold('Local Host Configuration:'));
console.log(` ID: ${chalk.cyan(localConfig.id.slice(0, 8))}`); console.log(` ID: ${colors.cyan(localConfig.id.slice(0, 8))}`);
console.log(` Name: ${localConfig.name}`); console.log(` Name: ${localConfig.name}`);
console.log(` Address: ${localIP}:${localConfig.port}`); console.log(` Address: ${localIP}:${localConfig.port}`);
@@ -102,20 +102,20 @@ export class MeshCommand extends Command {
} }
console.log(); console.log();
console.log(chalk.gray('Other hosts can connect to this machine using:')); console.log(colors.muted('Other hosts can connect to this machine using:'));
console.log(chalk.gray(` skillkit mesh add ${localIP}:${localConfig.port}`)); console.log(colors.muted(` skillkit mesh add ${localIP}:${localConfig.port}`));
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to initialize mesh: ${err.message}`)); error(`Failed to initialize mesh: ${err.message}`);
return 1; return 1;
} }
} }
private async addHost(): Promise<number> { private async addHost(): Promise<number> {
if (!this.arg) { if (!this.arg) {
console.error(chalk.red('Error: Host address is required')); error('Error: Host address is required');
console.log(chalk.gray('Usage: skillkit mesh add <address>[:port]')); console.log(colors.muted('Usage: skillkit mesh add <address>[:port]'));
return 1; return 1;
} }
@@ -127,7 +127,7 @@ export class MeshCommand extends Command {
const portValue = portStr ?? this.port; const portValue = portStr ?? this.port;
const port = portValue ? Number(portValue) : DEFAULT_PORT; const port = portValue ? Number(portValue) : DEFAULT_PORT;
if (!Number.isInteger(port) || port < 1 || port > 65535) { if (!Number.isInteger(port) || port < 1 || port > 65535) {
console.error(chalk.red(`Invalid port: ${portValue}`)); error(`Invalid port: ${portValue}`);
return 1; return 1;
} }
@@ -142,23 +142,23 @@ export class MeshCommand extends Command {
await addKnownHost(host); await addKnownHost(host);
console.log(chalk.green(`✓ Added host: ${host.name}`)); console.log(colors.success(`✓ Added host: ${host.name}`));
console.log(` ID: ${chalk.gray(host.id.slice(0, 8))}`); console.log(` ID: ${colors.muted(host.id.slice(0, 8))}`);
console.log(` Address: ${host.address}:${host.port}`); console.log(` Address: ${host.address}:${host.port}`);
console.log(chalk.gray('\nRun "skillkit mesh health" to verify connectivity.')); console.log(colors.muted('\nRun "skillkit mesh health" to verify connectivity.'));
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to add host: ${err.message}`)); error(`Failed to add host: ${err.message}`);
return 1; return 1;
} }
} }
private async removeHost(): Promise<number> { private async removeHost(): Promise<number> {
if (!this.arg) { if (!this.arg) {
console.error(chalk.red('Error: Host ID is required')); error('Error: Host ID is required');
console.log(chalk.gray('Usage: skillkit mesh remove <hostId>')); console.log(colors.muted('Usage: skillkit mesh remove <hostId>'));
return 1; return 1;
} }
@@ -169,22 +169,22 @@ export class MeshCommand extends Command {
const host = hosts.find(h => h.id === this.arg || h.id.startsWith(this.arg!) || h.name === this.arg); const host = hosts.find(h => h.id === this.arg || h.id.startsWith(this.arg!) || h.name === this.arg);
if (!host) { if (!host) {
console.error(chalk.red(`Host not found: ${this.arg}`)); error(`Host not found: ${this.arg}`);
return 1; return 1;
} }
const removed = await removeKnownHost(host.id); const removed = await removeKnownHost(host.id);
if (removed) { if (removed) {
console.log(chalk.green(`✓ Removed host: ${host.name}`)); console.log(colors.success(`✓ Removed host: ${host.name}`));
} else { } else {
console.error(chalk.red('Failed to remove host')); error('Failed to remove host');
return 1; return 1;
} }
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to remove host: ${err.message}`)); error(`Failed to remove host: ${err.message}`);
return 1; return 1;
} }
} }
@@ -202,23 +202,23 @@ export class MeshCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nLocal Host:\n')); console.log(colors.bold('\nLocal Host:\n'));
console.log(` ${chalk.cyan('●')} ${localConfig.name} ${chalk.green('[local]')}`); console.log(` ${colors.cyan('●')} ${localConfig.name} ${colors.success('[local]')}`);
console.log(` ID: ${chalk.gray(localConfig.id.slice(0, 8))}`); console.log(` ID: ${colors.muted(localConfig.id.slice(0, 8))}`);
console.log(` Address: ${localIP}:${localConfig.port}`); console.log(` Address: ${localIP}:${localConfig.port}`);
console.log(chalk.bold('\nKnown Hosts:\n')); console.log(colors.bold('\nKnown Hosts:\n'));
if (hosts.length === 0) { if (hosts.length === 0) {
console.log(chalk.gray(' No hosts configured.')); console.log(colors.muted(' No hosts configured.'));
console.log(chalk.gray(' Add hosts with: skillkit mesh add <address>')); console.log(colors.muted(' Add hosts with: skillkit mesh add <address>'));
} else { } else {
for (const host of hosts) { for (const host of hosts) {
const statusIcon = host.status === 'online' ? chalk.green('●') : host.status === 'offline' ? chalk.red('●') : chalk.gray('○'); const statusIcon = host.status === 'online' ? colors.success('●') : host.status === 'offline' ? colors.error('●') : colors.muted('○');
const statusLabel = host.status === 'online' ? chalk.green('[online]') : host.status === 'offline' ? chalk.red('[offline]') : chalk.gray('[unknown]'); const statusLabel = host.status === 'online' ? colors.success('[online]') : host.status === 'offline' ? colors.error('[offline]') : colors.muted('[unknown]');
console.log(` ${statusIcon} ${host.name} ${statusLabel}`); console.log(` ${statusIcon} ${host.name} ${statusLabel}`);
console.log(` ID: ${chalk.gray(host.id.slice(0, 8))}`); console.log(` ID: ${colors.muted(host.id.slice(0, 8))}`);
console.log(` Address: ${host.address}:${host.port}`); console.log(` Address: ${host.address}:${host.port}`);
if (host.tailscaleIP) { if (host.tailscaleIP) {
console.log(` Tailscale: ${host.tailscaleIP}`); console.log(` Tailscale: ${host.tailscaleIP}`);
@@ -235,9 +235,9 @@ export class MeshCommand extends Command {
const tailscaleHosts = await discoverTailscaleHosts(localConfig.port); const tailscaleHosts = await discoverTailscaleHosts(localConfig.port);
if (tailscaleHosts.length > 0) { if (tailscaleHosts.length > 0) {
console.log(chalk.bold('\nTailscale Peers:\n')); console.log(colors.bold('\nTailscale Peers:\n'));
for (const host of tailscaleHosts) { for (const host of tailscaleHosts) {
console.log(` ${chalk.blue('◆')} ${host.name}`); console.log(` ${colors.info('◆')} ${host.name}`);
console.log(` IP: ${host.tailscaleIP}`); console.log(` IP: ${host.tailscaleIP}`);
} }
} }
@@ -247,7 +247,7 @@ export class MeshCommand extends Command {
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to list hosts: ${err.message}`)); error(`Failed to list hosts: ${err.message}`);
return 1; return 1;
} }
} }
@@ -259,12 +259,12 @@ export class MeshCommand extends Command {
const hosts = await getKnownHosts(); const hosts = await getKnownHosts();
if (hosts.length === 0) { if (hosts.length === 0) {
console.log(chalk.yellow('No hosts configured.')); console.log(colors.warning('No hosts configured.'));
console.log(chalk.gray('Add hosts with: skillkit mesh add <address>')); console.log(colors.muted('Add hosts with: skillkit mesh add <address>'));
return 0; return 0;
} }
console.log(chalk.bold('\nChecking host health...\n')); console.log(colors.bold('\nChecking host health...\n'));
const timeout = this.timeout ? parseInt(this.timeout, 10) : undefined; const timeout = this.timeout ? parseInt(this.timeout, 10) : undefined;
const results = await checkAllHostsHealth({ timeout }); const results = await checkAllHostsHealth({ timeout });
@@ -281,10 +281,10 @@ export class MeshCommand extends Command {
const name = host?.name || result.hostId.slice(0, 8); const name = host?.name || result.hostId.slice(0, 8);
if (result.status === 'online') { if (result.status === 'online') {
console.log(` ${chalk.green('✓')} ${name} - ${chalk.green('online')} (${result.latencyMs}ms)`); console.log(` ${colors.success('✓')} ${name} - ${colors.success('online')} (${result.latencyMs}ms)`);
} else { } else {
hasFailures = true; hasFailures = true;
console.log(` ${chalk.red('✗')} ${name} - ${chalk.red('offline')} ${result.error ? `(${result.error})` : ''}`); console.log(` ${colors.error('✗')} ${name} - ${colors.error('offline')} ${result.error ? `(${result.error})` : ''}`);
} }
} }
@@ -296,7 +296,7 @@ export class MeshCommand extends Command {
return hasFailures ? 1 : 0; return hasFailures ? 1 : 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to check health: ${err.message}`)); error(`Failed to check health: ${err.message}`);
return 1; return 1;
} }
} }
@@ -305,18 +305,18 @@ export class MeshCommand extends Command {
try { try {
const { discoverOnce, isTailscaleAvailable, discoverTailscaleHosts, getLocalHostConfig } = await import('@skillkit/mesh'); const { discoverOnce, isTailscaleAvailable, discoverTailscaleHosts, getLocalHostConfig } = await import('@skillkit/mesh');
console.log(chalk.bold('\nDiscovering hosts on local network...\n')); console.log(colors.bold('\nDiscovering hosts on local network...\n'));
const timeout = this.timeout ? parseInt(this.timeout, 10) : 5000; const timeout = this.timeout ? parseInt(this.timeout, 10) : 5000;
const localHosts = await discoverOnce(timeout); const localHosts = await discoverOnce(timeout);
if (localHosts.length === 0) { if (localHosts.length === 0) {
console.log(chalk.gray(' No hosts discovered on local network.')); console.log(colors.muted(' No hosts discovered on local network.'));
} else { } else {
console.log(chalk.cyan('Local Network:')); console.log(colors.cyan('Local Network:'));
for (const host of localHosts) { for (const host of localHosts) {
console.log(` ${chalk.green('●')} ${host.name}`); console.log(` ${colors.success('●')} ${host.name}`);
console.log(` Address: ${host.address}:${host.port}`); console.log(` Address: ${host.address}:${host.port}`);
} }
} }
@@ -328,23 +328,23 @@ export class MeshCommand extends Command {
const tailscaleHosts = await discoverTailscaleHosts(localConfig.port); const tailscaleHosts = await discoverTailscaleHosts(localConfig.port);
if (tailscaleHosts.length > 0) { if (tailscaleHosts.length > 0) {
console.log(chalk.cyan('\nTailscale Network:')); console.log(colors.cyan('\nTailscale Network:'));
for (const host of tailscaleHosts) { for (const host of tailscaleHosts) {
console.log(` ${chalk.blue('◆')} ${host.name}`); console.log(` ${colors.info('◆')} ${host.name}`);
console.log(` Tailscale IP: ${host.tailscaleIP}`); console.log(` Tailscale IP: ${host.tailscaleIP}`);
} }
} else { } else {
console.log(chalk.gray('\n No Tailscale peers found.')); console.log(colors.muted('\n No Tailscale peers found.'));
} }
} else { } else {
console.log(chalk.gray('\n Tailscale not available.')); console.log(colors.muted('\n Tailscale not available.'));
} }
} }
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to discover hosts: ${err.message}`)); error(`Failed to discover hosts: ${err.message}`);
return 1; return 1;
} }
} }
@@ -373,31 +373,31 @@ export class MeshCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nMesh Network Status\n')); console.log(colors.bold('\nMesh Network Status\n'));
console.log(chalk.cyan('Local Host:')); console.log(colors.cyan('Local Host:'));
console.log(` Name: ${localConfig.name}`); console.log(` Name: ${localConfig.name}`);
console.log(` ID: ${chalk.gray(localConfig.id.slice(0, 8))}`); console.log(` ID: ${colors.muted(localConfig.id.slice(0, 8))}`);
console.log(` Address: ${localIP}:${localConfig.port}`); console.log(` Address: ${localIP}:${localConfig.port}`);
if (hasTailscale) { if (hasTailscale) {
const tailscaleIP = await getTailscaleIP(); const tailscaleIP = await getTailscaleIP();
if (tailscaleIP) { if (tailscaleIP) {
console.log(` Tailscale: ${chalk.blue(tailscaleIP)}`); console.log(` Tailscale: ${colors.info(tailscaleIP)}`);
} }
} }
console.log(); console.log();
console.log(chalk.cyan('Network:')); console.log(colors.cyan('Network:'));
console.log(` Known hosts: ${hosts.length}`); console.log(` Known hosts: ${hosts.length}`);
console.log(` Online: ${onlineHosts}`); console.log(` Online: ${onlineHosts}`);
console.log(` Local peers: ${localPeers.length}`); console.log(` Local peers: ${localPeers.length}`);
console.log(` Tailscale: ${hasTailscale ? chalk.green('available') : chalk.gray('not available')}`); console.log(` Tailscale: ${hasTailscale ? colors.success('available') : colors.muted('not available')}`);
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to get status: ${err.message}`)); error(`Failed to get status: ${err.message}`);
return 1; return 1;
} }
} }
@@ -411,8 +411,8 @@ export class MeshCommand extends Command {
case 'status': case 'status':
return this.showSecurityStatus(); return this.showSecurityStatus();
default: default:
console.error(chalk.red(`Unknown security action: ${subAction}`)); error(`Unknown security action: ${subAction}`);
console.log(chalk.gray('Available actions: init, status')); console.log(colors.muted('Available actions: init, status'));
return 1; return 1;
} }
} }
@@ -421,33 +421,33 @@ export class MeshCommand extends Command {
try { try {
const { SecureKeystore, TLSManager, getLocalHostConfig, describeSecurityLevel, DEFAULT_SECURITY_CONFIG } = await import('@skillkit/mesh'); const { SecureKeystore, TLSManager, getLocalHostConfig, describeSecurityLevel, DEFAULT_SECURITY_CONFIG } = await import('@skillkit/mesh');
console.log(chalk.bold('\nInitializing mesh security...\n')); console.log(colors.bold('\nInitializing mesh security...\n'));
const keystore = new SecureKeystore(); const keystore = new SecureKeystore();
const identity = await keystore.loadOrCreateIdentity(); const identity = await keystore.loadOrCreateIdentity();
console.log(chalk.green('✓ Identity created/loaded')); console.log(colors.success('✓ Identity created/loaded'));
console.log(` Fingerprint: ${chalk.cyan(identity.fingerprint)}`); console.log(` Fingerprint: ${colors.cyan(identity.fingerprint)}`);
console.log(` Public Key: ${chalk.gray(identity.publicKeyHex.slice(0, 32))}...`); console.log(` Public Key: ${colors.muted(identity.publicKeyHex.slice(0, 32))}...`);
const localConfig = await getLocalHostConfig(); const localConfig = await getLocalHostConfig();
const tlsManager = new TLSManager(); const tlsManager = new TLSManager();
const certInfo = await tlsManager.loadOrCreateCertificate(localConfig.id, 'localhost'); const certInfo = await tlsManager.loadOrCreateCertificate(localConfig.id, 'localhost');
console.log(chalk.green('\n✓ TLS certificate generated')); console.log(colors.success('\n✓ TLS certificate generated'));
console.log(` Fingerprint: ${chalk.gray(certInfo.fingerprint.slice(0, 16))}...`); console.log(` Fingerprint: ${colors.muted(certInfo.fingerprint.slice(0, 16))}...`);
console.log(` Valid until: ${certInfo.notAfter.toLocaleDateString()}`); console.log(` Valid until: ${certInfo.notAfter.toLocaleDateString()}`);
console.log(chalk.green('\n✓ Security initialized')); console.log(colors.success('\n✓ Security initialized'));
console.log(` Mode: ${chalk.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`); console.log(` Mode: ${colors.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`);
console.log(chalk.gray('\nOther hosts can trust this peer using:')); console.log(colors.muted('\nOther hosts can trust this peer using:'));
console.log(chalk.gray(` skillkit mesh peer trust ${identity.fingerprint}`)); console.log(colors.muted(` skillkit mesh peer trust ${identity.fingerprint}`));
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to initialize security: ${err.message}`)); error(`Failed to initialize security: ${err.message}`);
return 1; return 1;
} }
} }
@@ -465,7 +465,7 @@ export class MeshCommand extends Command {
const keystore = new SecureKeystore(); const keystore = new SecureKeystore();
console.log(chalk.bold('\nMesh Security Status\n')); console.log(colors.bold('\nMesh Security Status\n'));
const hasIdentity = await keystore.hasIdentity(); const hasIdentity = await keystore.hasIdentity();
@@ -474,47 +474,47 @@ export class MeshCommand extends Command {
const trustedPeers = await keystore.getTrustedPeers(); const trustedPeers = await keystore.getTrustedPeers();
const revokedPeers = await keystore.getRevokedFingerprints(); const revokedPeers = await keystore.getRevokedFingerprints();
console.log(chalk.cyan('Identity:')); console.log(colors.cyan('Identity:'));
console.log(` Fingerprint: ${chalk.green(identity.fingerprint)}`); console.log(` Fingerprint: ${colors.success(identity.fingerprint)}`);
console.log(` Public Key: ${chalk.gray(identity.publicKeyHex.slice(0, 32))}...`); console.log(` Public Key: ${colors.muted(identity.publicKeyHex.slice(0, 32))}...`);
console.log(chalk.cyan('\nTrust:')); console.log(colors.cyan('\nTrust:'));
console.log(` Trusted peers: ${trustedPeers.length}`); console.log(` Trusted peers: ${trustedPeers.length}`);
console.log(` Revoked peers: ${revokedPeers.length}`); console.log(` Revoked peers: ${revokedPeers.length}`);
if (this.verbose && trustedPeers.length > 0) { if (this.verbose && trustedPeers.length > 0) {
console.log(chalk.cyan('\nTrusted Peers:')); console.log(colors.cyan('\nTrusted Peers:'));
for (const peer of trustedPeers) { for (const peer of trustedPeers) {
console.log(` ${chalk.green('●')} ${peer.name || peer.fingerprint.slice(0, 16)}`); console.log(` ${colors.success('●')} ${peer.name || peer.fingerprint.slice(0, 16)}`);
console.log(` Fingerprint: ${chalk.gray(peer.fingerprint)}`); console.log(` Fingerprint: ${colors.muted(peer.fingerprint)}`);
console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`); console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`);
} }
} }
} else { } else {
console.log(chalk.yellow('Identity: Not initialized')); console.log(colors.warning('Identity: Not initialized'));
console.log(chalk.gray('Run "skillkit mesh security init" to initialize.')); console.log(colors.muted('Run "skillkit mesh security init" to initialize.'));
} }
const localConfig = await getLocalHostConfig(); const localConfig = await getLocalHostConfig();
const tlsManager = new TLSManager(); const tlsManager = new TLSManager();
const hasCert = await tlsManager.hasCertificate(localConfig.id); const hasCert = await tlsManager.hasCertificate(localConfig.id);
console.log(chalk.cyan('\nTLS:')); console.log(colors.cyan('\nTLS:'));
if (hasCert) { if (hasCert) {
const certInfo = await tlsManager.loadCertificate(localConfig.id); const certInfo = await tlsManager.loadCertificate(localConfig.id);
console.log(` Certificate: ${chalk.green('Available')}`); console.log(` Certificate: ${colors.success('Available')}`);
if (certInfo) { if (certInfo) {
console.log(` Fingerprint: ${chalk.gray(certInfo.fingerprint.slice(0, 16))}...`); console.log(` Fingerprint: ${colors.muted(certInfo.fingerprint.slice(0, 16))}...`);
} }
} else { } else {
console.log(` Certificate: ${chalk.yellow('Not generated')}`); console.log(` Certificate: ${colors.warning('Not generated')}`);
} }
console.log(chalk.cyan('\nConfiguration:')); console.log(colors.cyan('\nConfiguration:'));
console.log(` Security level: ${chalk.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`); console.log(` Security level: ${colors.cyan(describeSecurityLevel(DEFAULT_SECURITY_CONFIG))}`);
console.log(` Discovery mode: ${DEFAULT_SECURITY_CONFIG.discovery.mode}`); console.log(` Discovery mode: ${DEFAULT_SECURITY_CONFIG.discovery.mode}`);
console.log(` Transport encryption: ${DEFAULT_SECURITY_CONFIG.transport.encryption}`); console.log(` Transport encryption: ${DEFAULT_SECURITY_CONFIG.transport.encryption}`);
console.log(` Auth required: ${DEFAULT_SECURITY_CONFIG.transport.requireAuth ? chalk.green('yes') : chalk.gray('no')}`); console.log(` Auth required: ${DEFAULT_SECURITY_CONFIG.transport.requireAuth ? colors.success('yes') : colors.muted('no')}`);
if (this.json) { if (this.json) {
const identity = hasIdentity ? await keystore.loadOrCreateIdentity() : null; const identity = hasIdentity ? await keystore.loadOrCreateIdentity() : null;
@@ -530,7 +530,7 @@ export class MeshCommand extends Command {
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to get security status: ${err.message}`)); error(`Failed to get security status: ${err.message}`);
return 1; return 1;
} }
} }
@@ -539,8 +539,8 @@ export class MeshCommand extends Command {
const subAction = this.arg; const subAction = this.arg;
if (!subAction) { if (!subAction) {
console.error(chalk.red('Error: Peer action is required')); error('Error: Peer action is required');
console.log(chalk.gray('Usage: skillkit mesh peer <trust|revoke|list> [fingerprint]')); console.log(colors.muted('Usage: skillkit mesh peer <trust|revoke|list> [fingerprint]'));
return 1; return 1;
} }
@@ -552,8 +552,8 @@ export class MeshCommand extends Command {
case 'list': case 'list':
return this.listPeers(); return this.listPeers();
default: default:
console.error(chalk.red(`Unknown peer action: ${subAction}`)); error(`Unknown peer action: ${subAction}`);
console.log(chalk.gray('Available actions: trust, revoke, list')); console.log(colors.muted('Available actions: trust, revoke, list'));
return 1; return 1;
} }
} }
@@ -562,8 +562,8 @@ export class MeshCommand extends Command {
const fingerprint = this.subArg; const fingerprint = this.subArg;
if (!fingerprint) { if (!fingerprint) {
console.error(chalk.red('Error: Fingerprint is required')); error('Error: Fingerprint is required');
console.log(chalk.gray('Usage: skillkit mesh peer trust <fingerprint> [--name <name>]')); console.log(colors.muted('Usage: skillkit mesh peer trust <fingerprint> [--name <name>]'));
return 1; return 1;
} }
@@ -574,17 +574,17 @@ export class MeshCommand extends Command {
const isRevoked = await keystore.isRevoked(fingerprint); const isRevoked = await keystore.isRevoked(fingerprint);
if (isRevoked) { if (isRevoked) {
console.log(chalk.yellow(`Peer ${fingerprint.slice(0, 8)} was previously revoked. Removing from revoked list...`)); console.log(colors.warning(`Peer ${fingerprint.slice(0, 8)} was previously revoked. Removing from revoked list...`));
} }
await keystore.addTrustedPeer(fingerprint, '', this.name); await keystore.addTrustedPeer(fingerprint, '', this.name);
console.log(chalk.green(`✓ Trusted peer: ${this.name || fingerprint.slice(0, 16)}`)); console.log(colors.success(`✓ Trusted peer: ${this.name || fingerprint.slice(0, 16)}`));
console.log(` Fingerprint: ${chalk.gray(fingerprint)}`); console.log(` Fingerprint: ${colors.muted(fingerprint)}`);
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to trust peer: ${err.message}`)); error(`Failed to trust peer: ${err.message}`);
return 1; return 1;
} }
} }
@@ -593,8 +593,8 @@ export class MeshCommand extends Command {
const fingerprint = this.subArg; const fingerprint = this.subArg;
if (!fingerprint) { if (!fingerprint) {
console.error(chalk.red('Error: Fingerprint is required')); error('Error: Fingerprint is required');
console.log(chalk.gray('Usage: skillkit mesh peer revoke <fingerprint>')); console.log(colors.muted('Usage: skillkit mesh peer revoke <fingerprint>'));
return 1; return 1;
} }
@@ -604,12 +604,12 @@ export class MeshCommand extends Command {
const keystore = new SecureKeystore(); const keystore = new SecureKeystore();
await keystore.revokePeer(fingerprint); await keystore.revokePeer(fingerprint);
console.log(chalk.green(`✓ Revoked peer: ${fingerprint.slice(0, 16)}`)); console.log(colors.success(`✓ Revoked peer: ${fingerprint.slice(0, 16)}`));
console.log(chalk.gray('This peer will no longer be trusted for mesh communication.')); console.log(colors.muted('This peer will no longer be trusted for mesh communication.'));
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to revoke peer: ${err.message}`)); error(`Failed to revoke peer: ${err.message}`);
return 1; return 1;
} }
} }
@@ -627,34 +627,34 @@ export class MeshCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nPeer Trust Status\n')); console.log(colors.bold('\nPeer Trust Status\n'));
if (this.trusted || trustedPeers.length > 0) { if (this.trusted || trustedPeers.length > 0) {
console.log(chalk.cyan('Trusted Peers:')); console.log(colors.cyan('Trusted Peers:'));
if (trustedPeers.length === 0) { if (trustedPeers.length === 0) {
console.log(chalk.gray(' No trusted peers.')); console.log(colors.muted(' No trusted peers.'));
} else { } else {
for (const peer of trustedPeers) { for (const peer of trustedPeers) {
console.log(` ${chalk.green('●')} ${peer.name || 'Unknown'}`); console.log(` ${colors.success('●')} ${peer.name || 'Unknown'}`);
console.log(` Fingerprint: ${chalk.gray(peer.fingerprint)}`); console.log(` Fingerprint: ${colors.muted(peer.fingerprint)}`);
console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`); console.log(` Added: ${new Date(peer.addedAt).toLocaleDateString()}`);
} }
} }
} }
if (!this.trusted && revokedFingerprints.length > 0) { if (!this.trusted && revokedFingerprints.length > 0) {
console.log(chalk.cyan('\nRevoked Peers:')); console.log(colors.cyan('\nRevoked Peers:'));
for (const fp of revokedFingerprints) { for (const fp of revokedFingerprints) {
console.log(` ${chalk.red('●')} ${chalk.gray(fp)}`); console.log(` ${colors.error('●')} ${colors.muted(fp)}`);
} }
} }
console.log(chalk.gray(`\nTotal: ${trustedPeers.length} trusted, ${revokedFingerprints.length} revoked`)); console.log(colors.muted(`\nTotal: ${trustedPeers.length} trusted, ${revokedFingerprints.length} revoked`));
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to list peers: ${err.message}`)); error(`Failed to list peers: ${err.message}`);
return 1; return 1;
} }
} }
+68 -68
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, error } from '../onboarding/index.js';
export class MessageCommand extends Command { export class MessageCommand extends Command {
static override paths = [['message'], ['msg']]; static override paths = [['message'], ['msg']];
@@ -66,8 +66,8 @@ export class MessageCommand extends Command {
case 'status': case 'status':
return this.showStatus(); return this.showStatus();
default: default:
console.error(chalk.red(`Unknown action: ${action}`)); error(`Unknown action: ${action}`);
console.log(chalk.gray('Available actions: send, inbox, read, reply, archive, forward, sent, status')); console.log(colors.muted('Available actions: send, inbox, read, reply, archive, forward, sent, status'));
return 1; return 1;
} }
} }
@@ -79,14 +79,14 @@ export class MessageCommand extends Command {
private async sendMessage(): Promise<number> { private async sendMessage(): Promise<number> {
const to = this.arg; const to = this.arg;
if (!to) { if (!to) {
console.error(chalk.red('Error: Recipient is required')); error('Error: Recipient is required');
console.log(chalk.gray('Usage: skillkit message send <to> --body "..."')); console.log(colors.muted('Usage: skillkit message send <to> --body "..."'));
return 1; return 1;
} }
if (!this.body) { if (!this.body) {
console.error(chalk.red('Error: Message body is required')); error('Error: Message body is required');
console.log(chalk.gray('Usage: skillkit message send <to> --body "..."')); console.log(colors.muted('Usage: skillkit message send <to> --body "..."'));
return 1; return 1;
} }
@@ -105,20 +105,20 @@ export class MessageCommand extends Command {
}); });
if (result.delivered) { if (result.delivered) {
console.log(chalk.green(`✓ Message sent to ${to}`)); console.log(colors.success(`✓ Message sent to ${to}`));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`); console.log(` ID: ${colors.muted(result.messageId.slice(0, 8))}`);
console.log(` Via: ${result.via}`); console.log(` Via: ${result.via}`);
} else { } else {
console.error(chalk.red(`✗ Failed to deliver message`)); error(`✗ Failed to deliver message`);
if (result.error) { if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`)); console.error(colors.muted(` Error: ${result.error}`));
} }
return 1; return 1;
} }
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to send message: ${err.message}`)); error(`Failed to send message: ${err.message}`);
return 1; return 1;
} }
} }
@@ -147,33 +147,33 @@ export class MessageCommand extends Command {
const summary = await service.getInboxSummary(); const summary = await service.getInboxSummary();
console.log(chalk.bold(`\nInbox (${summary.unread} unread / ${summary.total} total)\n`)); console.log(colors.bold(`\nInbox (${summary.unread} unread / ${summary.total} total)\n`));
if (messages.length === 0) { if (messages.length === 0) {
console.log(chalk.gray(' No messages.')); console.log(colors.muted(' No messages.'));
return 0; return 0;
} }
for (const message of messages) { for (const message of messages) {
const isUnread = message.status === 'unread'; const isUnread = message.status === 'unread';
const priorityIcon = this.getPriorityIcon(message.priority); const priorityIcon = this.getPriorityIcon(message.priority);
const statusIcon = isUnread ? chalk.cyan('●') : chalk.gray('○'); const statusIcon = isUnread ? colors.cyan('●') : colors.muted('○');
console.log(`${statusIcon} ${priorityIcon} ${isUnread ? chalk.bold(message.subject) : message.subject}`); console.log(`${statusIcon} ${priorityIcon} ${isUnread ? colors.bold(message.subject) : message.subject}`);
console.log(` ID: ${chalk.gray(message.id.slice(0, 8))} | From: ${message.from} | ${this.formatDate(message.createdAt)}`); console.log(` ID: ${colors.muted(message.id.slice(0, 8))} | From: ${message.from} | ${this.formatDate(message.createdAt)}`);
if (this.verbose) { if (this.verbose) {
const bodyPreview = typeof message.body === 'string' const bodyPreview = typeof message.body === 'string'
? message.body.slice(0, 80) ? message.body.slice(0, 80)
: JSON.stringify(message.body).slice(0, 80); : JSON.stringify(message.body).slice(0, 80);
console.log(` ${chalk.gray(bodyPreview)}${bodyPreview.length >= 80 ? '...' : ''}`); console.log(` ${colors.muted(bodyPreview)}${bodyPreview.length >= 80 ? '...' : ''}`);
} }
} }
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to show inbox: ${err.message}`)); error(`Failed to show inbox: ${err.message}`);
return 1; return 1;
} }
} }
@@ -181,8 +181,8 @@ export class MessageCommand extends Command {
private async readMessage(): Promise<number> { private async readMessage(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Message ID is required')); error('Error: Message ID is required');
console.log(chalk.gray('Usage: skillkit message read <id>')); console.log(colors.muted('Usage: skillkit message read <id>'));
return 1; return 1;
} }
@@ -205,13 +205,13 @@ export class MessageCommand extends Command {
} }
} }
console.error(chalk.red(`Message not found: ${id}`)); error(`Message not found: ${id}`);
return 1; return 1;
} }
return this.displayMessage(message); return this.displayMessage(message);
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to read message: ${err.message}`)); error(`Failed to read message: ${err.message}`);
return 1; return 1;
} }
} }
@@ -222,22 +222,22 @@ export class MessageCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold(`\n${message.subject}\n`)); console.log(colors.bold(`\n${message.subject}\n`));
console.log(`From: ${message.from}`); console.log(`From: ${message.from}`);
console.log(`To: ${message.to}`); console.log(`To: ${message.to}`);
console.log(`Date: ${new Date(message.createdAt).toLocaleString()}`); console.log(`Date: ${new Date(message.createdAt).toLocaleString()}`);
console.log(`Priority: ${message.priority}`); console.log(`Priority: ${message.priority}`);
console.log(`Type: ${message.type}`); console.log(`Type: ${message.type}`);
console.log(`ID: ${chalk.gray(message.id)}`); console.log(`ID: ${colors.muted(message.id)}`);
if (message.replyTo) { if (message.replyTo) {
console.log(`Reply to: ${chalk.gray(message.replyTo)}`); console.log(`Reply to: ${colors.muted(message.replyTo)}`);
} }
if (message.threadId) { if (message.threadId) {
console.log(`Thread: ${chalk.gray(message.threadId)}`); console.log(`Thread: ${colors.muted(message.threadId)}`);
} }
console.log(chalk.bold('\nBody:\n')); console.log(colors.bold('\nBody:\n'));
if (typeof message.body === 'string') { if (typeof message.body === 'string') {
console.log(message.body); console.log(message.body);
} else { } else {
@@ -251,14 +251,14 @@ export class MessageCommand extends Command {
private async replyMessage(): Promise<number> { private async replyMessage(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Message ID is required')); error('Error: Message ID is required');
console.log(chalk.gray('Usage: skillkit message reply <id> --body "..."')); console.log(colors.muted('Usage: skillkit message reply <id> --body "..."'));
return 1; return 1;
} }
if (!this.body) { if (!this.body) {
console.error(chalk.red('Error: Reply body is required')); error('Error: Reply body is required');
console.log(chalk.gray('Usage: skillkit message reply <id> --body "..."')); console.log(colors.muted('Usage: skillkit message reply <id> --body "..."'));
return 1; return 1;
} }
@@ -276,7 +276,7 @@ export class MessageCommand extends Command {
if (found) { if (found) {
messageId = found.id; messageId = found.id;
} else { } else {
console.error(chalk.red(`Message not found: ${id}`)); error(`Message not found: ${id}`);
return 1; return 1;
} }
} }
@@ -284,19 +284,19 @@ export class MessageCommand extends Command {
const result = await service.reply(messageId, this.body); const result = await service.reply(messageId, this.body);
if (result.delivered) { if (result.delivered) {
console.log(chalk.green('✓ Reply sent')); console.log(colors.success('✓ Reply sent'));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`); console.log(` ID: ${colors.muted(result.messageId.slice(0, 8))}`);
} else { } else {
console.error(chalk.red('✗ Failed to send reply')); error('✗ Failed to send reply');
if (result.error) { if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`)); console.error(colors.muted(` Error: ${result.error}`));
} }
return 1; return 1;
} }
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to reply: ${err.message}`)); error(`Failed to reply: ${err.message}`);
return 1; return 1;
} }
} }
@@ -304,8 +304,8 @@ export class MessageCommand extends Command {
private async archiveMessage(): Promise<number> { private async archiveMessage(): Promise<number> {
const id = this.arg; const id = this.arg;
if (!id) { if (!id) {
console.error(chalk.red('Error: Message ID is required')); error('Error: Message ID is required');
console.log(chalk.gray('Usage: skillkit message archive <id>')); console.log(colors.muted('Usage: skillkit message archive <id>'));
return 1; return 1;
} }
@@ -323,7 +323,7 @@ export class MessageCommand extends Command {
if (found) { if (found) {
messageId = found.id; messageId = found.id;
} else { } else {
console.error(chalk.red(`Message not found: ${id}`)); error(`Message not found: ${id}`);
return 1; return 1;
} }
} }
@@ -331,15 +331,15 @@ export class MessageCommand extends Command {
const archived = await service.archive(messageId); const archived = await service.archive(messageId);
if (archived) { if (archived) {
console.log(chalk.green('✓ Message archived')); console.log(colors.success('✓ Message archived'));
} else { } else {
console.error(chalk.red('✗ Failed to archive message')); error('✗ Failed to archive message');
return 1; return 1;
} }
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to archive: ${err.message}`)); error(`Failed to archive: ${err.message}`);
return 1; return 1;
} }
} }
@@ -349,14 +349,14 @@ export class MessageCommand extends Command {
const to = this.arg2; const to = this.arg2;
if (!id) { if (!id) {
console.error(chalk.red('Error: Message ID is required')); error('Error: Message ID is required');
console.log(chalk.gray('Usage: skillkit message forward <id> <to>')); console.log(colors.muted('Usage: skillkit message forward <id> <to>'));
return 1; return 1;
} }
if (!to) { if (!to) {
console.error(chalk.red('Error: Recipient is required')); error('Error: Recipient is required');
console.log(chalk.gray('Usage: skillkit message forward <id> <to>')); console.log(colors.muted('Usage: skillkit message forward <id> <to>'));
return 1; return 1;
} }
@@ -374,7 +374,7 @@ export class MessageCommand extends Command {
if (found) { if (found) {
messageId = found.id; messageId = found.id;
} else { } else {
console.error(chalk.red(`Message not found: ${id}`)); error(`Message not found: ${id}`);
return 1; return 1;
} }
} }
@@ -382,19 +382,19 @@ export class MessageCommand extends Command {
const result = await service.forward(messageId, to, this.body); const result = await service.forward(messageId, to, this.body);
if (result.delivered) { if (result.delivered) {
console.log(chalk.green(`✓ Message forwarded to ${to}`)); console.log(colors.success(`✓ Message forwarded to ${to}`));
console.log(` ID: ${chalk.gray(result.messageId.slice(0, 8))}`); console.log(` ID: ${colors.muted(result.messageId.slice(0, 8))}`);
} else { } else {
console.error(chalk.red('✗ Failed to forward message')); error('✗ Failed to forward message');
if (result.error) { if (result.error) {
console.error(chalk.gray(` Error: ${result.error}`)); console.error(colors.muted(` Error: ${result.error}`));
} }
return 1; return 1;
} }
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to forward: ${err.message}`)); error(`Failed to forward: ${err.message}`);
return 1; return 1;
} }
} }
@@ -418,24 +418,24 @@ export class MessageCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold(`\nSent Messages (${messages.length})\n`)); console.log(colors.bold(`\nSent Messages (${messages.length})\n`));
if (messages.length === 0) { if (messages.length === 0) {
console.log(chalk.gray(' No sent messages.')); console.log(colors.muted(' No sent messages.'));
return 0; return 0;
} }
for (const message of messages) { for (const message of messages) {
const priorityIcon = this.getPriorityIcon(message.priority); const priorityIcon = this.getPriorityIcon(message.priority);
console.log(`${chalk.gray('○')} ${priorityIcon} ${message.subject}`); console.log(`${colors.muted('○')} ${priorityIcon} ${message.subject}`);
console.log(` ID: ${chalk.gray(message.id.slice(0, 8))} | To: ${message.to} | ${this.formatDate(message.createdAt)}`); console.log(` ID: ${colors.muted(message.id.slice(0, 8))} | To: ${message.to} | ${this.formatDate(message.createdAt)}`);
} }
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to show sent: ${err.message}`)); error(`Failed to show sent: ${err.message}`);
return 1; return 1;
} }
} }
@@ -461,26 +461,26 @@ export class MessageCommand extends Command {
return 0; return 0;
} }
console.log(chalk.bold('\nMessaging Status\n')); console.log(colors.bold('\nMessaging Status\n'));
console.log(chalk.cyan('Agent:')); console.log(colors.cyan('Agent:'));
console.log(` ID: ${agentId}`); console.log(` ID: ${agentId}`);
console.log(); console.log();
console.log(chalk.cyan('Inbox:')); console.log(colors.cyan('Inbox:'));
console.log(` Total: ${summary.total}`); console.log(` Total: ${summary.total}`);
console.log(` Unread: ${summary.unread}`); 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(` By priority: urgent=${summary.byPriority.urgent}, high=${summary.byPriority.high}, normal=${summary.byPriority.normal}, low=${summary.byPriority.low}`);
console.log(); console.log();
console.log(chalk.cyan('Storage:')); console.log(colors.cyan('Storage:'));
console.log(` Sent: ${sent.length}`); console.log(` Sent: ${sent.length}`);
console.log(` Archived: ${archived.length}`); console.log(` Archived: ${archived.length}`);
console.log(); console.log();
return 0; return 0;
} catch (err: any) { } catch (err: any) {
console.error(chalk.red(`Failed to get status: ${err.message}`)); error(`Failed to get status: ${err.message}`);
return 1; return 1;
} }
} }
@@ -488,13 +488,13 @@ export class MessageCommand extends Command {
private getPriorityIcon(priority: string): string { private getPriorityIcon(priority: string): string {
switch (priority) { switch (priority) {
case 'urgent': case 'urgent':
return chalk.red('!!!!'); return colors.error('!!!!');
case 'high': case 'high':
return chalk.yellow('!!!'); return colors.warning('!!!');
case 'normal': case 'normal':
return chalk.gray('!'); return colors.muted('!');
case 'low': case 'low':
return chalk.gray('·'); return colors.muted('·');
default: default:
return ''; return '';
} }
+48 -48
View File
@@ -5,7 +5,7 @@
*/ */
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { createMethodologyManager, createMethodologyLoader } from '@skillkit/core'; import { createMethodologyManager, createMethodologyLoader } from '@skillkit/core';
export class MethodologyCommand extends Command { export class MethodologyCommand extends Command {
@@ -50,12 +50,12 @@ export class MethodologyCommand extends Command {
case 'installed': case 'installed':
return await this.listInstalled(projectPath); return await this.listInstalled(projectPath);
default: default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`)); this.context.stderr.write(colors.error(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: list, install, uninstall, sync, search, info, installed\n'); this.context.stderr.write('Available actions: list, install, uninstall, sync, search, info, installed\n');
return 1; return 1;
} }
} catch (err) { } catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`)); this.context.stderr.write(colors.error(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1; return 1;
} }
} }
@@ -69,18 +69,18 @@ export class MethodologyCommand extends Command {
return 0; return 0;
} }
this.context.stdout.write(chalk.cyan('Available Methodology Packs:\n\n')); this.context.stdout.write(colors.cyan('Available Methodology Packs:\n\n'));
for (const pack of packs) { for (const pack of packs) {
this.context.stdout.write(chalk.green(` ${pack.name}`) + ` v${pack.version}\n`); this.context.stdout.write(colors.success(` ${pack.name}`) + ` v${pack.version}\n`);
this.context.stdout.write(chalk.gray(` ${pack.description}\n`)); this.context.stdout.write(colors.muted(` ${pack.description}\n`));
this.context.stdout.write(` Skills: ${pack.skills.join(', ')}\n`); this.context.stdout.write(` Skills: ${pack.skills.join(', ')}\n`);
this.context.stdout.write(` Tags: ${pack.tags.join(', ')}\n`); this.context.stdout.write(` Tags: ${pack.tags.join(', ')}\n`);
this.context.stdout.write('\n'); this.context.stdout.write('\n');
} }
this.context.stdout.write(`Total: ${packs.length} packs\n`); this.context.stdout.write(`Total: ${packs.length} packs\n`);
this.context.stdout.write(chalk.gray('\nRun `skillkit methodology install` to install all packs.\n')); this.context.stdout.write(colors.muted('\nRun `skillkit methodology install` to install all packs.\n'));
return 0; return 0;
} }
@@ -92,31 +92,31 @@ export class MethodologyCommand extends Command {
// Check if it's a skill ID (pack/skill) or pack name // Check if it's a skill ID (pack/skill) or pack name
if (this.target.includes('/')) { if (this.target.includes('/')) {
// Install single skill // Install single skill
this.context.stdout.write(`Installing skill: ${chalk.cyan(this.target)}...\n`); this.context.stdout.write(`Installing skill: ${colors.cyan(this.target)}...\n`);
if (this.dryRun) { if (this.dryRun) {
this.context.stdout.write(chalk.yellow('[dry-run] Would install skill.\n')); this.context.stdout.write(colors.warning('[dry-run] Would install skill.\n'));
return 0; return 0;
} }
const result = await manager.installSkill(this.target); const result = await manager.installSkill(this.target);
if (result.success) { if (result.success) {
this.context.stdout.write(chalk.green(`✓ Skill installed: ${this.target}\n`)); this.context.stdout.write(colors.success(`✓ Skill installed: ${this.target}\n`));
} else { } else {
for (const failed of result.failed) { for (const failed of result.failed) {
this.context.stderr.write(chalk.red(`✗ ${failed.name}: ${failed.error}\n`)); this.context.stderr.write(colors.error(`✗ ${failed.name}: ${failed.error}\n`));
} }
return 1; return 1;
} }
} else { } else {
// Install single pack // Install single pack
this.context.stdout.write(`Installing pack: ${chalk.cyan(this.target)}...\n`); this.context.stdout.write(`Installing pack: ${colors.cyan(this.target)}...\n`);
if (this.dryRun) { if (this.dryRun) {
const pack = await loader.loadPack(this.target); const pack = await loader.loadPack(this.target);
if (pack) { if (pack) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would install ${pack.skills.length} skills.\n`)); this.context.stdout.write(colors.warning(`[dry-run] Would install ${pack.skills.length} skills.\n`));
} }
return 0; return 0;
} }
@@ -124,15 +124,15 @@ export class MethodologyCommand extends Command {
const result = await manager.installPack(this.target); const result = await manager.installPack(this.target);
if (result.success) { if (result.success) {
this.context.stdout.write(chalk.green(`✓ Pack "${this.target}" installed!\n`)); this.context.stdout.write(colors.success(`✓ Pack "${this.target}" installed!\n`));
this.context.stdout.write(` Installed: ${result.installed.length} skills\n`); this.context.stdout.write(` Installed: ${result.installed.length} skills\n`);
if (result.skipped.length > 0) { if (result.skipped.length > 0) {
this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`); this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`);
} }
} else { } else {
this.context.stderr.write(chalk.red(`✗ Failed to install pack\n`)); this.context.stderr.write(colors.error(`✗ Failed to install pack\n`));
for (const failed of result.failed) { for (const failed of result.failed) {
this.context.stderr.write(chalk.red(` - ${failed.name}: ${failed.error}\n`)); this.context.stderr.write(colors.error(` - ${failed.name}: ${failed.error}\n`));
} }
return 1; return 1;
} }
@@ -145,31 +145,31 @@ export class MethodologyCommand extends Command {
const packs = await loader.loadAllPacks(); const packs = await loader.loadAllPacks();
let totalSkills = 0; let totalSkills = 0;
for (const pack of packs) { for (const pack of packs) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would install ${pack.name} (${pack.skills.length} skills)\n`)); this.context.stdout.write(colors.warning(`[dry-run] Would install ${pack.name} (${pack.skills.length} skills)\n`));
totalSkills += pack.skills.length; totalSkills += pack.skills.length;
} }
this.context.stdout.write(chalk.yellow(`\n[dry-run] Would install ${totalSkills} skills total.\n`)); this.context.stdout.write(colors.warning(`\n[dry-run] Would install ${totalSkills} skills total.\n`));
return 0; return 0;
} }
const result = await manager.installAllPacks(); const result = await manager.installAllPacks();
if (result.success) { if (result.success) {
this.context.stdout.write(chalk.green('\n✓ All methodology packs installed!\n')); this.context.stdout.write(colors.success('\n✓ All methodology packs installed!\n'));
this.context.stdout.write(` Installed: ${result.installed.length} skills\n`); this.context.stdout.write(` Installed: ${result.installed.length} skills\n`);
if (result.skipped.length > 0) { if (result.skipped.length > 0) {
this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`); this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`);
} }
} else { } else {
this.context.stdout.write(chalk.yellow('\n⚠ Some skills failed to install:\n')); this.context.stdout.write(colors.warning('\n⚠ Some skills failed to install:\n'));
for (const failed of result.failed) { for (const failed of result.failed) {
this.context.stderr.write(chalk.red(` - ${failed.name}: ${failed.error}\n`)); this.context.stderr.write(colors.error(` - ${failed.name}: ${failed.error}\n`));
} }
this.context.stdout.write(`\n Installed: ${result.installed.length} skills\n`); this.context.stdout.write(`\n Installed: ${result.installed.length} skills\n`);
} }
} }
this.context.stdout.write(chalk.gray('\nRun `skillkit methodology sync` to sync to detected agents.\n')); this.context.stdout.write(colors.muted('\nRun `skillkit methodology sync` to sync to detected agents.\n'));
return 0; return 0;
} }
@@ -177,18 +177,18 @@ export class MethodologyCommand extends Command {
const manager = createMethodologyManager({ projectPath }); const manager = createMethodologyManager({ projectPath });
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Pack name required for uninstall.\n')); this.context.stderr.write(colors.error('Pack name required for uninstall.\n'));
this.context.stderr.write('Usage: skillkit methodology uninstall <pack-name>\n'); this.context.stderr.write('Usage: skillkit methodology uninstall <pack-name>\n');
return 1; return 1;
} }
if (this.dryRun) { if (this.dryRun) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would uninstall pack: ${this.target}\n`)); this.context.stdout.write(colors.warning(`[dry-run] Would uninstall pack: ${this.target}\n`));
return 0; return 0;
} }
await manager.uninstallPack(this.target); await manager.uninstallPack(this.target);
this.context.stdout.write(chalk.green(`✓ Pack "${this.target}" uninstalled.\n`)); this.context.stdout.write(colors.success(`✓ Pack "${this.target}" uninstalled.\n`));
return 0; return 0;
} }
@@ -199,23 +199,23 @@ export class MethodologyCommand extends Command {
if (this.dryRun) { if (this.dryRun) {
const installed = manager.listInstalledSkills(); const installed = manager.listInstalledSkills();
this.context.stdout.write(chalk.yellow(`[dry-run] Would sync ${installed.length} skills.\n`)); this.context.stdout.write(colors.warning(`[dry-run] Would sync ${installed.length} skills.\n`));
return 0; return 0;
} }
const result = await manager.syncAll(); const result = await manager.syncAll();
if (result.synced.length > 0) { if (result.synced.length > 0) {
this.context.stdout.write(chalk.green('✓ Sync complete!\n')); this.context.stdout.write(colors.success('✓ Sync complete!\n'));
for (const sync of result.synced) { for (const sync of result.synced) {
this.context.stdout.write(` ${sync.skill} → ${sync.agents.join(', ')}\n`); this.context.stdout.write(` ${sync.skill} → ${sync.agents.join(', ')}\n`);
} }
} }
if (result.failed.length > 0) { if (result.failed.length > 0) {
this.context.stdout.write(chalk.yellow('\n⚠ Some syncs failed:\n')); this.context.stdout.write(colors.warning('\n⚠ Some syncs failed:\n'));
for (const fail of result.failed) { for (const fail of result.failed) {
this.context.stderr.write(chalk.red(` ${fail.skill} (${fail.agent}): ${fail.error}\n`)); this.context.stderr.write(colors.error(` ${fail.skill} (${fail.agent}): ${fail.error}\n`));
} }
} }
@@ -230,7 +230,7 @@ export class MethodologyCommand extends Command {
const loader = createMethodologyLoader(); const loader = createMethodologyLoader();
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Search query required.\n')); this.context.stderr.write(colors.error('Search query required.\n'));
this.context.stderr.write('Usage: skillkit methodology search <query>\n'); this.context.stderr.write('Usage: skillkit methodology search <query>\n');
return 1; return 1;
} }
@@ -242,11 +242,11 @@ export class MethodologyCommand extends Command {
return 0; return 0;
} }
this.context.stdout.write(chalk.cyan(`Found ${skills.length} skills matching "${this.target}":\n\n`)); this.context.stdout.write(colors.cyan(`Found ${skills.length} skills matching "${this.target}":\n\n`));
for (const skill of skills) { for (const skill of skills) {
this.context.stdout.write(chalk.green(` ${skill.id}`) + ` v${skill.version}\n`); this.context.stdout.write(colors.success(` ${skill.id}`) + ` v${skill.version}\n`);
this.context.stdout.write(chalk.gray(` ${skill.description || 'No description'}\n`)); this.context.stdout.write(colors.muted(` ${skill.description || 'No description'}\n`));
if (skill.tags.length > 0) { if (skill.tags.length > 0) {
this.context.stdout.write(` Tags: ${skill.tags.join(', ')}\n`); this.context.stdout.write(` Tags: ${skill.tags.join(', ')}\n`);
} }
@@ -263,7 +263,7 @@ export class MethodologyCommand extends Command {
const loader = createMethodologyLoader(); const loader = createMethodologyLoader();
if (!this.target) { if (!this.target) {
this.context.stderr.write(chalk.red('Pack name required.\n')); this.context.stderr.write(colors.error('Pack name required.\n'));
this.context.stderr.write('Usage: skillkit methodology info <pack-name>\n'); this.context.stderr.write('Usage: skillkit methodology info <pack-name>\n');
return 1; return 1;
} }
@@ -271,11 +271,11 @@ export class MethodologyCommand extends Command {
const pack = await loader.loadPack(this.target); const pack = await loader.loadPack(this.target);
if (!pack) { if (!pack) {
this.context.stderr.write(chalk.red(`Pack not found: ${this.target}\n`)); this.context.stderr.write(colors.error(`Pack not found: ${this.target}\n`));
return 1; return 1;
} }
this.context.stdout.write(chalk.cyan(`\nPack: ${pack.name}\n`)); this.context.stdout.write(colors.cyan(`\nPack: ${pack.name}\n`));
this.context.stdout.write(`Version: ${pack.version}\n`); this.context.stdout.write(`Version: ${pack.version}\n`);
this.context.stdout.write(`Description: ${pack.description}\n`); this.context.stdout.write(`Description: ${pack.description}\n`);
this.context.stdout.write(`Tags: ${pack.tags.join(', ')}\n`); this.context.stdout.write(`Tags: ${pack.tags.join(', ')}\n`);
@@ -283,12 +283,12 @@ export class MethodologyCommand extends Command {
this.context.stdout.write(`License: ${pack.license || 'Unknown'}\n`); this.context.stdout.write(`License: ${pack.license || 'Unknown'}\n`);
this.context.stdout.write(`Compatibility: ${pack.compatibility.join(', ')}\n`); this.context.stdout.write(`Compatibility: ${pack.compatibility.join(', ')}\n`);
this.context.stdout.write(chalk.cyan(`\nSkills (${pack.skills.length}):\n`)); this.context.stdout.write(colors.cyan(`\nSkills (${pack.skills.length}):\n`));
const skills = await loader.loadPackSkills(this.target); const skills = await loader.loadPackSkills(this.target);
for (const skill of skills) { for (const skill of skills) {
this.context.stdout.write(chalk.green(` ${skill.id.split('/')[1]}\n`)); this.context.stdout.write(colors.success(` ${skill.id.split('/')[1]}\n`));
this.context.stdout.write(chalk.gray(` ${skill.description || 'No description'}\n`)); this.context.stdout.write(colors.muted(` ${skill.description || 'No description'}\n`));
if (this.verbose) { if (this.verbose) {
if (skill.metadata.triggers) { if (skill.metadata.triggers) {
this.context.stdout.write(` Triggers: ${skill.metadata.triggers.join(', ')}\n`); this.context.stdout.write(` Triggers: ${skill.metadata.triggers.join(', ')}\n`);
@@ -302,7 +302,7 @@ export class MethodologyCommand extends Command {
} }
} }
this.context.stdout.write(chalk.gray(`\nRun \`skillkit methodology install ${this.target}\` to install this pack.\n`)); this.context.stdout.write(colors.muted(`\nRun \`skillkit methodology install ${this.target}\` to install this pack.\n`));
return 0; return 0;
} }
@@ -314,30 +314,30 @@ export class MethodologyCommand extends Command {
if (installedPacks.length === 0 && installedSkills.length === 0) { if (installedPacks.length === 0 && installedSkills.length === 0) {
this.context.stdout.write('No methodology skills installed.\n'); this.context.stdout.write('No methodology skills installed.\n');
this.context.stdout.write(chalk.gray('Run `skillkit methodology install` to install methodology packs.\n')); this.context.stdout.write(colors.muted('Run `skillkit methodology install` to install methodology packs.\n'));
return 0; return 0;
} }
if (installedPacks.length > 0) { if (installedPacks.length > 0) {
this.context.stdout.write(chalk.cyan('Installed Packs:\n')); this.context.stdout.write(colors.cyan('Installed Packs:\n'));
for (const pack of installedPacks) { for (const pack of installedPacks) {
this.context.stdout.write(chalk.green(` ${pack.name}`) + ` v${pack.version}\n`); this.context.stdout.write(colors.success(` ${pack.name}`) + ` v${pack.version}\n`);
this.context.stdout.write(` Skills: ${pack.skills.length}\n`); this.context.stdout.write(` Skills: ${pack.skills.length}\n`);
} }
this.context.stdout.write('\n'); this.context.stdout.write('\n');
} }
if (installedSkills.length > 0) { if (installedSkills.length > 0) {
this.context.stdout.write(chalk.cyan('Installed Skills:\n')); this.context.stdout.write(colors.cyan('Installed Skills:\n'));
for (const skill of installedSkills) { for (const skill of installedSkills) {
const syncStatus = skill.syncedAgents.length > 0 const syncStatus = skill.syncedAgents.length > 0
? chalk.green(`synced to ${skill.syncedAgents.length} agents`) ? colors.success(`synced to ${skill.syncedAgents.length} agents`)
: chalk.yellow('not synced'); : colors.warning('not synced');
this.context.stdout.write(` ${chalk.green(skill.id)} v${skill.version} [${syncStatus}]\n`); this.context.stdout.write(` ${colors.success(skill.id)} v${skill.version} [${syncStatus}]\n`);
} }
} }
this.context.stdout.write(chalk.gray(`\nTotal: ${installedSkills.length} skills installed.\n`)); this.context.stdout.write(colors.muted(`\nTotal: ${installedSkills.length} skills installed.\n`));
return 0; return 0;
} }
} }
+12 -12
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { SessionManager } from '@skillkit/core'; import { SessionManager } from '@skillkit/core';
/** /**
@@ -36,35 +36,35 @@ export class PauseCommand extends Command {
const state = manager.get(); const state = manager.get();
if (!state) { if (!state) {
console.log(chalk.yellow('No active session found.')); warn('No active session found.');
return 1; return 1;
} }
if (!state.currentExecution) { if (!state.currentExecution) {
console.log(chalk.yellow('No skill execution in progress.')); warn('No skill execution in progress.');
return 1; return 1;
} }
if (state.currentExecution.status === 'paused') { if (state.currentExecution.status === 'paused') {
console.log(chalk.yellow('Execution is already paused.')); warn('Execution is already paused.');
console.log(chalk.dim('Resume with: skillkit resume')); console.log(colors.muted('Resume with: skillkit resume'));
return 0; return 0;
} }
const success = manager.pause(); const paused = manager.pause();
if (success) { if (paused) {
const exec = state.currentExecution; const exec = state.currentExecution;
console.log(chalk.green('✓ Execution paused')); success('✓ Execution paused');
console.log(); console.log();
console.log(` Skill: ${chalk.bold(exec.skillName)}`); console.log(` Skill: ${colors.bold(exec.skillName)}`);
console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks completed`); console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks completed`);
console.log(); console.log();
console.log(chalk.dim('Resume with: skillkit resume')); console.log(colors.muted('Resume with: skillkit resume'));
console.log(chalk.dim('View status: skillkit status')); console.log(colors.muted('View status: skillkit status'));
return 0; return 0;
} else { } else {
console.log(chalk.red('Failed to pause execution.')); error('Failed to pause execution.');
return 1; return 1;
} }
} }
+26 -26
View File
@@ -8,7 +8,7 @@ import { Command, Option } from 'clipanion';
import { join, isAbsolute, resolve, sep } from 'node:path'; import { join, isAbsolute, resolve, sep } from 'node:path';
import { homedir } from 'node:os'; import { homedir } from 'node:os';
import { existsSync, mkdirSync, copyFileSync, cpSync, rmSync } from 'node:fs'; import { existsSync, mkdirSync, copyFileSync, cpSync, rmSync } from 'node:fs';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { createPluginManager, loadPlugin, loadPluginsFromDirectory } from '@skillkit/core'; import { createPluginManager, loadPlugin, loadPluginsFromDirectory } from '@skillkit/core';
export class PluginCommand extends Command { export class PluginCommand extends Command {
@@ -67,12 +67,12 @@ export class PluginCommand extends Command {
case 'info': case 'info':
return this.pluginInfo(pluginManager); return this.pluginInfo(pluginManager);
default: default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`)); this.context.stderr.write(colors.error(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: list, install, uninstall, enable, disable, info\n'); this.context.stderr.write('Available actions: list, install, uninstall, enable, disable, info\n');
return 1; return 1;
} }
} catch (err) { } catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`)); this.context.stderr.write(colors.error(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1; return 1;
} }
} }
@@ -86,17 +86,17 @@ export class PluginCommand extends Command {
return 0; return 0;
} }
this.context.stdout.write(chalk.cyan(`Installed Plugins (${plugins.length}):\n\n`)); this.context.stdout.write(colors.cyan(`Installed Plugins (${plugins.length}):\n\n`));
for (const plugin of plugins) { for (const plugin of plugins) {
const enabled = pluginManager.isPluginEnabled(plugin.name); const enabled = pluginManager.isPluginEnabled(plugin.name);
const status = enabled const status = enabled
? chalk.green('enabled') ? colors.success('enabled')
: chalk.gray('disabled'); : colors.muted('disabled');
this.context.stdout.write(chalk.cyan(` ${plugin.name}`) + ` v${plugin.version} [${status}]\n`); this.context.stdout.write(colors.cyan(` ${plugin.name}`) + ` v${plugin.version} [${status}]\n`);
if (plugin.description) { if (plugin.description) {
this.context.stdout.write(chalk.gray(` ${plugin.description}\n`)); this.context.stdout.write(colors.muted(` ${plugin.description}\n`));
} }
} }
@@ -106,7 +106,7 @@ export class PluginCommand extends Command {
const commands = pluginManager.getAllCommands(); const commands = pluginManager.getAllCommands();
if (translators.size > 0 || providers.size > 0 || commands.length > 0) { if (translators.size > 0 || providers.size > 0 || commands.length > 0) {
this.context.stdout.write(chalk.cyan('\nRegistered Extensions:\n')); this.context.stdout.write(colors.cyan('\nRegistered Extensions:\n'));
if (translators.size > 0) { if (translators.size > 0) {
this.context.stdout.write(` Translators: ${Array.from(translators.keys()).join(', ')}\n`); this.context.stdout.write(` Translators: ${Array.from(translators.keys()).join(', ')}\n`);
} }
@@ -140,7 +140,7 @@ export class PluginCommand extends Command {
private async installPlugin(pluginManager: ReturnType<typeof createPluginManager>): Promise<number> { private async installPlugin(pluginManager: ReturnType<typeof createPluginManager>): Promise<number> {
if (!this.source) { if (!this.source) {
this.context.stderr.write(chalk.red('--source is required for install\n')); this.context.stderr.write(colors.error('--source is required for install\n'));
return 1; return 1;
} }
@@ -156,7 +156,7 @@ export class PluginCommand extends Command {
// Validate plugin name from metadata // Validate plugin name from metadata
const pluginName = plugin.metadata.name; const pluginName = plugin.metadata.name;
if (!this.isValidPluginName(pluginName)) { if (!this.isValidPluginName(pluginName)) {
this.context.stderr.write(chalk.red(`Invalid plugin name: ${pluginName}\n`)); this.context.stderr.write(colors.error(`Invalid plugin name: ${pluginName}\n`));
return 1; return 1;
} }
@@ -184,7 +184,7 @@ export class PluginCommand extends Command {
const resolvedTarget = resolve(targetDir); const resolvedTarget = resolve(targetDir);
const resolvedPluginsDir = resolve(pluginsDir); const resolvedPluginsDir = resolve(pluginsDir);
if (!resolvedTarget.startsWith(resolvedPluginsDir + sep)) { if (!resolvedTarget.startsWith(resolvedPluginsDir + sep)) {
this.context.stderr.write(chalk.red('Invalid plugin name\n')); this.context.stderr.write(colors.error('Invalid plugin name\n'));
return 1; return 1;
} }
@@ -217,12 +217,12 @@ export class PluginCommand extends Command {
copyFileSync(resolvedSource, join(targetDir, destFileName)); copyFileSync(resolvedSource, join(targetDir, destFileName));
} }
this.context.stdout.write(chalk.dim(` Copied to ${targetDir}\n`)); this.context.stdout.write(colors.muted(` Copied to ${targetDir}\n`));
} }
await pluginManager.register(plugin); await pluginManager.register(plugin);
this.context.stdout.write(chalk.green(`✓ Plugin "${plugin.metadata.name}" installed!\n`)); this.context.stdout.write(colors.success(`✓ Plugin "${plugin.metadata.name}" installed!\n`));
this.context.stdout.write(` Version: ${plugin.metadata.version}\n`); this.context.stdout.write(` Version: ${plugin.metadata.version}\n`);
if (plugin.metadata.description) { if (plugin.metadata.description) {
this.context.stdout.write(` ${plugin.metadata.description}\n`); this.context.stdout.write(` ${plugin.metadata.description}\n`);
@@ -244,13 +244,13 @@ export class PluginCommand extends Command {
private async uninstallPlugin(pluginManager: ReturnType<typeof createPluginManager>): Promise<number> { private async uninstallPlugin(pluginManager: ReturnType<typeof createPluginManager>): Promise<number> {
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name is required for uninstall\n')); this.context.stderr.write(colors.error('--name is required for uninstall\n'));
return 1; return 1;
} }
// Validate plugin name to prevent path traversal attacks // Validate plugin name to prevent path traversal attacks
if (!this.isValidPluginName(this.name)) { if (!this.isValidPluginName(this.name)) {
this.context.stderr.write(chalk.red('Invalid plugin name\n')); this.context.stderr.write(colors.error('Invalid plugin name\n'));
return 1; return 1;
} }
@@ -269,57 +269,57 @@ export class PluginCommand extends Command {
const resolvedPluginDir = resolve(pluginDir); const resolvedPluginDir = resolve(pluginDir);
const resolvedPluginsDir = resolve(pluginsDir); const resolvedPluginsDir = resolve(pluginsDir);
if (!resolvedPluginDir.startsWith(resolvedPluginsDir + sep)) { if (!resolvedPluginDir.startsWith(resolvedPluginsDir + sep)) {
this.context.stderr.write(chalk.red('Invalid plugin name\n')); this.context.stderr.write(colors.error('Invalid plugin name\n'));
return 1; return 1;
} }
if (existsSync(pluginDir)) { if (existsSync(pluginDir)) {
rmSync(pluginDir, { recursive: true, force: true }); rmSync(pluginDir, { recursive: true, force: true });
this.context.stdout.write(chalk.dim(` Removed ${pluginDir}\n`)); this.context.stdout.write(colors.muted(` Removed ${pluginDir}\n`));
} }
this.context.stdout.write(chalk.green(`✓ Plugin "${this.name}" uninstalled.\n`)); this.context.stdout.write(colors.success(`✓ Plugin "${this.name}" uninstalled.\n`));
return 0; return 0;
} }
private enablePlugin(pluginManager: ReturnType<typeof createPluginManager>): number { private enablePlugin(pluginManager: ReturnType<typeof createPluginManager>): number {
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name is required for enable\n')); this.context.stderr.write(colors.error('--name is required for enable\n'));
return 1; return 1;
} }
pluginManager.enablePlugin(this.name); pluginManager.enablePlugin(this.name);
this.context.stdout.write(chalk.green(`✓ Plugin "${this.name}" enabled.\n`)); this.context.stdout.write(colors.success(`✓ Plugin "${this.name}" enabled.\n`));
return 0; return 0;
} }
private disablePlugin(pluginManager: ReturnType<typeof createPluginManager>): number { private disablePlugin(pluginManager: ReturnType<typeof createPluginManager>): number {
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name is required for disable\n')); this.context.stderr.write(colors.error('--name is required for disable\n'));
return 1; return 1;
} }
pluginManager.disablePlugin(this.name); pluginManager.disablePlugin(this.name);
this.context.stdout.write(chalk.green(`✓ Plugin "${this.name}" disabled.\n`)); this.context.stdout.write(colors.success(`✓ Plugin "${this.name}" disabled.\n`));
return 0; return 0;
} }
private pluginInfo(pluginManager: ReturnType<typeof createPluginManager>): number { private pluginInfo(pluginManager: ReturnType<typeof createPluginManager>): number {
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name is required for info\n')); this.context.stderr.write(colors.error('--name is required for info\n'));
return 1; return 1;
} }
const plugin = pluginManager.getPlugin(this.name); const plugin = pluginManager.getPlugin(this.name);
if (!plugin) { if (!plugin) {
this.context.stderr.write(chalk.red(`Plugin "${this.name}" not found.\n`)); this.context.stderr.write(colors.error(`Plugin "${this.name}" not found.\n`));
return 1; return 1;
} }
const { metadata } = plugin; const { metadata } = plugin;
const enabled = pluginManager.isPluginEnabled(this.name); const enabled = pluginManager.isPluginEnabled(this.name);
this.context.stdout.write(chalk.cyan(`${metadata.name}`) + ` v${metadata.version}\n`); this.context.stdout.write(colors.cyan(`${metadata.name}`) + ` v${metadata.version}\n`);
this.context.stdout.write(`Status: ${enabled ? 'enabled' : 'disabled'}\n`); this.context.stdout.write(`Status: ${enabled ? 'enabled' : 'disabled'}\n`);
if (metadata.description) { if (metadata.description) {
this.context.stdout.write(`Description: ${metadata.description}\n`); this.context.stdout.write(`Description: ${metadata.description}\n`);
+68 -68
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, warn, error, step } from '../onboarding/index.js';
import { import {
type AgentType, type AgentType,
AgentType as AgentTypeSchema, AgentType as AgentTypeSchema,
@@ -22,13 +22,13 @@ export class PrimerCommand extends Command {
for AI coding agents. for AI coding agents.
By default, it generates instructions for detected agents in your project. By default, it generates instructions for detected agents in your project.
Use --all-agents to generate for all 44 supported agents. Use --all-agents to generate for all 45 supported agents.
Inspired by github.com/pierceboggan/primer but extended for all SkillKit agents. Inspired by github.com/pierceboggan/primer but extended for all SkillKit agents.
`, `,
examples: [ examples: [
['Generate for detected agents', '$0 primer'], ['Generate for detected agents', '$0 primer'],
['Generate for all 44 agents', '$0 primer --all-agents'], ['Generate for all 45 agents', '$0 primer --all-agents'],
['Generate for specific agents', '$0 primer --agent claude-code,cursor,github-copilot'], ['Generate for specific agents', '$0 primer --agent claude-code,cursor,github-copilot'],
['Custom output directory', '$0 primer --output ./instructions'], ['Custom output directory', '$0 primer --output ./instructions'],
['Preview without writing files', '$0 primer --dry-run'], ['Preview without writing files', '$0 primer --dry-run'],
@@ -42,7 +42,7 @@ export class PrimerCommand extends Command {
}); });
allAgents = Option.Boolean('--all-agents,-A', false, { allAgents = Option.Boolean('--all-agents,-A', false, {
description: 'Generate for all 44 supported agents', description: 'Generate for all 45 supported agents',
}); });
output = Option.String('--output,-o', { output = Option.String('--output,-o', {
@@ -96,7 +96,7 @@ export class PrimerCommand extends Command {
} }
private async runLearn(projectPath: string): Promise<number> { private async runLearn(projectPath: string): Promise<number> {
console.log(chalk.cyan('Analyzing codebase and extracting patterns...\n')); step('Analyzing codebase and extracting patterns...\n');
const analysis = analyzePrimer(projectPath); const analysis = analyzePrimer(projectPath);
if (this.verbose) { if (this.verbose) {
@@ -104,7 +104,7 @@ export class PrimerCommand extends Command {
console.log(); console.log();
} }
console.log(chalk.bold('Analyzing git history for patterns...\n')); console.log(colors.bold('Analyzing git history for patterns...\n'));
const gitResult = analyzeGitHistory(projectPath, { const gitResult = analyzeGitHistory(projectPath, {
commits: this.commits ? parseInt(this.commits) : 100, commits: this.commits ? parseInt(this.commits) : 100,
@@ -116,35 +116,35 @@ export class PrimerCommand extends Command {
console.log(); console.log();
if (gitResult.patterns.length === 0) { if (gitResult.patterns.length === 0) {
console.log(chalk.yellow('No learnable patterns found.')); warn('No learnable patterns found.');
return 0; return 0;
} }
console.log(chalk.bold(`Extracted ${gitResult.patterns.length} patterns:\n`)); console.log(colors.bold(`Extracted ${gitResult.patterns.length} patterns:\n`));
for (const pattern of gitResult.patterns.slice(0, 10)) { for (const pattern of gitResult.patterns.slice(0, 10)) {
const confidence = chalk.blue(`${(pattern.confidence * 100).toFixed(0)}%`); const confidence = colors.info(`${(pattern.confidence * 100).toFixed(0)}%`);
console.log(` ${chalk.dim('○')} ${pattern.title} [${pattern.category}] ${confidence}`); console.log(` ${colors.muted('○')} ${pattern.title} [${pattern.category}] ${confidence}`);
addPattern(pattern); addPattern(pattern);
} }
if (gitResult.patterns.length > 10) { if (gitResult.patterns.length > 10) {
console.log(chalk.dim(` ... and ${gitResult.patterns.length - 10} more saved`)); console.log(colors.muted(` ... and ${gitResult.patterns.length - 10} more saved`));
for (const pattern of gitResult.patterns.slice(10)) { for (const pattern of gitResult.patterns.slice(10)) {
addPattern(pattern); addPattern(pattern);
} }
} }
console.log(); console.log();
console.log(chalk.green(`✓ Saved ${gitResult.patterns.length} patterns`)); console.log(colors.success(`✓ Saved ${gitResult.patterns.length} patterns`));
console.log(chalk.dim('View with: skillkit learn --show')); console.log(colors.muted('View with: skillkit learn --show'));
console.log(chalk.dim('Approve with: skillkit pattern approve <id>')); console.log(colors.muted('Approve with: skillkit pattern approve <id>'));
return 0; return 0;
} }
private async runAnalysis(projectPath: string): Promise<number> { private async runAnalysis(projectPath: string): Promise<number> {
console.log(chalk.cyan('Analyzing codebase...\n')); step('Analyzing codebase...\n');
try { try {
const analysis = analyzePrimer(projectPath); const analysis = analyzePrimer(projectPath);
@@ -156,8 +156,8 @@ export class PrimerCommand extends Command {
this.printAnalysis(analysis); this.printAnalysis(analysis);
return 0; return 0;
} catch (error) { } catch (err) {
console.error(chalk.red('Analysis failed:'), error instanceof Error ? error.message : error); error('Analysis failed: ' + (err instanceof Error ? err.message : String(err)));
return 1; return 1;
} }
} }
@@ -165,7 +165,7 @@ export class PrimerCommand extends Command {
private async runGenerate(projectPath: string): Promise<number> { private async runGenerate(projectPath: string): Promise<number> {
const agents = this.parseAgents(); const agents = this.parseAgents();
console.log(chalk.cyan('Analyzing codebase and generating AI instructions...\n')); step('Analyzing codebase and generating AI instructions...\n');
try { try {
const result = generatePrimer(projectPath, { const result = generatePrimer(projectPath, {
@@ -183,37 +183,37 @@ export class PrimerCommand extends Command {
} }
if (result.generated.length === 0) { if (result.generated.length === 0) {
console.log(chalk.yellow('No instruction files generated.')); warn('No instruction files generated.');
if (result.errors.length > 0) { if (result.errors.length > 0) {
for (const error of result.errors) { for (const errMsg of result.errors) {
console.log(chalk.red(` Error: ${error}`)); console.log(colors.error(` Error: ${errMsg}`));
} }
} }
return 1; return 1;
} }
console.log(chalk.bold('Generated Instruction Files:\n')); console.log(colors.bold('Generated Instruction Files:\n'));
for (const instruction of result.generated) { for (const instruction of result.generated) {
const status = this.dryRun ? chalk.yellow('(dry-run)') : chalk.green('created'); const status = this.dryRun ? colors.warning('(dry-run)') : colors.success('created');
console.log(` ${chalk.green('●')} ${chalk.bold(instruction.agent)}`); console.log(` ${colors.success('●')} ${colors.bold(instruction.agent)}`);
console.log(` ${chalk.gray(instruction.filepath)} ${status}`); console.log(` ${colors.muted(instruction.filepath)} ${status}`);
} }
console.log(); console.log();
if (result.warnings.length > 0) { if (result.warnings.length > 0) {
console.log(chalk.yellow('Warnings:')); console.log(colors.warning('Warnings:'));
for (const warning of result.warnings) { for (const warningMsg of result.warnings) {
console.log(` ${chalk.yellow('⚠')} ${warning}`); console.log(` ${colors.warning('⚠')} ${warningMsg}`);
} }
console.log(); console.log();
} }
if (result.errors.length > 0) { if (result.errors.length > 0) {
console.log(chalk.red('Errors:')); console.log(colors.error('Errors:'));
for (const error of result.errors) { for (const errMsg of result.errors) {
console.log(` ${chalk.red('✗')} ${error}`); console.log(` ${colors.error('✗')} ${errMsg}`);
} }
console.log(); console.log();
} }
@@ -222,15 +222,15 @@ export class PrimerCommand extends Command {
? `Would generate ${result.generated.length} instruction file(s)` ? `Would generate ${result.generated.length} instruction file(s)`
: `Generated ${result.generated.length} instruction file(s)`; : `Generated ${result.generated.length} instruction file(s)`;
console.log(chalk.bold(summary)); console.log(colors.bold(summary));
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.gray('\n(Dry run - no files were written)')); console.log(colors.muted('\n(Dry run - no files were written)'));
} }
return result.success ? 0 : 1; return result.success ? 0 : 1;
} catch (error) { } catch (err) {
console.error(chalk.red('Generation failed:'), error instanceof Error ? error.message : error); error('Generation failed: ' + (err instanceof Error ? err.message : String(err)));
return 1; return 1;
} }
} }
@@ -246,7 +246,7 @@ export class PrimerCommand extends Command {
if (result.success) { if (result.success) {
agents.push(result.data); agents.push(result.data);
} else { } else {
console.warn(chalk.yellow(`Unknown agent: ${part}`)); warn(`Unknown agent: ${part}`);
} }
} }
@@ -256,8 +256,8 @@ export class PrimerCommand extends Command {
private printAnalysis(analysis: ReturnType<typeof analyzePrimer>): void { private printAnalysis(analysis: ReturnType<typeof analyzePrimer>): void {
const { project, languages, packageManagers, stack, structure, conventions, ci, docker, buildCommands, importantFiles } = analysis; const { project, languages, packageManagers, stack, structure, conventions, ci, docker, buildCommands, importantFiles } = analysis;
console.log(chalk.bold('Project Information')); console.log(colors.bold('Project Information'));
console.log(` Name: ${chalk.cyan(project.name)}`); console.log(` Name: ${colors.cyan(project.name)}`);
if (project.description) { if (project.description) {
console.log(` Description: ${project.description}`); console.log(` Description: ${project.description}`);
} }
@@ -270,67 +270,67 @@ export class PrimerCommand extends Command {
console.log(); console.log();
if (languages.length > 0) { if (languages.length > 0) {
console.log(chalk.bold('Languages')); console.log(colors.bold('Languages'));
for (const lang of languages) { for (const lang of languages) {
const version = lang.version ? ` (${lang.version})` : ''; const version = lang.version ? ` (${lang.version})` : '';
console.log(` ${chalk.green('●')} ${lang.name}${version}`); console.log(` ${colors.success('●')} ${lang.name}${version}`);
} }
console.log(); console.log();
} }
if (packageManagers.length > 0) { if (packageManagers.length > 0) {
console.log(chalk.bold('Package Managers')); console.log(colors.bold('Package Managers'));
console.log(` ${chalk.cyan(packageManagers.join(', '))}`); console.log(` ${colors.cyan(packageManagers.join(', '))}`);
console.log(); console.log();
} }
if (stack.frameworks.length > 0) { if (stack.frameworks.length > 0) {
console.log(chalk.bold('Frameworks')); console.log(colors.bold('Frameworks'));
for (const fw of stack.frameworks) { for (const fw of stack.frameworks) {
const version = fw.version ? ` (${fw.version})` : ''; const version = fw.version ? ` (${fw.version})` : '';
console.log(` ${chalk.green('●')} ${fw.name}${version}`); console.log(` ${colors.success('●')} ${fw.name}${version}`);
} }
console.log(); console.log();
} }
if (stack.libraries.length > 0) { if (stack.libraries.length > 0) {
console.log(chalk.bold('Libraries')); console.log(colors.bold('Libraries'));
for (const lib of stack.libraries.slice(0, 10)) { for (const lib of stack.libraries.slice(0, 10)) {
const version = lib.version ? ` (${lib.version})` : ''; const version = lib.version ? ` (${lib.version})` : '';
console.log(` ${chalk.green('●')} ${lib.name}${version}`); console.log(` ${colors.success('●')} ${lib.name}${version}`);
} }
if (stack.libraries.length > 10) { if (stack.libraries.length > 10) {
console.log(` ${chalk.gray(`...and ${stack.libraries.length - 10} more`)}`); console.log(` ${colors.muted(`...and ${stack.libraries.length - 10} more`)}`);
} }
console.log(); console.log();
} }
if (stack.styling.length > 0) { if (stack.styling.length > 0) {
console.log(chalk.bold('Styling')); console.log(colors.bold('Styling'));
for (const style of stack.styling) { for (const style of stack.styling) {
console.log(` ${chalk.green('●')} ${style.name}`); console.log(` ${colors.success('●')} ${style.name}`);
} }
console.log(); console.log();
} }
if (stack.testing.length > 0) { if (stack.testing.length > 0) {
console.log(chalk.bold('Testing')); console.log(colors.bold('Testing'));
for (const test of stack.testing) { for (const test of stack.testing) {
console.log(` ${chalk.green('●')} ${test.name}`); console.log(` ${colors.success('●')} ${test.name}`);
} }
console.log(); console.log();
} }
if (stack.databases.length > 0) { if (stack.databases.length > 0) {
console.log(chalk.bold('Databases')); console.log(colors.bold('Databases'));
for (const db of stack.databases) { for (const db of stack.databases) {
console.log(` ${chalk.green('●')} ${db.name}`); console.log(` ${colors.success('●')} ${db.name}`);
} }
console.log(); console.log();
} }
if (structure) { if (structure) {
console.log(chalk.bold('Project Structure')); console.log(colors.bold('Project Structure'));
if (structure.type) { if (structure.type) {
console.log(` Type: ${structure.type}`); console.log(` Type: ${structure.type}`);
} }
@@ -350,7 +350,7 @@ export class PrimerCommand extends Command {
} }
if (conventions && Object.keys(conventions).some(k => conventions[k as keyof typeof conventions] !== undefined)) { if (conventions && Object.keys(conventions).some(k => conventions[k as keyof typeof conventions] !== undefined)) {
console.log(chalk.bold('Code Conventions')); console.log(colors.bold('Code Conventions'));
if (conventions.indentation) { if (conventions.indentation) {
console.log(` Indentation: ${conventions.indentation}`); console.log(` Indentation: ${conventions.indentation}`);
} }
@@ -367,7 +367,7 @@ export class PrimerCommand extends Command {
} }
if (ci && ci.hasCI) { if (ci && ci.hasCI) {
console.log(chalk.bold('CI/CD')); console.log(colors.bold('CI/CD'));
console.log(` Provider: ${ci.provider}`); console.log(` Provider: ${ci.provider}`);
if (ci.hasCD) { if (ci.hasCD) {
console.log(` Deployment: Yes`); console.log(` Deployment: Yes`);
@@ -376,7 +376,7 @@ export class PrimerCommand extends Command {
} }
if (docker && (docker.hasDockerfile || docker.hasCompose)) { if (docker && (docker.hasDockerfile || docker.hasCompose)) {
console.log(chalk.bold('Docker')); console.log(colors.bold('Docker'));
if (docker.hasDockerfile) { if (docker.hasDockerfile) {
console.log(` Dockerfile: Yes`); console.log(` Dockerfile: Yes`);
if (docker.baseImage) { if (docker.baseImage) {
@@ -390,35 +390,35 @@ export class PrimerCommand extends Command {
} }
if (buildCommands && Object.keys(buildCommands).some(k => buildCommands[k as keyof typeof buildCommands])) { if (buildCommands && Object.keys(buildCommands).some(k => buildCommands[k as keyof typeof buildCommands])) {
console.log(chalk.bold('Build Commands')); console.log(colors.bold('Build Commands'));
if (buildCommands.install) { if (buildCommands.install) {
console.log(` Install: ${chalk.gray(buildCommands.install)}`); console.log(` Install: ${colors.muted(buildCommands.install)}`);
} }
if (buildCommands.dev) { if (buildCommands.dev) {
console.log(` Dev: ${chalk.gray(buildCommands.dev)}`); console.log(` Dev: ${colors.muted(buildCommands.dev)}`);
} }
if (buildCommands.build) { if (buildCommands.build) {
console.log(` Build: ${chalk.gray(buildCommands.build)}`); console.log(` Build: ${colors.muted(buildCommands.build)}`);
} }
if (buildCommands.test) { if (buildCommands.test) {
console.log(` Test: ${chalk.gray(buildCommands.test)}`); console.log(` Test: ${colors.muted(buildCommands.test)}`);
} }
console.log(); console.log();
} }
if (importantFiles.length > 0 && this.verbose) { if (importantFiles.length > 0 && this.verbose) {
console.log(chalk.bold('Important Files')); console.log(colors.bold('Important Files'));
for (const file of importantFiles.slice(0, 15)) { for (const file of importantFiles.slice(0, 15)) {
console.log(` ${chalk.gray(file)}`); console.log(` ${colors.muted(file)}`);
} }
if (importantFiles.length > 15) { if (importantFiles.length > 15) {
console.log(` ${chalk.gray(`...and ${importantFiles.length - 15} more`)}`); console.log(` ${colors.muted(`...and ${importantFiles.length - 15} more`)}`);
} }
console.log(); console.log();
} }
console.log(chalk.bold('Available Agents')); console.log(colors.bold('Available Agents'));
console.log(chalk.gray(` Use --all-agents to generate for all ${Object.keys(AGENT_CONFIG).length} agents`)); console.log(colors.muted(` Use --all-agents to generate for all ${Object.keys(AGENT_CONFIG).length} agents`));
console.log(chalk.gray(` Use --agent <name> to generate for specific agents`)); console.log(colors.muted(` Use --agent <name> to generate for specific agents`));
} }
} }
+23 -23
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { import {
getActiveProfile, getActiveProfile,
setActiveProfile, setActiveProfile,
@@ -35,48 +35,48 @@ export class ProfileCommand extends Command {
const profile = getProfile(this.name as ProfileName); const profile = getProfile(this.name as ProfileName);
if (!profile) { if (!profile) {
console.log(chalk.red(`Profile not found: ${this.name}`)); error(`Profile not found: ${this.name}`);
console.log(chalk.dim('Run `skillkit profile list` to see available profiles')); console.log(colors.muted('Run `skillkit profile list` to see available profiles'));
return 1; return 1;
} }
setActiveProfile(this.name as ProfileName); setActiveProfile(this.name as ProfileName);
console.log(chalk.green(`✓ Switched to ${profile.name} mode`)); success(`✓ Switched to ${profile.name} mode`);
console.log(chalk.dim(` Focus: ${profile.focus}`)); console.log(colors.muted(` Focus: ${profile.focus}`));
return 0; return 0;
} }
const active = getActiveProfile(); const active = getActiveProfile();
const profile = getProfile(active); const profile = getProfile(active);
console.log(chalk.cyan(`Current Profile: ${active}\n`)); console.log(colors.cyan(`Current Profile: ${active}\n`));
if (profile) { if (profile) {
console.log(`Description: ${profile.description}`); console.log(`Description: ${profile.description}`);
console.log(`Focus: ${profile.focus}`); console.log(`Focus: ${profile.focus}`);
console.log(); console.log();
console.log(chalk.bold('Behaviors:')); console.log(colors.bold('Behaviors:'));
for (const behavior of profile.behaviors) { for (const behavior of profile.behaviors) {
console.log(` • ${behavior}`); console.log(` • ${behavior}`);
} }
console.log(); console.log();
console.log(chalk.bold('Priorities:')); console.log(colors.bold('Priorities:'));
console.log(` ${profile.priorities.join(' > ')}`); console.log(` ${profile.priorities.join(' > ')}`);
if (profile.preferredTools?.length) { if (profile.preferredTools?.length) {
console.log(); console.log();
console.log(chalk.bold('Preferred Tools:')); console.log(colors.bold('Preferred Tools:'));
console.log(` ${profile.preferredTools.join(', ')}`); console.log(` ${profile.preferredTools.join(', ')}`);
} }
if (profile.avoidTools?.length) { if (profile.avoidTools?.length) {
console.log(chalk.bold('Avoid Tools:')); console.log(colors.bold('Avoid Tools:'));
console.log(` ${profile.avoidTools.join(', ')}`); console.log(` ${profile.avoidTools.join(', ')}`);
} }
} }
console.log(); console.log();
console.log(chalk.dim('Switch with: skillkit profile <name>')); console.log(colors.muted('Switch with: skillkit profile <name>'));
return 0; return 0;
} }
@@ -103,21 +103,21 @@ export class ProfileListCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan('Available Profiles:\n')); console.log(colors.cyan('Available Profiles:\n'));
for (const profile of profiles) { for (const profile of profiles) {
const isActive = profile.name === active; const isActive = profile.name === active;
const marker = isActive ? chalk.green('●') : chalk.dim('○'); const marker = isActive ? colors.success('●') : colors.muted('○');
const name = isActive ? chalk.bold(profile.name) : profile.name; const name = isActive ? colors.bold(profile.name) : profile.name;
const type = isBuiltinProfile(profile.name) ? '' : chalk.dim(' (custom)'); const type = isBuiltinProfile(profile.name) ? '' : colors.muted(' (custom)');
console.log(` ${marker} ${name}${type}`); console.log(` ${marker} ${name}${type}`);
console.log(` ${chalk.dim(profile.description)}`); console.log(` ${colors.muted(profile.description)}`);
console.log(` Focus: ${profile.focus}`); console.log(` Focus: ${profile.focus}`);
console.log(); console.log();
} }
console.log(chalk.dim('Switch with: skillkit profile <name>')); console.log(colors.muted('Switch with: skillkit profile <name>'));
return 0; return 0;
} }
@@ -149,7 +149,7 @@ export class ProfileCreateCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (isBuiltinProfile(this.name as ProfileName)) { if (isBuiltinProfile(this.name as ProfileName)) {
console.log(chalk.red(`Cannot create profile: ${this.name} is a built-in profile`)); error(`Cannot create profile: ${this.name} is a built-in profile`);
return 1; return 1;
} }
@@ -163,8 +163,8 @@ export class ProfileCreateCommand extends Command {
addCustomProfile(profile); addCustomProfile(profile);
console.log(chalk.green(`✓ Created profile: ${this.name}`)); success(`✓ Created profile: ${this.name}`);
console.log(chalk.dim('Edit ~/.skillkit/profiles.yaml to customize')); console.log(colors.muted('Edit ~/.skillkit/profiles.yaml to customize'));
return 0; return 0;
} }
@@ -182,18 +182,18 @@ export class ProfileRemoveCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (isBuiltinProfile(this.name as ProfileName)) { if (isBuiltinProfile(this.name as ProfileName)) {
console.log(chalk.red(`Cannot remove built-in profile: ${this.name}`)); error(`Cannot remove built-in profile: ${this.name}`);
return 1; return 1;
} }
const removed = removeCustomProfile(this.name as ProfileName); const removed = removeCustomProfile(this.name as ProfileName);
if (!removed) { if (!removed) {
console.log(chalk.yellow(`Profile not found: ${this.name}`)); warn(`Profile not found: ${this.name}`);
return 1; return 1;
} }
console.log(chalk.green(`✓ Removed profile: ${this.name}`)); success(`✓ Removed profile: ${this.name}`);
return 0; return 0;
} }
+168 -90
View File
@@ -7,7 +7,15 @@ import {
statSync, statSync,
} from "node:fs"; } from "node:fs";
import { join, basename, dirname, resolve, sep } from "node:path"; import { join, basename, dirname, resolve, sep } from "node:path";
import chalk from "chalk"; import {
colors,
warn,
success,
error,
step,
formatQualityBadge,
getQualityGradeFromScore,
} from "../onboarding/index.js";
import { Command, Option } from "clipanion"; import { Command, Option } from "clipanion";
import { import {
generateWellKnownIndex, generateWellKnownIndex,
@@ -15,7 +23,9 @@ import {
SkillScanner, SkillScanner,
formatSummary, formatSummary,
Severity, Severity,
evaluateSkillDirectory,
} from "@skillkit/core"; } from "@skillkit/core";
import { formatCount, timeAgo, fetchGitHubActivity } from "../helpers.js";
function sanitizeSkillName(name: string): string | null { function sanitizeSkillName(name: string): string | null {
if (!name || typeof name !== "string") return null; if (!name || typeof name !== "string") return null;
@@ -136,19 +146,19 @@ export class PublishCommand extends Command {
const basePath = this.skillPath || process.cwd(); const basePath = this.skillPath || process.cwd();
const outputDir = this.output || basePath; const outputDir = this.output || basePath;
console.log(chalk.cyan("Generating well-known skills structure...\n")); step("Generating well-known skills structure...\n");
const discoveredSkills = this.discoverSkills(basePath); const discoveredSkills = this.discoverSkills(basePath);
if (discoveredSkills.length === 0) { if (discoveredSkills.length === 0) {
console.error(chalk.red("No skills found")); error("No skills found");
console.error( console.error(
chalk.dim("Skills must contain a SKILL.md file with frontmatter"), colors.muted("Skills must contain a SKILL.md file with frontmatter"),
); );
return 1; return 1;
} }
console.log(chalk.white(`Found ${discoveredSkills.length} skill(s):\n`)); console.log(colors.primary(`Found ${discoveredSkills.length} skill(s):\n`));
const wellKnownSkills: WellKnownSkill[] = []; const wellKnownSkills: WellKnownSkill[] = [];
const validSkills: Array<{ const validSkills: Array<{
@@ -161,20 +171,18 @@ export class PublishCommand extends Command {
for (const skill of discoveredSkills) { for (const skill of discoveredSkills) {
const safeName = sanitizeSkillName(skill.name); const safeName = sanitizeSkillName(skill.name);
if (!safeName) { if (!safeName) {
console.log( warn(
chalk.yellow( ` ${colors.warning("⚠")} Skipping "${skill.name}" (invalid name - must be alphanumeric with hyphens/underscores)`,
` ${chalk.yellow("⚠")} Skipping "${skill.name}" (invalid name - must be alphanumeric with hyphens/underscores)`,
),
); );
continue; continue;
} }
const files = this.getSkillFiles(skill.path); const files = this.getSkillFiles(skill.path);
console.log(chalk.dim(` ${chalk.green("●")} ${safeName}`)); console.log(colors.muted(` ${colors.success("●")} ${safeName}`));
console.log( console.log(
chalk.dim(` Description: ${skill.description || "No description"}`), colors.muted(` Description: ${skill.description || "No description"}`),
); );
console.log(chalk.dim(` Files: ${files.join(", ")}`)); console.log(colors.muted(` Files: ${files.join(", ")}`));
validSkills.push({ validSkills.push({
name: skill.name, name: skill.name,
@@ -193,24 +201,20 @@ export class PublishCommand extends Command {
for (const skill of validSkills) { for (const skill of validSkills) {
const scanResult = await scanner.scan(skill.path); const scanResult = await scanner.scan(skill.path);
if (scanResult.verdict === "fail") { if (scanResult.verdict === "fail") {
console.error( error(`\nSecurity scan FAILED for "${skill.safeName}"`);
chalk.red(`\nSecurity scan FAILED for "${skill.safeName}"`),
);
console.error(formatSummary(scanResult)); console.error(formatSummary(scanResult));
console.error(chalk.dim("Fix security issues before publishing.")); console.error(colors.muted("Fix security issues before publishing."));
return 1; return 1;
} }
if (scanResult.verdict === "warn") { if (scanResult.verdict === "warn") {
console.log( warn(
chalk.yellow( ` Security warnings for "${skill.safeName}" (${scanResult.findings.length} findings)`,
` Security warnings for "${skill.safeName}" (${scanResult.findings.length} findings)`,
),
); );
} }
} }
if (validSkills.length === 0) { if (validSkills.length === 0) {
console.error(chalk.red("\nNo valid skills to publish")); error("\nNo valid skills to publish");
return 1; return 1;
} }
@@ -218,11 +222,11 @@ export class PublishCommand extends Command {
if (this.format === "mintlify") { if (this.format === "mintlify") {
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.yellow("Dry run - not writing files\n")); warn("Dry run - not writing files\n");
console.log(chalk.white("Would generate (Mintlify format):")); console.log(colors.primary("Would generate (Mintlify format):"));
for (const skill of validSkills) { for (const skill of validSkills) {
console.log( console.log(
chalk.dim( colors.muted(
` ${outputDir}/.well-known/skills/${skill.safeName}/skill.md`, ` ${outputDir}/.well-known/skills/${skill.safeName}/skill.md`,
), ),
); );
@@ -241,7 +245,7 @@ export class PublishCommand extends Command {
const resolvedDir = resolve(mintlifyDir); const resolvedDir = resolve(mintlifyDir);
if (!resolvedDir.startsWith(resolvedOutput + sep)) { if (!resolvedDir.startsWith(resolvedOutput + sep)) {
console.log( console.log(
chalk.red(`Skipping ${skill.safeName} (path traversal detected)`), colors.error(`Skipping ${skill.safeName} (path traversal detected)`),
); );
continue; continue;
} }
@@ -253,26 +257,26 @@ export class PublishCommand extends Command {
} }
} }
console.log(chalk.green("Generated Mintlify well-known structure:\n")); success("Generated Mintlify well-known structure:\n");
for (const skill of validSkills) { for (const skill of validSkills) {
console.log( console.log(
chalk.dim( colors.muted(
` ${outputDir}/.well-known/skills/${skill.safeName}/skill.md`, ` ${outputDir}/.well-known/skills/${skill.safeName}/skill.md`,
), ),
); );
} }
console.log(""); console.log("");
console.log(chalk.cyan("Next steps:")); step("Next steps:");
console.log( console.log(
chalk.dim(" 1. Deploy the .well-known directory to your web server"), colors.muted(" 1. Deploy the .well-known directory to your web server"),
); );
console.log( console.log(
chalk.dim( colors.muted(
" 2. Users can install via: skillkit install https://your-domain.com", " 2. Users can install via: skillkit install https://your-domain.com",
), ),
); );
console.log( console.log(
chalk.dim( colors.muted(
" 3. Skills auto-discovered from /.well-known/skills/{name}/skill.md", " 3. Skills auto-discovered from /.well-known/skills/{name}/skill.md",
), ),
); );
@@ -280,20 +284,20 @@ export class PublishCommand extends Command {
} }
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.yellow("Dry run - not writing files\n")); warn("Dry run - not writing files\n");
console.log(chalk.white("Would generate:")); console.log(colors.primary("Would generate:"));
console.log(chalk.dim(` ${outputDir}/.well-known/skills/index.json`)); console.log(colors.muted(` ${outputDir}/.well-known/skills/index.json`));
for (const skill of wellKnownSkills) { for (const skill of wellKnownSkills) {
for (const file of skill.files) { for (const file of skill.files) {
console.log( console.log(
chalk.dim( colors.muted(
` ${outputDir}/.well-known/skills/${skill.name}/${file}`, ` ${outputDir}/.well-known/skills/${skill.name}/${file}`,
), ),
); );
} }
} }
console.log(""); console.log("");
console.log(chalk.white("index.json preview:")); console.log(colors.primary("index.json preview:"));
console.log( console.log(
JSON.stringify(generateWellKnownIndex(wellKnownSkills), null, 2), JSON.stringify(generateWellKnownIndex(wellKnownSkills), null, 2),
); );
@@ -309,9 +313,7 @@ export class PublishCommand extends Command {
const resolvedWellKnownDir = resolve(wellKnownDir); const resolvedWellKnownDir = resolve(wellKnownDir);
if (!resolvedSkillDir.startsWith(resolvedWellKnownDir + sep)) { if (!resolvedSkillDir.startsWith(resolvedWellKnownDir + sep)) {
console.log( warn(` Skipping "${skill.name}" (path traversal detected)`);
chalk.yellow(` Skipping "${skill.name}" (path traversal detected)`),
);
continue; continue;
} }
@@ -333,24 +335,24 @@ export class PublishCommand extends Command {
JSON.stringify(index, null, 2), JSON.stringify(index, null, 2),
); );
console.log(chalk.green("Generated well-known structure:\n")); success("Generated well-known structure:\n");
console.log(chalk.dim(` ${wellKnownDir}/index.json`)); console.log(colors.muted(` ${wellKnownDir}/index.json`));
for (const skill of wellKnownSkills) { for (const skill of wellKnownSkills) {
console.log(chalk.dim(` ${wellKnownDir}/${skill.name}/`)); console.log(colors.muted(` ${wellKnownDir}/${skill.name}/`));
} }
console.log(""); console.log("");
console.log(chalk.cyan("Next steps:")); step("Next steps:");
console.log( console.log(
chalk.dim(" 1. Deploy the .well-known directory to your web server"), colors.muted(" 1. Deploy the .well-known directory to your web server"),
); );
console.log( console.log(
chalk.dim( colors.muted(
" 2. Users can install via: skillkit add https://your-domain.com", " 2. Users can install via: skillkit add https://your-domain.com",
), ),
); );
console.log( console.log(
chalk.dim( colors.muted(
" 3. Skills auto-discovered from /.well-known/skills/index.json", " 3. Skills auto-discovered from /.well-known/skills/index.json",
), ),
); );
@@ -456,14 +458,14 @@ export class PublishSubmitCommand extends Command {
const skillMdPath = this.findSkillMd(skillPath); const skillMdPath = this.findSkillMd(skillPath);
if (!skillMdPath) { if (!skillMdPath) {
console.error(chalk.red("No SKILL.md found")); error("No SKILL.md found");
console.error( console.error(
chalk.dim("Run this command from a directory containing SKILL.md"), colors.muted("Run this command from a directory containing SKILL.md"),
); );
return 1; return 1;
} }
console.log(chalk.cyan("Submitting skill to SkillKit marketplace...\n")); step("Submitting skill to SkillKit marketplace...\n");
const content = readFileSync(skillMdPath, "utf-8"); const content = readFileSync(skillMdPath, "utf-8");
const frontmatter = this.parseFrontmatter(content); const frontmatter = this.parseFrontmatter(content);
@@ -472,9 +474,9 @@ export class PublishSubmitCommand extends Command {
const repoInfo = await this.getRepoInfo(dirname(skillMdPath)); const repoInfo = await this.getRepoInfo(dirname(skillMdPath));
if (!repoInfo) { if (!repoInfo) {
console.error(chalk.red("Not a git repository or no remote configured")); error("Not a git repository or no remote configured");
console.error( console.error(
chalk.dim( colors.muted(
"Your skill must be in a git repository with a GitHub remote", "Your skill must be in a git repository with a GitHub remote",
), ),
); );
@@ -483,11 +485,19 @@ export class PublishSubmitCommand extends Command {
const skillSlug = this.slugify(skillName); const skillSlug = this.slugify(skillName);
if (!skillSlug) { if (!skillSlug) {
console.error(chalk.red("Skill name produces an empty slug.")); error("Skill name produces an empty slug.");
console.error(chalk.dim("Please pass --name with letters or numbers.")); console.error(colors.muted("Please pass --name with letters or numbers."));
return 1; return 1;
} }
const skillDir = dirname(skillMdPath);
const quality = evaluateSkillDirectory(skillDir);
const qualityScore = quality?.overall ?? null;
const qualityGrade = qualityScore !== null ? getQualityGradeFromScore(qualityScore) : null;
const qualityBadge = qualityScore !== null ? formatQualityBadge(qualityScore) : "N/A";
const activity = await fetchGitHubActivity(repoInfo.owner, repoInfo.repo);
const skillEntry = { const skillEntry = {
id: `${repoInfo.owner}/${repoInfo.repo}/${skillSlug}`, id: `${repoInfo.owner}/${repoInfo.repo}/${skillSlug}`,
name: this.formatName(skillName), name: this.formatName(skillName),
@@ -498,47 +508,88 @@ export class PublishSubmitCommand extends Command {
tags: frontmatter.tags || ["general"], tags: frontmatter.tags || ["general"],
}; };
console.log(chalk.white("Skill details:")); console.log(colors.primary("Skill details:"));
console.log(chalk.dim(` ID: ${skillEntry.id}`)); console.log(colors.muted(` ID: ${skillEntry.id}`));
console.log(chalk.dim(` Name: ${skillEntry.name}`)); console.log(colors.muted(` Name: ${skillEntry.name}`));
console.log(chalk.dim(` Description: ${skillEntry.description}`)); console.log(colors.muted(` Description: ${skillEntry.description}`));
console.log(chalk.dim(` Source: ${skillEntry.source}`)); console.log(colors.muted(` Source: ${skillEntry.source}`));
console.log(chalk.dim(` Tags: ${skillEntry.tags.join(", ")}`)); console.log(colors.muted(` Tags: ${skillEntry.tags.join(", ")}`));
console.log(colors.muted(` Quality: ${qualityBadge}${qualityScore !== null ? ` (${qualityScore}/100)` : ""}`));
if (activity) {
const stars = formatCount(activity.stars);
const pushed = activity.pushedAt ? timeAgo(activity.pushedAt) : "unknown";
console.log(colors.muted(` Stars: ${stars}`));
console.log(colors.muted(` Last push: ${pushed}`));
}
if (quality && quality.warnings.length > 0) {
console.log(colors.warning(` Warnings:`));
for (const w of quality.warnings.slice(0, 3)) {
console.log(colors.muted(` - ${w}`));
}
}
console.log(); console.log();
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.yellow("Dry run - not submitting")); warn("Dry run - not submitting");
console.log(JSON.stringify(skillEntry, null, 2)); console.log(JSON.stringify(skillEntry, null, 2));
return 0; return 0;
} }
const issueBody = this.createIssueBody(skillEntry); const issueBody = this.createIssueBody(skillEntry, {
const issueTitle = encodeURIComponent(`[Publish] ${skillEntry.name}`); qualityScore,
const issueBodyEncoded = encodeURIComponent(issueBody); qualityGrade,
const issueUrl = `https://github.com/rohitg00/skillkit/issues/new?title=${issueTitle}&body=${issueBodyEncoded}&labels=skill-submission,publish`; warnings: quality?.warnings ?? [],
stars: activity?.stars ?? null,
console.log(chalk.green("Opening GitHub to submit your skill...\n")); pushedAt: activity?.pushedAt ?? null,
});
try { try {
const { execFileSync } = await import("node:child_process"); const { execFileSync } = await import("node:child_process");
const cmd = const result = execFileSync(
process.platform === "darwin" "gh",
? "open" [
: process.platform === "win32" "issue",
? "cmd" "create",
: "xdg-open"; "--repo",
const args = "rohitg00/skillkit",
process.platform === "win32" "--title",
? ["/c", "start", "", issueUrl] `[Publish] ${skillEntry.name}`,
: [issueUrl]; "--body",
execFileSync(cmd, args, { stdio: "ignore" }); issueBody,
"--label",
"skill-submission,publish",
],
{
encoding: "utf-8",
stdio: ["pipe", "pipe", "pipe"],
timeout: 15_000,
},
).trim();
console.log(chalk.green("GitHub issue page opened!")); success("Submission created!");
console.log(chalk.dim("Review and submit the issue.")); if (result) {
} catch { console.log(colors.muted(` ${result}`));
console.log(chalk.yellow("Could not open browser automatically.")); }
console.log(chalk.dim("Please open this URL manually:\n")); } catch (err) {
console.log(chalk.cyan(issueUrl)); const message = err instanceof Error ? err.message : String(err);
if (message.includes("not found") || message.includes("ENOENT")) {
error("GitHub CLI (gh) is not installed");
console.error(
colors.muted("Install it from https://cli.github.com then run `gh auth login`"),
);
} else if (message.includes("auth") || message.includes("401")) {
error("GitHub CLI is not authenticated");
console.error(colors.muted("Run `gh auth login` first"));
} else {
error("Failed to create issue");
console.error(colors.muted(message));
}
console.log();
warn("You can submit manually instead:");
const manualUrl = `https://github.com/rohitg00/skillkit/issues/new?title=${encodeURIComponent(`[Publish] ${skillEntry.name}`)}&labels=skill-submission,publish`;
console.log(colors.cyan(manualUrl));
return 1;
} }
return 0; return 0;
@@ -609,13 +660,36 @@ export class PublishSubmitCommand extends Command {
.join(" "); .join(" ");
} }
private createIssueBody(skill: { private createIssueBody(
id: string; skill: {
name: string; id: string;
description: string; name: string;
source: string; description: string;
tags: string[]; source: string;
}): string { tags: string[];
},
meta: {
qualityScore: number | null;
qualityGrade: string | null;
warnings: string[];
stars: number | null;
pushedAt: string | null;
},
): string {
const qualityLine =
meta.qualityScore !== null
? `- **Quality:** ${meta.qualityGrade} (${meta.qualityScore}/100)`
: "- **Quality:** N/A";
const starsLine =
typeof meta.stars === "number" ? `- **Stars:** ${formatCount(meta.stars)}` : "";
const pushLine = meta.pushedAt
? `- **Last push:** ${meta.pushedAt.slice(0, 10)}`
: "";
const warningLines =
meta.warnings.length > 0
? `\n### Warnings\n${meta.warnings.map((w) => `- ${w}`).join("\n")}`
: "";
return `## Publish Skill Request return `## Publish Skill Request
### Skill Details ### Skill Details
@@ -624,6 +698,10 @@ export class PublishSubmitCommand extends Command {
- **Description:** ${skill.description} - **Description:** ${skill.description}
- **Source:** [${skill.source}](https://github.com/${skill.source}) - **Source:** [${skill.source}](https://github.com/${skill.source})
- **Tags:** ${skill.tags.map((t) => `\`${t}\``).join(", ")} - **Tags:** ${skill.tags.map((t) => `\`${t}\``).join(", ")}
${qualityLine}
${starsLine}
${pushLine}
${warningLines}
### JSON Entry ### JSON Entry
\`\`\`json \`\`\`json
+8 -8
View File
@@ -1,4 +1,4 @@
import chalk from 'chalk'; import { colors, warn, error } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { findSkill, readSkillContent } from '@skillkit/core'; import { findSkill, readSkillContent } from '@skillkit/core';
import { getSearchDirs } from '../helpers.js'; import { getSearchDirs } from '../helpers.js';
@@ -30,7 +30,7 @@ export class ReadCommand extends Command {
.filter(s => s.length > 0); .filter(s => s.length > 0);
if (skillNames.length === 0) { if (skillNames.length === 0) {
console.error(chalk.red('No skill names provided')); error('No skill names provided');
return 1; return 1;
} }
@@ -40,16 +40,16 @@ export class ReadCommand extends Command {
const skill = findSkill(skillName, searchDirs); const skill = findSkill(skillName, searchDirs);
if (!skill) { if (!skill) {
console.error(chalk.red(`Skill not found: ${skillName}`)); error(`Skill not found: ${skillName}`);
console.error(chalk.dim('Available directories:')); console.log(colors.muted('Available directories:'));
searchDirs.forEach(d => console.error(chalk.dim(` - ${d}`))); searchDirs.forEach(d => console.log(colors.muted(` - ${d}`)));
exitCode = 1; exitCode = 1;
continue; continue;
} }
if (!skill.enabled) { if (!skill.enabled) {
console.error(chalk.yellow(`Skill disabled: ${skillName}`)); warn(`Skill disabled: ${skillName}`);
console.error(chalk.dim('Enable with: skillkit enable ' + skillName)); console.log(colors.muted('Enable with: skillkit enable ' + skillName));
exitCode = 1; exitCode = 1;
continue; continue;
} }
@@ -57,7 +57,7 @@ export class ReadCommand extends Command {
const content = readSkillContent(skill.path); const content = readSkillContent(skill.path);
if (!content) { if (!content) {
console.error(chalk.red(`Could not read SKILL.md for: ${skillName}`)); error(`Could not read SKILL.md for: ${skillName}`);
exitCode = 1; exitCode = 1;
continue; continue;
} }
+70 -24
View File
@@ -1,8 +1,8 @@
import { existsSync, rmSync, readFileSync, writeFileSync } from 'node:fs'; import { existsSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
import { join } from 'node:path'; import { join, dirname, basename } from 'node:path';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { findSkill, AgentsMdParser, AgentsMdGenerator } from '@skillkit/core'; import { findSkill, findAllSkills, loadMetadata, AgentsMdParser, AgentsMdGenerator, removeSkillFromLock } from '@skillkit/core';
import { getSearchDirs } from '../helpers.js'; import { getSearchDirs } from '../helpers.js';
export class RemoveCommand extends Command { export class RemoveCommand extends Command {
@@ -13,11 +13,21 @@ export class RemoveCommand extends Command {
examples: [ examples: [
['Remove a skill', '$0 remove pdf'], ['Remove a skill', '$0 remove pdf'],
['Remove multiple skills', '$0 remove pdf xlsx docx'], ['Remove multiple skills', '$0 remove pdf xlsx docx'],
['Force removal without confirmation', '$0 remove pdf --force'], ['Remove all skills from a source', '$0 remove --source iii-hq/iii'],
['Remove all installed skills', '$0 remove --all'],
['Force removal without confirmation', '$0 remove --all --force'],
], ],
}); });
skills = Option.Rest({ required: 1 }); skills = Option.Rest({ required: 0 });
all = Option.Boolean('--all,-a', false, {
description: 'Remove all installed skills',
});
source = Option.String('--source,-s', {
description: 'Remove all skills installed from this source (e.g. iii-hq/iii)',
});
force = Option.Boolean('--force,-f', false, { force = Option.Boolean('--force,-f', false, {
description: 'Skip confirmation', description: 'Skip confirmation',
@@ -25,29 +35,65 @@ export class RemoveCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
const searchDirs = getSearchDirs(); const searchDirs = getSearchDirs();
if (!this.all && !this.source && this.skills.length === 0) {
error('Provide skill names, --source, or --all');
return 1;
}
let skillsToRemove: Array<{ name: string; path: string }> = [];
if (this.all || this.source) {
const allSkills = findAllSkills(searchDirs);
if (this.source) {
skillsToRemove = allSkills.filter((s) => {
const meta = loadMetadata(s.path);
return meta?.source?.includes(this.source!) ?? false;
}).map((s) => ({ name: s.name, path: s.path }));
if (skillsToRemove.length === 0) {
warn(`No skills found from source: ${this.source}`);
return 0;
}
} else {
skillsToRemove = allSkills.map((s) => ({ name: s.name, path: s.path }));
if (skillsToRemove.length === 0) {
warn('No installed skills found');
return 0;
}
}
console.log(colors.muted(`Found ${skillsToRemove.length} skill(s) to remove`));
} else {
for (const skillName of this.skills) {
const skill = findSkill(skillName, searchDirs);
if (!skill) {
warn(`Skill not found: ${skillName}`);
continue;
}
skillsToRemove.push({ name: skill.name, path: skill.path });
}
}
let removed = 0; let removed = 0;
let failed = 0; let failed = 0;
for (const skillName of this.skills) { for (const { name: skillName, path: skillPath } of skillsToRemove) {
const skill = findSkill(skillName, searchDirs); if (!existsSync(skillPath)) {
warn(`Path not found: ${skillPath}`);
if (!skill) {
console.log(chalk.yellow(`Skill not found: ${skillName}`));
continue;
}
if (!existsSync(skill.path)) {
console.log(chalk.yellow(`Path not found: ${skill.path}`));
continue; continue;
} }
try { try {
rmSync(skill.path, { recursive: true, force: true }); rmSync(skillPath, { recursive: true, force: true });
console.log(chalk.green(`Removed: ${skillName}`)); if (skillPath.endsWith('.md')) {
const metaSibling = join(dirname(skillPath), `.${basename(skillPath, '.md')}.skillkit.json`);
if (existsSync(metaSibling)) rmSync(metaSibling);
}
removeSkillFromLock(skillName);
success(`Removed: ${skillName}`);
removed++; removed++;
} catch (error) { } catch (err) {
console.log(chalk.red(`Failed to remove: ${skillName}`)); error(`Failed to remove: ${skillName}`);
console.error(chalk.dim(error instanceof Error ? error.message : String(error))); console.error(colors.muted(err instanceof Error ? err.message : String(err)));
failed++; failed++;
} }
} }
@@ -65,11 +111,11 @@ export class RemoveCommand extends Command {
writeFileSync(agentsMdPath, updated, 'utf-8'); writeFileSync(agentsMdPath, updated, 'utf-8');
} }
} }
} catch (error) { } catch (err) {
console.log(chalk.yellow('Warning: Failed to update AGENTS.md')); warn('Warning: Failed to update AGENTS.md');
console.error(chalk.dim(error instanceof Error ? error.message : String(error))); console.error(colors.muted(err instanceof Error ? err.message : String(err)));
} }
console.log(chalk.dim('\nRun `skillkit sync` to update your agent config')); console.log(colors.muted('\nRun `skillkit sync` to update your agent config'));
} }
return failed > 0 ? 1 : 0; return failed > 0 ? 1 : 0;
+14 -15
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { SessionManager } from '@skillkit/core'; import { SessionManager } from '@skillkit/core';
/** /**
@@ -36,47 +36,46 @@ export class ResumeCommand extends Command {
const state = manager.get(); const state = manager.get();
if (!state) { if (!state) {
console.log(chalk.yellow('No active session found.')); warn('No active session found.');
return 1; return 1;
} }
if (!state.currentExecution) { if (!state.currentExecution) {
console.log(chalk.yellow('No skill execution to resume.')); warn('No skill execution to resume.');
console.log(chalk.dim('Start a new execution with: skillkit run <skill>')); console.log(colors.muted('Start a new execution with: skillkit run <skill>'));
return 1; return 1;
} }
if (state.currentExecution.status !== 'paused') { if (state.currentExecution.status !== 'paused') {
if (state.currentExecution.status === 'running') { if (state.currentExecution.status === 'running') {
console.log(chalk.yellow('Execution is already running.')); warn('Execution is already running.');
} else { } else {
console.log(chalk.yellow(`Execution is ${state.currentExecution.status}.`)); warn(`Execution is ${state.currentExecution.status}.`);
} }
return 1; return 1;
} }
const success = manager.resume(); const resumed = manager.resume();
if (success) { if (resumed) {
const exec = state.currentExecution; const exec = state.currentExecution;
console.log(chalk.green('✓ Execution resumed')); success('✓ Execution resumed');
console.log(); console.log();
console.log(` Skill: ${chalk.bold(exec.skillName)}`); console.log(` Skill: ${colors.bold(exec.skillName)}`);
console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks`); console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks`);
console.log(); console.log();
// Show next task
const nextTask = exec.tasks.find((t) => t.status === 'pending' || t.status === 'in_progress'); const nextTask = exec.tasks.find((t) => t.status === 'pending' || t.status === 'in_progress');
if (nextTask) { if (nextTask) {
console.log(` Next task: ${chalk.cyan(nextTask.name)}`); console.log(` Next task: ${colors.cyan(nextTask.name)}`);
} }
console.log(); console.log();
console.log(chalk.dim('The execution will continue from where it left off.')); console.log(colors.muted('The execution will continue from where it left off.'));
console.log(chalk.dim('View status: skillkit status')); console.log(colors.muted('View status: skillkit status'));
return 0; return 0;
} else { } else {
console.log(chalk.red('Failed to resume execution.')); error('Failed to resume execution.');
return 1; return 1;
} }
} }
+40 -45
View File
@@ -1,8 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve, join } from 'node:path'; import { resolve, join } from 'node:path';
import { existsSync, readFileSync, statSync } from 'node:fs'; import { existsSync, readFileSync, statSync } from 'node:fs';
import chalk from 'chalk'; import { colors, step, success, error, spinner } from '../onboarding/index.js';
import ora from 'ora';
import { import {
createExecutionEngine, createExecutionEngine,
discoverSkills, discoverSkills,
@@ -89,22 +88,20 @@ export class RunCommand extends Command {
return 1; return 1;
} }
// Show skill info
if (!this.json) { if (!this.json) {
console.log(chalk.cyan(`Executing skill: ${chalk.bold(skill.name)}`)); step(`Executing skill: ${colors.bold(skill.name)}`);
if (skill.description) { if (skill.description) {
console.log(chalk.dim(skill.description)); console.log(colors.muted(skill.description));
} }
console.log(); console.log();
} }
// Dry run mode
if (this.dryRun) { if (this.dryRun) {
this.showDryRun(skill); this.showDryRun(skill);
return 0; return 0;
} }
const spinner = ora(); const oraSpinner = spinner();
let currentTask = ''; let currentTask = '';
// Create execution engine // Create execution engine
@@ -115,38 +112,38 @@ export class RunCommand extends Command {
switch (event.type) { switch (event.type) {
case 'task_start': case 'task_start':
currentTask = event.taskName || ''; currentTask = event.taskName || '';
spinner.start(`Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`); oraSpinner.start(`Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`);
break; break;
case 'task_complete': case 'task_complete': {
const icon = event.status === 'completed' ? chalk.green('✓') : chalk.red('✗'); const icon = event.status === 'completed' ? colors.success('✓') : colors.error('✗');
spinner.stopAndPersist({ oraSpinner.stop();
symbol: icon, console.log(`${icon} Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`);
text: `Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`,
});
if (event.error && this.verbose) { if (event.error && this.verbose) {
console.log(chalk.red(` Error: ${event.error}`)); console.log(colors.error(` Error: ${event.error}`));
} }
break; break;
}
case 'checkpoint': case 'checkpoint':
spinner.info(`Checkpoint: ${event.message}`); oraSpinner.stop();
console.log(`Checkpoint: ${event.message}`);
break; break;
case 'verification': case 'verification':
if (this.verbose) { if (this.verbose) {
console.log(chalk.dim(` ${event.message}`)); console.log(colors.muted(` ${event.message}`));
} }
break; break;
case 'complete': case 'complete':
console.log(); console.log();
if (event.status === 'completed') { if (event.status === 'completed') {
console.log(chalk.green('✓ Skill execution completed')); success('✓ Skill execution completed');
} else { } else {
console.log(chalk.red(`✗ Skill execution ${event.status}`)); error(`✗ Skill execution ${event.status}`);
if (event.error) { if (event.error) {
console.log(chalk.red(` Error: ${event.error}`)); console.log(colors.error(` Error: ${event.error}`));
} }
} }
break; break;
@@ -176,18 +173,17 @@ export class RunCommand extends Command {
if (this.json) { if (this.json) {
console.log(JSON.stringify(result, null, 2)); console.log(JSON.stringify(result, null, 2));
} else { } else {
// Show summary
console.log(); console.log();
console.log(chalk.cyan('Summary:')); step('Summary:');
console.log(` Duration: ${chalk.dim(this.formatDuration(result.durationMs || 0))}`); console.log(` Duration: ${colors.muted(this.formatDuration(result.durationMs || 0))}`);
console.log(` Tasks: ${chalk.dim(`${result.tasks.filter(t => t.status === 'completed').length}/${result.tasks.length} completed`)}`); console.log(` Tasks: ${colors.muted(`${result.tasks.filter(t => t.status === 'completed').length}/${result.tasks.length} completed`)}`);
if (result.filesModified.length > 0) { if (result.filesModified.length > 0) {
console.log(` Files modified: ${chalk.dim(result.filesModified.length.toString())}`); console.log(` Files modified: ${colors.muted(result.filesModified.length.toString())}`);
} }
if (result.commits.length > 0) { if (result.commits.length > 0) {
console.log(` Commits: ${chalk.dim(result.commits.join(', '))}`); console.log(` Commits: ${colors.muted(result.commits.join(', '))}`);
} }
} }
@@ -206,14 +202,14 @@ export class RunCommand extends Command {
return skill; return skill;
} }
console.error(chalk.red(`Skill "${this.skillRef}" not found`)); console.error(colors.error(`Skill "${this.skillRef}" not found`));
console.log(chalk.dim('Install skills with: skillkit install <source>')); console.log(colors.muted('Install skills with: skillkit install <source>'));
return null; return null;
} }
private loadSkillFromFile(filePath: string): ExecutableSkill | null { private loadSkillFromFile(filePath: string): ExecutableSkill | null {
if (!existsSync(filePath)) { if (!existsSync(filePath)) {
console.error(chalk.red(`File not found: ${filePath}`)); console.error(colors.error(`File not found: ${filePath}`));
return null; return null;
} }
@@ -221,7 +217,6 @@ export class RunCommand extends Command {
const content = readFileSync(filePath, 'utf-8'); const content = readFileSync(filePath, 'utf-8');
const frontmatter = extractFrontmatter(content); const frontmatter = extractFrontmatter(content);
// Parse tasks from frontmatter if present
const tasks = this.parseTasksFromFrontmatter(frontmatter); const tasks = this.parseTasksFromFrontmatter(frontmatter);
return { return {
@@ -232,8 +227,8 @@ export class RunCommand extends Command {
content, content,
tasks, tasks,
}; };
} catch (error) { } catch (err) {
console.error(chalk.red(`Failed to load skill: ${error}`)); console.error(colors.error(`Failed to load skill: ${err}`));
return null; return null;
} }
} }
@@ -281,46 +276,46 @@ export class RunCommand extends Command {
} }
private showDryRun(skill: ExecutableSkill): void { private showDryRun(skill: ExecutableSkill): void {
console.log(chalk.cyan('Dry Run - Execution Plan')); step('Dry Run - Execution Plan');
console.log(); console.log();
console.log(`Skill: ${chalk.bold(skill.name)}`); console.log(`Skill: ${colors.bold(skill.name)}`);
if (skill.description) { if (skill.description) {
console.log(`Description: ${chalk.dim(skill.description)}`); console.log(`Description: ${colors.muted(skill.description)}`);
} }
console.log(`Source: ${chalk.dim(skill.source)}`); console.log(`Source: ${colors.muted(skill.source)}`);
console.log(); console.log();
if (skill.tasks && skill.tasks.length > 0) { if (skill.tasks && skill.tasks.length > 0) {
console.log(chalk.cyan('Tasks:')); step('Tasks:');
for (let i = 0; i < skill.tasks.length; i++) { for (let i = 0; i < skill.tasks.length; i++) {
const task = skill.tasks[i]; const task = skill.tasks[i];
const typeLabel = this.getTaskTypeLabel(task.type); const typeLabel = this.getTaskTypeLabel(task.type);
console.log(` ${i + 1}. ${task.name} ${typeLabel}`); console.log(` ${i + 1}. ${task.name} ${typeLabel}`);
if (task.action) { if (task.action) {
console.log(` ${chalk.dim(task.action)}`); console.log(` ${colors.muted(task.action)}`);
} }
if (task.files && task.files.length > 0) { if (task.files && task.files.length > 0) {
console.log(` Files: ${chalk.dim(task.files.join(', '))}`); console.log(` Files: ${colors.muted(task.files.join(', '))}`);
} }
} }
} else { } else {
console.log(chalk.dim('No structured tasks defined. Skill will be executed as a single unit.')); console.log(colors.muted('No structured tasks defined. Skill will be executed as a single unit.'));
} }
console.log(); console.log();
console.log(chalk.dim('This is a dry run. Remove --dry-run to execute.')); console.log(colors.muted('This is a dry run. Remove --dry-run to execute.'));
} }
private getTaskTypeLabel(type: string): string { private getTaskTypeLabel(type: string): string {
switch (type) { switch (type) {
case 'auto': case 'auto':
return chalk.green('[auto]'); return colors.success('[auto]');
case 'checkpoint:human-verify': case 'checkpoint:human-verify':
return chalk.yellow('[verify]'); return colors.warning('[verify]');
case 'checkpoint:decision': case 'checkpoint:decision':
return chalk.blue('[decision]'); return colors.info('[decision]');
case 'checkpoint:human-action': case 'checkpoint:human-action':
return chalk.magenta('[manual]'); return colors.magenta('[manual]');
default: default:
return ''; return '';
} }
+11 -12
View File
@@ -1,11 +1,10 @@
import { cpSync, mkdirSync } from 'node:fs'; import { cpSync, mkdirSync } from 'node:fs';
import { dirname, join } from 'node:path'; import { dirname, join } from 'node:path';
import chalk from 'chalk'; import { colors, warn, spinner } from '../onboarding/index.js';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { ContentExtractor, SkillGenerator, AutoTagger } from '@skillkit/core'; import { ContentExtractor, SkillGenerator, AutoTagger } from '@skillkit/core';
import type { AgentType } from '@skillkit/core'; import type { AgentType } from '@skillkit/core';
import { getAdapter } from '@skillkit/agents'; import { getAdapter } from '@skillkit/agents';
import { spinner } from '../onboarding/index.js';
export class SaveCommand extends Command { export class SaveCommand extends Command {
static override paths = [['save']]; static override paths = [['save']];
@@ -47,11 +46,11 @@ export class SaveCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
const sources = [this.url, this.text, this.file].filter(Boolean); const sources = [this.url, this.text, this.file].filter(Boolean);
if (sources.length === 0) { if (sources.length === 0) {
console.log(chalk.red('Provide a URL, --text, or --file')); console.log(colors.error('Provide a URL, --text, or --file'));
return 1; return 1;
} }
if (sources.length > 1) { if (sources.length > 1) {
console.log(chalk.red('Provide only one of: URL, --text, or --file')); console.log(colors.error('Provide only one of: URL, --text, or --file'));
return 1; return 1;
} }
@@ -83,13 +82,13 @@ export class SaveCommand extends Command {
global: this.global, global: this.global,
}); });
s.stop(chalk.green('Skill saved')); s.stop(colors.success('Skill saved'));
console.log(''); console.log('');
console.log(chalk.bold(' Name: ') + chalk.cyan(result.name)); console.log(colors.bold(' Name: ') + colors.cyan(result.name));
console.log(chalk.bold(' Path: ') + chalk.dim(result.skillPath)); console.log(colors.bold(' Path: ') + colors.muted(result.skillPath));
if (tags.length > 0) { if (tags.length > 0) {
console.log(chalk.bold(' Tags: ') + tags.map(t => chalk.yellow(t)).join(', ')); console.log(colors.bold(' Tags: ') + tags.map(t => colors.warning(t)).join(', '));
} }
if (this.agent) { if (this.agent) {
@@ -102,9 +101,9 @@ export class SaveCommand extends Command {
const targetDir = join(adapter.skillsDir, result.name); const targetDir = join(adapter.skillsDir, result.name);
mkdirSync(targetDir, { recursive: true }); mkdirSync(targetDir, { recursive: true });
cpSync(skillDir, targetDir, { recursive: true }); cpSync(skillDir, targetDir, { recursive: true });
console.log(chalk.green(` Installed to ${agentName}: `) + chalk.dim(targetDir)); console.log(colors.success(` Installed to ${agentName}: `) + colors.muted(targetDir));
} catch (err) { } catch (err) {
console.log(chalk.yellow(` Skipped ${agentName}: ${err instanceof Error ? err.message : String(err)}`)); warn(` Skipped ${agentName}: ${err instanceof Error ? err.message : String(err)}`);
} }
} }
} }
@@ -112,8 +111,8 @@ export class SaveCommand extends Command {
console.log(''); console.log('');
return 0; return 0;
} catch (err) { } catch (err) {
s.stop(chalk.red('Failed')); s.stop(colors.error('Failed'));
console.log(chalk.red(err instanceof Error ? err.message : String(err))); console.log(colors.error(err instanceof Error ? err.message : String(err)));
return 1; return 1;
} }
} }
+4 -3
View File
@@ -2,6 +2,7 @@ import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { existsSync } from 'node:fs'; import { existsSync } from 'node:fs';
import { SkillScanner, formatResult, Severity } from '@skillkit/core'; import { SkillScanner, formatResult, Severity } from '@skillkit/core';
import { error } from '../onboarding/index.js';
const SEVERITY_MAP: Record<string, Severity> = { const SEVERITY_MAP: Record<string, Severity> = {
critical: Severity.CRITICAL, critical: Severity.CRITICAL,
@@ -50,13 +51,13 @@ export class ScanCommand extends Command {
const targetPath = resolve(this.skillPath); const targetPath = resolve(this.skillPath);
if (!existsSync(targetPath)) { if (!existsSync(targetPath)) {
this.context.stderr.write(`Path not found: ${targetPath}\n`); error(`Path not found: ${targetPath}`);
return 1; return 1;
} }
const validFormats = ['summary', 'json', 'table', 'sarif']; const validFormats = ['summary', 'json', 'table', 'sarif'];
if (!validFormats.includes(this.format)) { if (!validFormats.includes(this.format)) {
this.context.stderr.write(`Invalid format: "${this.format}". Must be one of: ${validFormats.join(', ')}\n`); error(`Invalid format: "${this.format}". Must be one of: ${validFormats.join(', ')}`);
return 1; return 1;
} }
@@ -66,7 +67,7 @@ export class ScanCommand extends Command {
if (this.failOn) { if (this.failOn) {
failOnSeverity = SEVERITY_MAP[this.failOn.toLowerCase()]; failOnSeverity = SEVERITY_MAP[this.failOn.toLowerCase()];
if (!failOnSeverity) { if (!failOnSeverity) {
this.context.stderr.write(`Invalid --fail-on value: "${this.failOn}". Must be one of: ${Object.keys(SEVERITY_MAP).join(', ')}\n`); error(`Invalid --fail-on value: "${this.failOn}". Must be one of: ${Object.keys(SEVERITY_MAP).join(', ')}`);
return 1; return 1;
} }
} }
+44 -44
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, warn, success, step } from '../onboarding/index.js';
import { import {
loadSessionFile, loadSessionFile,
saveSessionFile, saveSessionFile,
@@ -32,7 +32,7 @@ export class SessionCommand extends Command {
}); });
async execute(): Promise<number> { async execute(): Promise<number> {
console.log(chalk.cyan('Session commands:\n')); step('Session commands:\n');
console.log(' session status Show current session state'); console.log(' session status Show current session state');
console.log(' session start Start a new session'); console.log(' session start Start a new session');
console.log(' session load Load session from specific date'); console.log(' session load Load session from specific date');
@@ -65,8 +65,8 @@ export class SessionStatusCommand extends Command {
const session = getMostRecentSession(); const session = getMostRecentSession();
if (!session) { if (!session) {
console.log(chalk.yellow('No active session found')); warn('No active session found');
console.log(chalk.dim('Start one with: skillkit session start')); console.log(colors.muted('Start one with: skillkit session start'));
return 0; return 0;
} }
@@ -80,7 +80,7 @@ export class SessionStatusCommand extends Command {
} }
private printSession(session: SessionFile): void { private printSession(session: SessionFile): void {
console.log(chalk.cyan(`Session: ${session.date}\n`)); step(`Session: ${session.date}\n`);
console.log(`Agent: ${session.agent}`); console.log(`Agent: ${session.agent}`);
console.log(`Project: ${session.projectPath}`); console.log(`Project: ${session.projectPath}`);
console.log(`Started: ${session.startedAt}`); console.log(`Started: ${session.startedAt}`);
@@ -88,33 +88,33 @@ export class SessionStatusCommand extends Command {
console.log(); console.log();
if (session.completed.length > 0) { if (session.completed.length > 0) {
console.log(chalk.green('Completed:')); console.log(colors.success('Completed:'));
for (const task of session.completed) { for (const task of session.completed) {
console.log(` ${chalk.green('✓')} ${task}`); console.log(` ${colors.success('✓')} ${task}`);
} }
console.log(); console.log();
} }
if (session.inProgress.length > 0) { if (session.inProgress.length > 0) {
console.log(chalk.yellow('In Progress:')); console.log(colors.warning('In Progress:'));
for (const task of session.inProgress) { for (const task of session.inProgress) {
console.log(` ${chalk.yellow('○')} ${task}`); console.log(` ${colors.warning('○')} ${task}`);
} }
console.log(); console.log();
} }
if (session.notes.length > 0) { if (session.notes.length > 0) {
console.log(chalk.blue('Notes for Next Session:')); console.log(colors.info('Notes for Next Session:'));
for (const note of session.notes) { for (const n of session.notes) {
console.log(` ${chalk.dim('•')} ${note}`); console.log(` ${colors.muted('•')} ${n}`);
} }
console.log(); console.log();
} }
if (session.contextToLoad.length > 0) { if (session.contextToLoad.length > 0) {
console.log(chalk.dim('Context to Load:')); console.log(colors.muted('Context to Load:'));
for (const ctx of session.contextToLoad) { for (const ctx of session.contextToLoad) {
console.log(` ${chalk.dim('•')} ${ctx}`); console.log(` ${colors.muted('•')} ${ctx}`);
} }
} }
} }
@@ -142,8 +142,8 @@ export class SessionStartCommand extends Command {
const session = createSessionFile(agent, projectPath); const session = createSessionFile(agent, projectPath);
const filepath = saveSessionFile(session); const filepath = saveSessionFile(session);
console.log(chalk.green(`✓ Session started: ${session.date}`)); success(`✓ Session started: ${session.date}`);
console.log(chalk.dim(` Saved to: ${filepath}`)); console.log(colors.muted(` Saved to: ${filepath}`));
return 0; return 0;
} }
@@ -163,31 +163,31 @@ export class SessionLoadCommand extends Command {
const session = this.date ? loadSessionFile(this.date) : getMostRecentSession(); const session = this.date ? loadSessionFile(this.date) : getMostRecentSession();
if (!session) { if (!session) {
console.log(chalk.yellow('Session not found')); warn('Session not found');
return 1; return 1;
} }
console.log(chalk.green(`✓ Loaded session: ${session.date}`)); success(`✓ Loaded session: ${session.date}`);
console.log(); console.log();
if (session.notes.length > 0) { if (session.notes.length > 0) {
console.log(chalk.cyan('Notes from previous session:')); step('Notes from previous session:');
for (const note of session.notes) { for (const n of session.notes) {
console.log(` ${chalk.dim('•')} ${note}`); console.log(` ${colors.muted('•')} ${n}`);
} }
console.log(); console.log();
} }
if (session.inProgress.length > 0) { if (session.inProgress.length > 0) {
console.log(chalk.yellow('Tasks still in progress:')); console.log(colors.warning('Tasks still in progress:'));
for (const task of session.inProgress) { for (const task of session.inProgress) {
console.log(` ${chalk.yellow('○')} ${task}`); console.log(` ${colors.warning('○')} ${task}`);
} }
console.log(); console.log();
} }
if (session.contextToLoad.length > 0) { if (session.contextToLoad.length > 0) {
console.log(chalk.dim('Context to load:')); console.log(colors.muted('Context to load:'));
for (const ctx of session.contextToLoad) { for (const ctx of session.contextToLoad) {
console.log(` ${ctx}`); console.log(` ${ctx}`);
} }
@@ -218,7 +218,7 @@ export class SessionListCommand extends Command {
const sessions = listSessions(limit); const sessions = listSessions(limit);
if (sessions.length === 0) { if (sessions.length === 0) {
console.log(chalk.yellow('No sessions found')); warn('No sessions found');
return 0; return 0;
} }
@@ -227,13 +227,13 @@ export class SessionListCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan(`Recent Sessions (${sessions.length}):\n`)); step(`Recent Sessions (${sessions.length}):\n`);
for (const session of sessions) { for (const session of sessions) {
const progress = `${session.completedCount}/${session.taskCount}`; const progress = `${session.completedCount}/${session.taskCount}`;
const notesIndicator = session.hasNotes ? chalk.blue(' [notes]') : ''; const notesIndicator = session.hasNotes ? colors.info(' [notes]') : '';
console.log(` ${chalk.bold(session.date)} - ${session.agent}`); console.log(` ${colors.bold(session.date)} - ${session.agent}`);
console.log(` ${chalk.dim(session.projectPath)}`); console.log(` ${colors.muted(session.projectPath)}`);
console.log(` Tasks: ${progress}${notesIndicator}`); console.log(` Tasks: ${progress}${notesIndicator}`);
console.log(); console.log();
} }
@@ -265,7 +265,7 @@ export class SessionNoteCommand extends Command {
saveSessionFile(updated); saveSessionFile(updated);
console.log(chalk.green('✓ Note added')); success('✓ Note added');
return 0; return 0;
} }
} }
@@ -297,7 +297,7 @@ export class SessionCompleteCommand extends Command {
saveSessionFile(updated); saveSessionFile(updated);
console.log(chalk.green(`✓ Completed: ${this.task}`)); success(`✓ Completed: ${this.task}`);
return 0; return 0;
} }
} }
@@ -325,7 +325,7 @@ export class SessionInProgressCommand extends Command {
saveSessionFile(updated); saveSessionFile(updated);
console.log(chalk.yellow(`○ In progress: ${this.task}`)); console.log(colors.warning(`○ In progress: ${this.task}`));
return 0; return 0;
} }
} }
@@ -354,7 +354,7 @@ export class SessionSnapshotSaveCommand extends Command {
const state = sessionMgr.get(); const state = sessionMgr.get();
if (!state) { if (!state) {
console.log(chalk.yellow('No active session to snapshot')); warn('No active session to snapshot');
return 1; return 1;
} }
@@ -375,9 +375,9 @@ export class SessionSnapshotSaveCommand extends Command {
} }
manager.save(this.name, state, observations, this.desc); manager.save(this.name, state, observations, this.desc);
console.log(chalk.green(`\u2713 Snapshot saved: ${this.name}`)); success(`\u2713 Snapshot saved: ${this.name}`);
if (this.desc) { if (this.desc) {
console.log(chalk.dim(` ${this.desc}`)); console.log(colors.muted(` ${this.desc}`));
} }
return 0; return 0;
} }
@@ -398,7 +398,7 @@ export class SessionSnapshotRestoreCommand extends Command {
const manager = new SnapshotManager(projectPath); const manager = new SnapshotManager(projectPath);
if (!manager.exists(this.name)) { if (!manager.exists(this.name)) {
console.log(chalk.red(`Snapshot "${this.name}" not found`)); console.log(colors.error(`Snapshot "${this.name}" not found`));
return 1; return 1;
} }
@@ -429,7 +429,7 @@ export class SessionSnapshotRestoreCommand extends Command {
// Non-critical: session state restored even if observations fail // Non-critical: session state restored even if observations fail
} }
console.log(chalk.green(`\u2713 Snapshot restored: ${this.name}`)); success(`\u2713 Snapshot restored: ${this.name}`);
return 0; return 0;
} }
} }
@@ -457,18 +457,18 @@ export class SessionSnapshotListCommand extends Command {
} }
if (snapshots.length === 0) { if (snapshots.length === 0) {
console.log(chalk.yellow('No snapshots found')); warn('No snapshots found');
console.log(chalk.dim('Save one with: skillkit session snapshot save <name>')); console.log(colors.muted('Save one with: skillkit session snapshot save <name>'));
return 0; return 0;
} }
console.log(chalk.cyan(`Snapshots (${snapshots.length}):\n`)); step(`Snapshots (${snapshots.length}):\n`);
for (const snap of snapshots) { for (const snap of snapshots) {
console.log(` ${chalk.bold(snap.name)}`); console.log(` ${colors.bold(snap.name)}`);
console.log(` Created: ${snap.createdAt}`); console.log(` Created: ${snap.createdAt}`);
if (snap.description) { if (snap.description) {
console.log(` ${chalk.dim(snap.description)}`); console.log(` ${colors.muted(snap.description)}`);
} }
console.log(` Skills in history: ${snap.skillCount}`); console.log(` Skills in history: ${snap.skillCount}`);
console.log(); console.log();
@@ -493,11 +493,11 @@ export class SessionSnapshotDeleteCommand extends Command {
const manager = new SnapshotManager(projectPath); const manager = new SnapshotManager(projectPath);
if (!manager.delete(this.name)) { if (!manager.delete(this.name)) {
console.log(chalk.red(`Snapshot "${this.name}" not found`)); console.log(colors.error(`Snapshot "${this.name}" not found`));
return 1; return 1;
} }
console.log(chalk.green(`\u2713 Snapshot deleted: ${this.name}`)); success(`\u2713 Snapshot deleted: ${this.name}`);
return 0; return 0;
} }
} }
+14 -14
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, success, step } from '../onboarding/index.js';
import { loadConfig, saveConfig, type SkillkitConfig, type AgentType } from '@skillkit/core'; import { loadConfig, saveConfig, type SkillkitConfig, type AgentType } from '@skillkit/core';
const VALID_AGENTS: AgentType[] = [ const VALID_AGENTS: AgentType[] = [
@@ -69,7 +69,7 @@ export class SettingsCommand extends Command {
autoSync: true, autoSync: true,
}; };
saveConfig(defaultConfig, this.global); saveConfig(defaultConfig, this.global);
console.log(chalk.green('Settings reset to defaults')); success('Settings reset to defaults');
return 0; return 0;
} }
@@ -81,7 +81,7 @@ export class SettingsCommand extends Command {
'enabledSkills', 'disabledSkills', 'marketplaceSources', 'defaultTimeout' 'enabledSkills', 'disabledSkills', 'marketplaceSources', 'defaultTimeout'
]; ];
if (!knownKeys.includes(this.get)) { if (!knownKeys.includes(this.get)) {
console.error(chalk.red(`Unknown setting: ${this.get}`)); console.error(colors.error(`Unknown setting: ${this.get}`));
return 1; return 1;
} }
const value = this.getConfigValue(config, this.get); const value = this.getConfigValue(config, this.get);
@@ -100,18 +100,18 @@ export class SettingsCommand extends Command {
const value = valueParts.join('='); const value = valueParts.join('=');
if (!key || !this.set.includes('=')) { if (!key || !this.set.includes('=')) {
console.error(chalk.red('Invalid format. Use: --set key=value')); console.error(colors.error('Invalid format. Use: --set key=value'));
return 1; return 1;
} }
const result = this.setConfigValue(config, key, value); const result = this.setConfigValue(config, key, value);
if (!result.success) { if (!result.success) {
console.error(chalk.red(result.error)); console.error(colors.error(result.error || 'Unknown error'));
return 1; return 1;
} }
saveConfig(config, this.global); saveConfig(config, this.global);
console.log(chalk.green(`${key} = ${value}`)); success(`${key} = ${value}`);
return 0; return 0;
} }
@@ -119,8 +119,8 @@ export class SettingsCommand extends Command {
if (this.json) { if (this.json) {
console.log(JSON.stringify(config, null, 2)); console.log(JSON.stringify(config, null, 2));
} else { } else {
console.log(chalk.cyan('SkillKit Settings')); step('SkillKit Settings');
console.log(chalk.dim('─'.repeat(40))); console.log(colors.muted('─'.repeat(40)));
console.log(); console.log();
const settings = [ const settings = [
@@ -132,25 +132,25 @@ export class SettingsCommand extends Command {
]; ];
for (const setting of settings) { for (const setting of settings) {
console.log(` ${chalk.white(setting.label.padEnd(14))} ${chalk.dim(setting.value)}`); console.log(` ${colors.primary(setting.label.padEnd(14))} ${colors.muted(setting.value)}`);
} }
if (config.enabledSkills?.length) { if (config.enabledSkills?.length) {
console.log(); console.log();
console.log(` ${chalk.white('Enabled Skills'.padEnd(14))} ${chalk.dim(config.enabledSkills.join(', '))}`); console.log(` ${colors.primary('Enabled Skills'.padEnd(14))} ${colors.muted(config.enabledSkills.join(', '))}`);
} }
if (config.disabledSkills?.length) { if (config.disabledSkills?.length) {
console.log(` ${chalk.white('Disabled Skills'.padEnd(14))} ${chalk.dim(config.disabledSkills.join(', '))}`); console.log(` ${colors.primary('Disabled Skills'.padEnd(14))} ${colors.muted(config.disabledSkills.join(', '))}`);
} }
if (config.marketplaceSources?.length) { if (config.marketplaceSources?.length) {
console.log(` ${chalk.white('Marketplaces'.padEnd(14))} ${chalk.dim(config.marketplaceSources.join(', '))}`); console.log(` ${colors.primary('Marketplaces'.padEnd(14))} ${colors.muted(config.marketplaceSources.join(', '))}`);
} }
console.log(); console.log();
console.log(chalk.dim('Use --set key=value to modify settings')); console.log(colors.muted('Use --set key=value to modify settings'));
console.log(chalk.dim('Available keys: agent, autoSync, cacheDir, skillsDir, defaultTimeout')); console.log(colors.muted('Available keys: agent, autoSync, cacheDir, skillsDir, defaultTimeout'));
} }
return 0; return 0;
+40 -40
View File
@@ -1,7 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { existsSync } from 'node:fs'; import { existsSync } from 'node:fs';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import type { AgentType } from '@skillkit/core'; import type { AgentType } from '@skillkit/core';
import { SessionManager, findAllSkills, loadConfig, getProjectConfigPath } from '@skillkit/core'; import { SessionManager, findAllSkills, loadConfig, getProjectConfigPath } from '@skillkit/core';
import { detectAgent, getAdapter } from '@skillkit/agents'; import { detectAgent, getAdapter } from '@skillkit/agents';
@@ -77,34 +77,34 @@ export class StatusCommand extends Command {
// Show current execution // Show current execution
if (state.currentExecution) { if (state.currentExecution) {
const exec = state.currentExecution; const exec = state.currentExecution;
const statusColor = exec.status === 'paused' ? chalk.yellow : chalk.green; const statusColor = exec.status === 'paused' ? colors.warning : colors.success;
console.log(chalk.cyan('Current Execution:\n')); console.log(colors.cyan('Current Execution:\n'));
console.log(` Skill: ${chalk.bold(exec.skillName)}`); console.log(` Skill: ${colors.bold(exec.skillName)}`);
console.log(` Source: ${chalk.dim(exec.skillSource)}`); console.log(` Source: ${colors.muted(exec.skillSource)}`);
console.log(` Status: ${statusColor(exec.status)}`); console.log(` Status: ${statusColor(exec.status)}`);
console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks`); console.log(` Progress: ${exec.currentStep}/${exec.totalSteps} tasks`);
console.log(` Started: ${chalk.dim(new Date(exec.startedAt).toLocaleString())}`); console.log(` Started: ${colors.muted(new Date(exec.startedAt).toLocaleString())}`);
if (exec.pausedAt) { if (exec.pausedAt) {
console.log(` Paused: ${chalk.dim(new Date(exec.pausedAt).toLocaleString())}`); console.log(` Paused: ${colors.muted(new Date(exec.pausedAt).toLocaleString())}`);
} }
console.log(chalk.cyan('\n Tasks:')); console.log(colors.cyan('\n Tasks:'));
for (const task of exec.tasks) { for (const task of exec.tasks) {
const statusIcon = this.getStatusIcon(task.status); const statusIcon = this.getStatusIcon(task.status);
const statusText = this.getStatusColor(task.status)(task.status); const statusText = this.getStatusColor(task.status)(task.status);
console.log(` ${statusIcon} ${task.name} - ${statusText}`); console.log(` ${statusIcon} ${task.name} - ${statusText}`);
if (task.error) { if (task.error) {
console.log(` ${chalk.red('Error:')} ${task.error}`); console.log(` ${colors.error('Error:')} ${task.error}`);
} }
} }
if (exec.status === 'paused') { if (exec.status === 'paused') {
console.log(chalk.yellow('\n Resume with: skillkit resume')); console.log(colors.warning('\n Resume with: skillkit resume'));
} }
} else { } else {
console.log(chalk.dim('No active execution.')); console.log(colors.muted('No active execution.'));
} }
// Show history // Show history
@@ -113,22 +113,22 @@ export class StatusCommand extends Command {
const history = manager.getHistory(limit); const history = manager.getHistory(limit);
if (history.length > 0) { if (history.length > 0) {
console.log(chalk.cyan('\nExecution History:\n')); console.log(colors.cyan('\nExecution History:\n'));
for (const entry of history) { for (const entry of history) {
const statusColor = entry.status === 'completed' ? chalk.green : chalk.red; const statusColor = entry.status === 'completed' ? colors.success : colors.error;
const duration = this.formatDuration(entry.durationMs); const duration = this.formatDuration(entry.durationMs);
console.log(` ${statusColor('●')} ${chalk.bold(entry.skillName)}`); console.log(` ${statusColor('●')} ${colors.bold(entry.skillName)}`);
console.log(` ${chalk.dim(entry.skillSource)} • ${duration}`); console.log(` ${colors.muted(entry.skillSource)} • ${duration}`);
console.log(` ${chalk.dim(new Date(entry.completedAt).toLocaleString())}`); console.log(` ${colors.muted(new Date(entry.completedAt).toLocaleString())}`);
if (entry.commits.length > 0) { if (entry.commits.length > 0) {
console.log(` Commits: ${chalk.dim(entry.commits.join(', '))}`); console.log(` Commits: ${colors.muted(entry.commits.join(', '))}`);
} }
if (entry.error) { if (entry.error) {
console.log(` ${chalk.red('Error:')} ${entry.error}`); console.log(` ${colors.error('Error:')} ${entry.error}`);
} }
console.log(); console.log();
@@ -138,12 +138,12 @@ export class StatusCommand extends Command {
// Show decisions // Show decisions
if (state.decisions.length > 0) { if (state.decisions.length > 0) {
console.log(chalk.cyan('Saved Decisions:\n')); console.log(colors.cyan('Saved Decisions:\n'));
for (const decision of state.decisions.slice(0, 5)) { for (const decision of state.decisions.slice(0, 5)) {
console.log(` ${chalk.dim(decision.key)}: ${decision.value}`); console.log(` ${colors.muted(decision.key)}: ${decision.value}`);
} }
if (state.decisions.length > 5) { if (state.decisions.length > 5) {
console.log(chalk.dim(` ... and ${state.decisions.length - 5} more`)); console.log(colors.muted(` ... and ${state.decisions.length - 5} more`));
} }
} }
@@ -199,59 +199,59 @@ export class StatusCommand extends Command {
private showOverview(overview: StatusOverview): void { private showOverview(overview: StatusOverview): void {
console.log(''); console.log('');
console.log(chalk.cyan(' Project Overview')); console.log(colors.cyan(' Project Overview'));
console.log(` Agent: ${chalk.bold(overview.agent)}`); console.log(` Agent: ${colors.bold(overview.agent)}`);
console.log(` Config: ${overview.config ? chalk.green('skillkit.yaml') : chalk.dim('none (defaults)')}`); console.log(` Config: ${overview.config ? colors.success('skillkit.yaml') : colors.muted('none (defaults)')}`);
console.log(` Version: ${chalk.bold(overview.version)}`); console.log(` Version: ${colors.bold(overview.version)}`);
console.log(''); console.log('');
console.log(chalk.cyan(` Skills (${overview.totalSkills} installed)`)); console.log(colors.cyan(` Skills (${overview.totalSkills} installed)`));
console.log(` Project: ${overview.projectSkills} skills in ${overview.skillsDir}`); console.log(` Project: ${overview.projectSkills} skills in ${overview.skillsDir}`);
console.log(` Global: ${overview.globalSkills} skills`); console.log(` Global: ${overview.globalSkills} skills`);
console.log(''); console.log('');
console.log(chalk.cyan(' Recent Activity')); console.log(colors.cyan(' Recent Activity'));
if (overview.recentHistory.length === 0) { if (overview.recentHistory.length === 0) {
console.log(chalk.dim(' No recent executions.')); console.log(colors.muted(' No recent executions.'));
} else { } else {
for (const entry of overview.recentHistory) { for (const entry of overview.recentHistory) {
const statusColor = entry.status === 'completed' ? chalk.green : chalk.red; const statusColor = entry.status === 'completed' ? colors.success : colors.error;
console.log(` ${statusColor('\u25cf')} ${entry.skillName} - ${new Date(entry.completedAt).toLocaleDateString()}`); console.log(` ${statusColor('\u25cf')} ${entry.skillName} - ${new Date(entry.completedAt).toLocaleDateString()}`);
} }
} }
console.log(''); console.log('');
console.log(chalk.dim(' Tip: Run "skillkit doctor" for a full health check.')); console.log(colors.muted(' Tip: Run "skillkit doctor" for a full health check.'));
console.log(''); console.log('');
} }
private getStatusIcon(status: string): string { private getStatusIcon(status: string): string {
switch (status) { switch (status) {
case 'completed': case 'completed':
return chalk.green('✓'); return colors.success('✓');
case 'failed': case 'failed':
return chalk.red('✗'); return colors.error('✗');
case 'in_progress': case 'in_progress':
return chalk.blue('●'); return colors.info('●');
case 'paused': case 'paused':
return chalk.yellow('⏸'); return colors.warning('⏸');
default: default:
return chalk.dim('○'); return colors.muted('○');
} }
} }
private getStatusColor(status: string): (text: string) => string { private getStatusColor(status: string): (text: string) => string {
switch (status) { switch (status) {
case 'completed': case 'completed':
return chalk.green; return colors.success;
case 'failed': case 'failed':
return chalk.red; return colors.error;
case 'in_progress': case 'in_progress':
return chalk.blue; return colors.info;
case 'paused': case 'paused':
return chalk.yellow; return colors.warning;
default: default:
return chalk.dim; return colors.muted;
} }
} }
+106
View File
@@ -0,0 +1,106 @@
import { Command, Option } from 'clipanion';
import { colors, symbols, step, success, warn } from '../onboarding/index.js';
import { loadTaps, saveTaps } from '../helpers.js';
export class TapAddCommand extends Command {
static override paths = [['tap', 'add']];
static override usage = Command.Usage({
description: 'Add a custom skill source (tap)',
examples: [
['Add a GitHub source', '$0 tap add myorg/skills'],
['Add with a display name', '$0 tap add myorg/skills --name "My Org Skills"'],
],
});
source = Option.String({ required: true });
name = Option.String('--name,-n', {
description: 'Display name for the tap',
});
async execute(): Promise<number> {
const taps = loadTaps();
const exists = taps.taps.some((t) => t.source === this.source);
if (exists) {
warn(`Tap already exists: ${this.source}`);
return 0;
}
taps.taps.push({
source: this.source,
name: this.name,
addedAt: new Date().toISOString(),
});
saveTaps(taps);
success(`Added tap: ${this.source}${this.name ? ` (${this.name})` : ''}`);
console.log(colors.muted('Skills from this source will appear in search results'));
return 0;
}
}
export class TapRemoveCommand extends Command {
static override paths = [['tap', 'remove'], ['tap', 'rm']];
static override usage = Command.Usage({
description: 'Remove a custom skill source (tap)',
examples: [
['Remove a tap', '$0 tap remove myorg/skills'],
],
});
source = Option.String({ required: true });
async execute(): Promise<number> {
const taps = loadTaps();
const idx = taps.taps.findIndex((t) => t.source === this.source);
if (idx === -1) {
warn(`Tap not found: ${this.source}`);
return 0;
}
taps.taps.splice(idx, 1);
saveTaps(taps);
success(`Removed tap: ${this.source}`);
return 0;
}
}
export class TapListCommand extends Command {
static override paths = [['tap', 'list'], ['tap', 'ls'], ['tap']];
static override usage = Command.Usage({
description: 'List all custom skill sources (taps)',
examples: [
['List taps', '$0 tap list'],
],
});
async execute(): Promise<number> {
const taps = loadTaps();
if (taps.taps.length === 0) {
step('No custom taps configured');
console.log(colors.muted('Add one with: skillkit tap add owner/repo'));
return 0;
}
step(`${taps.taps.length} tap(s) configured`);
console.log('');
for (const tap of taps.taps) {
const label = tap.name ? `${tap.name} (${tap.source})` : tap.source;
console.log(` ${colors.success(symbols.bullet)} ${colors.primary(label)}`);
if (tap.addedAt) {
console.log(` ${colors.muted(`Added: ${tap.addedAt}`)}`);
}
}
console.log('');
return 0;
}
}
+47 -47
View File
@@ -5,7 +5,7 @@
*/ */
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors } from '../onboarding/index.js';
import { createTeamManager, createSkillBundle, exportBundle, importBundle } from '@skillkit/core'; import { createTeamManager, createSkillBundle, exportBundle, importBundle } from '@skillkit/core';
import { join } from 'node:path'; import { join } from 'node:path';
@@ -62,23 +62,23 @@ export class TeamCommand extends Command {
case 'bundle-import': case 'bundle-import':
return await this.importSkillBundle(); return await this.importSkillBundle();
default: default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`)); this.context.stderr.write(colors.error(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: init, share, import, list, sync, remove, bundle-create, bundle-export, bundle-import\n'); this.context.stderr.write('Available actions: init, share, import, list, sync, remove, bundle-create, bundle-export, bundle-import\n');
return 1; return 1;
} }
} catch (err) { } catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`)); this.context.stderr.write(colors.error(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1; return 1;
} }
} }
private async initTeam(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async initTeam(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name is required for init\n')); this.context.stderr.write(colors.error('--name is required for init\n'));
return 1; return 1;
} }
if (!this.registry) { if (!this.registry) {
this.context.stderr.write(chalk.red('--registry is required for init\n')); this.context.stderr.write(colors.error('--registry is required for init\n'));
return 1; return 1;
} }
@@ -87,7 +87,7 @@ export class TeamCommand extends Command {
registryUrl: this.registry, registryUrl: this.registry,
}); });
this.context.stdout.write(chalk.green('✓ Team initialized!\n')); this.context.stdout.write(colors.success('✓ Team initialized!\n'));
this.context.stdout.write(` Team ID: ${config.teamId}\n`); this.context.stdout.write(` Team ID: ${config.teamId}\n`);
this.context.stdout.write(` Registry: ${config.registryUrl}\n`); this.context.stdout.write(` Registry: ${config.registryUrl}\n`);
return 0; return 0;
@@ -96,12 +96,12 @@ export class TeamCommand extends Command {
private async shareSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async shareSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name <skill-name> is required for share\n')); this.context.stderr.write(colors.error('--name <skill-name> is required for share\n'));
return 1; return 1;
} }
@@ -111,7 +111,7 @@ export class TeamCommand extends Command {
tags: this.tags?.split(',').map((t) => t.trim()), tags: this.tags?.split(',').map((t) => t.trim()),
}); });
this.context.stdout.write(chalk.green('✓ Skill shared!\n')); this.context.stdout.write(colors.success('✓ Skill shared!\n'));
this.context.stdout.write(` Name: ${shared.name}\n`); this.context.stdout.write(` Name: ${shared.name}\n`);
this.context.stdout.write(` Version: ${shared.version}\n`); this.context.stdout.write(` Version: ${shared.version}\n`);
this.context.stdout.write(` Source: ${shared.source}\n`); this.context.stdout.write(` Source: ${shared.source}\n`);
@@ -121,12 +121,12 @@ export class TeamCommand extends Command {
private async importSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async importSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name <skill-name> is required for import\n')); this.context.stderr.write(colors.error('--name <skill-name> is required for import\n'));
return 1; return 1;
} }
@@ -136,14 +136,14 @@ export class TeamCommand extends Command {
}); });
if (!result.success) { if (!result.success) {
this.context.stderr.write(chalk.red(`✗ ${result.error}\n`)); this.context.stderr.write(colors.error(`✗ ${result.error}\n`));
return 1; return 1;
} }
if (this.dryRun) { if (this.dryRun) {
this.context.stdout.write(chalk.cyan(`[dry-run] Would import to: ${result.path}\n`)); this.context.stdout.write(colors.cyan(`[dry-run] Would import to: ${result.path}\n`));
} else { } else {
this.context.stdout.write(chalk.green(`✓ Skill imported to: ${result.path}\n`)); this.context.stdout.write(colors.success(`✓ Skill imported to: ${result.path}\n`));
} }
return 0; return 0;
} }
@@ -151,14 +151,14 @@ export class TeamCommand extends Command {
private async listSkills(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async listSkills(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
const skills = teamManager.listSharedSkills(); const skills = teamManager.listSharedSkills();
this.context.stdout.write(chalk.cyan(`Team: ${config.teamName}\n`)); this.context.stdout.write(colors.cyan(`Team: ${config.teamName}\n`));
this.context.stdout.write(chalk.gray(`Registry: ${config.registryUrl}\n\n`)); this.context.stdout.write(colors.muted(`Registry: ${config.registryUrl}\n\n`));
if (skills.length === 0) { if (skills.length === 0) {
this.context.stdout.write('No shared skills yet. Use `skillkit team share` to share a skill.\n'); this.context.stdout.write('No shared skills yet. Use `skillkit team share` to share a skill.\n');
@@ -167,9 +167,9 @@ export class TeamCommand extends Command {
this.context.stdout.write(`Shared Skills (${skills.length}):\n`); this.context.stdout.write(`Shared Skills (${skills.length}):\n`);
for (const skill of skills) { for (const skill of skills) {
this.context.stdout.write(chalk.cyan(` ${skill.name}`) + ` v${skill.version}\n`); this.context.stdout.write(colors.cyan(` ${skill.name}`) + ` v${skill.version}\n`);
if (skill.description) { if (skill.description) {
this.context.stdout.write(chalk.gray(` ${skill.description}\n`)); this.context.stdout.write(colors.muted(` ${skill.description}\n`));
} }
this.context.stdout.write(` by ${skill.author} | ${skill.downloads || 0} downloads\n`); this.context.stdout.write(` by ${skill.author} | ${skill.downloads || 0} downloads\n`);
} }
@@ -180,7 +180,7 @@ export class TeamCommand extends Command {
private async syncTeam(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async syncTeam(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
@@ -188,7 +188,7 @@ export class TeamCommand extends Command {
const result = await teamManager.sync(); const result = await teamManager.sync();
this.context.stdout.write(chalk.green('✓ Sync complete!\n')); this.context.stdout.write(colors.success('✓ Sync complete!\n'));
if (result.added.length > 0) { if (result.added.length > 0) {
this.context.stdout.write(` Added: ${result.added.join(', ')}\n`); this.context.stdout.write(` Added: ${result.added.join(', ')}\n`);
} }
@@ -205,39 +205,39 @@ export class TeamCommand extends Command {
private async removeSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async removeSkill(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name <skill-name> is required for remove\n')); this.context.stderr.write(colors.error('--name <skill-name> is required for remove\n'));
return 1; return 1;
} }
const removed = teamManager.removeSkill(this.name); const removed = teamManager.removeSkill(this.name);
if (!removed) { if (!removed) {
this.context.stderr.write(chalk.red(`Skill "${this.name}" not found in team registry.\n`)); this.context.stderr.write(colors.error(`Skill "${this.name}" not found in team registry.\n`));
return 1; return 1;
} }
this.context.stdout.write(chalk.green(`✓ Skill "${this.name}" removed from team registry.\n`)); this.context.stdout.write(colors.success(`✓ Skill "${this.name}" removed from team registry.\n`));
return 0; return 0;
} }
private async createBundle(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async createBundle(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name <bundle-name> is required for bundle-create\n')); this.context.stderr.write(colors.error('--name <bundle-name> is required for bundle-create\n'));
return 1; return 1;
} }
if (!this.skills) { if (!this.skills) {
this.context.stderr.write(chalk.red('--skills <skill1,skill2,...> is required for bundle-create\n')); this.context.stderr.write(colors.error('--skills <skill1,skill2,...> is required for bundle-create\n'));
return 1; return 1;
} }
@@ -254,14 +254,14 @@ export class TeamCommand extends Command {
try { try {
bundle.addSkill(skillPath); bundle.addSkill(skillPath);
addedCount++; addedCount++;
this.context.stdout.write(chalk.gray(` + ${skillName}\n`)); this.context.stdout.write(colors.muted(` + ${skillName}\n`));
} catch (err) { } catch (err) {
this.context.stderr.write(chalk.yellow(` ⚠ Skipping ${skillName}: ${err instanceof Error ? err.message : 'Unknown error'}\n`)); this.context.stderr.write(colors.warning(` ⚠ Skipping ${skillName}: ${err instanceof Error ? err.message : 'Unknown error'}\n`));
} }
} }
if (addedCount === 0) { if (addedCount === 0) {
this.context.stderr.write(chalk.red('No skills were added to the bundle.\n')); this.context.stderr.write(colors.error('No skills were added to the bundle.\n'));
return 1; return 1;
} }
@@ -270,11 +270,11 @@ export class TeamCommand extends Command {
const result = exportBundle(bundle, outputPath); const result = exportBundle(bundle, outputPath);
if (!result.success) { if (!result.success) {
this.context.stderr.write(chalk.red(`✗ ${result.error}\n`)); this.context.stderr.write(colors.error(`✗ ${result.error}\n`));
return 1; return 1;
} }
this.context.stdout.write(chalk.green(`\n✓ Bundle "${this.name}" created with ${addedCount} skills!\n`)); this.context.stdout.write(colors.success(`\n✓ Bundle "${this.name}" created with ${addedCount} skills!\n`));
this.context.stdout.write(` Checksum: ${bundle.getChecksum()}\n`); this.context.stdout.write(` Checksum: ${bundle.getChecksum()}\n`);
this.context.stdout.write(` Output: ${result.path}\n`); this.context.stdout.write(` Output: ${result.path}\n`);
return 0; return 0;
@@ -283,17 +283,17 @@ export class TeamCommand extends Command {
private async exportSkillBundle(teamManager: ReturnType<typeof createTeamManager>): Promise<number> { private async exportSkillBundle(teamManager: ReturnType<typeof createTeamManager>): Promise<number> {
const config = teamManager.load(); const config = teamManager.load();
if (!config) { if (!config) {
this.context.stderr.write(chalk.red('Team not initialized. Run `skillkit team init` first.\n')); this.context.stderr.write(colors.error('Team not initialized. Run `skillkit team init` first.\n'));
return 1; return 1;
} }
if (!this.name) { if (!this.name) {
this.context.stderr.write(chalk.red('--name <bundle-name> is required for bundle-export\n')); this.context.stderr.write(colors.error('--name <bundle-name> is required for bundle-export\n'));
return 1; return 1;
} }
if (!this.output) { if (!this.output) {
this.context.stderr.write(chalk.red('--output <path> is required for bundle-export\n')); this.context.stderr.write(colors.error('--output <path> is required for bundle-export\n'));
return 1; return 1;
} }
@@ -303,7 +303,7 @@ export class TeamCommand extends Command {
// Check if bundle exists // Check if bundle exists
const { existsSync, readFileSync, writeFileSync } = await import('node:fs'); const { existsSync, readFileSync, writeFileSync } = await import('node:fs');
if (!existsSync(bundlePath)) { if (!existsSync(bundlePath)) {
this.context.stderr.write(chalk.red(`Bundle "${this.name}" not found. Create it first with bundle-create.\n`)); this.context.stderr.write(colors.error(`Bundle "${this.name}" not found. Create it first with bundle-create.\n`));
return 1; return 1;
} }
@@ -311,19 +311,19 @@ export class TeamCommand extends Command {
const content = readFileSync(bundlePath, 'utf-8'); const content = readFileSync(bundlePath, 'utf-8');
writeFileSync(this.output, content, 'utf-8'); writeFileSync(this.output, content, 'utf-8');
this.context.stdout.write(chalk.green(`✓ Bundle exported to: ${this.output}\n`)); this.context.stdout.write(colors.success(`✓ Bundle exported to: ${this.output}\n`));
return 0; return 0;
} }
private async importSkillBundle(): Promise<number> { private async importSkillBundle(): Promise<number> {
if (!this.source) { if (!this.source) {
this.context.stderr.write(chalk.red('--source <path> is required for bundle-import\n')); this.context.stderr.write(colors.error('--source <path> is required for bundle-import\n'));
return 1; return 1;
} }
const { existsSync } = await import('node:fs'); const { existsSync } = await import('node:fs');
if (!existsSync(this.source)) { if (!existsSync(this.source)) {
this.context.stderr.write(chalk.red(`Bundle file not found: ${this.source}\n`)); this.context.stderr.write(colors.error(`Bundle file not found: ${this.source}\n`));
return 1; return 1;
} }
@@ -331,28 +331,28 @@ export class TeamCommand extends Command {
const skillsDir = join(projectPath, 'skills'); const skillsDir = join(projectPath, 'skills');
if (this.dryRun) { if (this.dryRun) {
this.context.stdout.write(chalk.cyan('[dry-run] Would import bundle to: ' + skillsDir + '\n')); this.context.stdout.write(colors.cyan('[dry-run] Would import bundle to: ' + skillsDir + '\n'));
return 0; return 0;
} }
const result = importBundle(this.source, skillsDir, { overwrite: this.overwrite }); const result = importBundle(this.source, skillsDir, { overwrite: this.overwrite });
if (!result.success && result.imported.length === 0) { if (!result.success && result.imported.length === 0) {
this.context.stderr.write(chalk.red('✗ Failed to import bundle:\n')); this.context.stderr.write(colors.error('✗ Failed to import bundle:\n'));
for (const error of result.errors) { for (const error of result.errors) {
this.context.stderr.write(chalk.red(` - ${error}\n`)); this.context.stderr.write(colors.error(` - ${error}\n`));
} }
return 1; return 1;
} }
this.context.stdout.write(chalk.green(`✓ Imported ${result.imported.length} skills from bundle!\n`)); this.context.stdout.write(colors.success(`✓ Imported ${result.imported.length} skills from bundle!\n`));
for (const name of result.imported) { for (const name of result.imported) {
this.context.stdout.write(chalk.gray(` + ${name}\n`)); this.context.stdout.write(colors.muted(` + ${name}\n`));
} }
if (result.errors.length > 0) { if (result.errors.length > 0) {
this.context.stdout.write(chalk.yellow('\nWarnings:\n')); this.context.stdout.write(colors.warning('\nWarnings:\n'));
for (const error of result.errors) { for (const error of result.errors) {
this.context.stdout.write(chalk.yellow(` - ${error}\n`)); this.context.stdout.write(colors.warning(` - ${error}\n`));
} }
} }
return 0; return 0;
+18 -18
View File
@@ -1,7 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve, join } from 'node:path'; import { resolve, join } from 'node:path';
import { existsSync, readFileSync, readdirSync } from 'node:fs'; import { existsSync, readFileSync, readdirSync } from 'node:fs';
import chalk from 'chalk'; import { colors, warn, success, error, step } from '../onboarding/index.js';
import { import {
runTestSuite, runTestSuite,
createTestSuiteFromFrontmatter, createTestSuiteFromFrontmatter,
@@ -85,8 +85,8 @@ export class TestCommand extends Command {
if (skillFiles.length === 0) { if (skillFiles.length === 0) {
if (!this.json) { if (!this.json) {
console.log(chalk.yellow('No skills found with tests.')); warn('No skills found with tests.');
console.log(chalk.dim('Add tests to your skills using YAML frontmatter.')); console.log(colors.muted('Add tests to your skills using YAML frontmatter.'));
} else { } else {
console.log(JSON.stringify({ results: [], passed: true, total: 0 })); console.log(JSON.stringify({ results: [], passed: true, total: 0 }));
} }
@@ -100,13 +100,13 @@ export class TestCommand extends Command {
if (filesToTest.length === 0) { if (filesToTest.length === 0) {
if (!this.json) { if (!this.json) {
console.log(chalk.yellow(`No skills found matching "${this.skill}"`)); warn(`No skills found matching "${this.skill}"`);
} }
return 1; return 1;
} }
if (!this.json) { if (!this.json) {
console.log(chalk.bold('Running skill tests...\n')); console.log(colors.bold('Running skill tests...\n'));
} }
// Parse tags // Parse tags
@@ -126,7 +126,7 @@ export class TestCommand extends Command {
} }
if (!this.json) { if (!this.json) {
console.log(chalk.blue(`Testing: ${suite.skillName}`)); step(`Testing: ${suite.skillName}`);
} }
const result = await runTestSuite(suite, { const result = await runTestSuite(suite, {
@@ -141,21 +141,21 @@ export class TestCommand extends Command {
switch (event.type) { switch (event.type) {
case 'test_start': case 'test_start':
console.log(chalk.dim(` Running: ${event.testName}`)); console.log(colors.muted(` Running: ${event.testName}`));
break; break;
case 'test_end': case 'test_end':
if (event.passed) { if (event.passed) {
console.log(chalk.green(` ✓ ${event.testName}`)); console.log(colors.success(` ✓ ${event.testName}`));
} else { } else {
console.log(chalk.red(` ✗ ${event.testName}`)); console.log(colors.error(` ✗ ${event.testName}`));
if (event.error) { if (event.error) {
console.log(chalk.red(` ${event.error}`)); console.log(colors.error(` ${event.error}`));
} }
} }
break; break;
case 'assertion_end': case 'assertion_end':
if (this.verbose && !event.passed) { if (this.verbose && !event.passed) {
console.log(chalk.red(` - ${event.assertionType}: ${event.error}`)); console.log(colors.error(` - ${event.assertionType}: ${event.error}`));
} }
break; break;
} }
@@ -169,7 +169,7 @@ export class TestCommand extends Command {
} }
if (!this.json) { if (!this.json) {
const icon = result.passed ? chalk.green('✓') : chalk.red('✗'); const icon = result.passed ? colors.success('✓') : colors.error('✗');
const status = result.passed ? 'PASSED' : 'FAILED'; const status = result.passed ? 'PASSED' : 'FAILED';
console.log( console.log(
`${icon} ${suite.skillName}: ${result.passedCount}/${result.tests.length} tests ${status} (${result.duration}ms)\n` `${icon} ${suite.skillName}: ${result.passedCount}/${result.tests.length} tests ${status} (${result.duration}ms)\n`
@@ -203,21 +203,21 @@ export class TestCommand extends Command {
const failedTests = results.reduce((acc, r) => acc + r.failedCount, 0); const failedTests = results.reduce((acc, r) => acc + r.failedCount, 0);
const skippedTests = results.reduce((acc, r) => acc + r.skippedCount, 0); const skippedTests = results.reduce((acc, r) => acc + r.skippedCount, 0);
console.log(chalk.bold('Summary:')); console.log(colors.bold('Summary:'));
console.log(` Skills tested: ${results.length}`); console.log(` Skills tested: ${results.length}`);
console.log(` Total tests: ${totalTests}`); console.log(` Total tests: ${totalTests}`);
console.log(chalk.green(` Passed: ${passedTests}`)); console.log(colors.success(` Passed: ${passedTests}`));
if (failedTests > 0) { if (failedTests > 0) {
console.log(chalk.red(` Failed: ${failedTests}`)); console.log(colors.error(` Failed: ${failedTests}`));
} }
if (skippedTests > 0) { if (skippedTests > 0) {
console.log(chalk.yellow(` Skipped: ${skippedTests}`)); console.log(colors.warning(` Skipped: ${skippedTests}`));
} }
if (allPassed) { if (allPassed) {
console.log(chalk.green('\n✓ All tests passed!')); success('\n✓ All tests passed!');
} else { } else {
console.log(chalk.red('\n✗ Some tests failed.')); error('\n✗ Some tests failed.');
} }
} }
+5 -5
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, warn, error } from '../onboarding/index.js';
import { SessionTimeline } from '@skillkit/core'; import { SessionTimeline } from '@skillkit/core';
import type { TimelineEventType } from '@skillkit/core'; import type { TimelineEventType } from '@skillkit/core';
@@ -52,8 +52,8 @@ export class TimelineCommand extends Command {
let types: TimelineEventType[] | undefined; let types: TimelineEventType[] | undefined;
if (this.type) { if (this.type) {
if (!validTypes.includes(this.type as TimelineEventType)) { if (!validTypes.includes(this.type as TimelineEventType)) {
console.log(chalk.red(`Invalid event type: ${this.type}`)); error(`Invalid event type: ${this.type}`);
console.log(chalk.dim(`Valid types: ${validTypes.join(', ')}`)); console.log(colors.muted(`Valid types: ${validTypes.join(', ')}`));
return 1; return 1;
} }
types = [this.type as TimelineEventType]; types = [this.type as TimelineEventType];
@@ -72,8 +72,8 @@ export class TimelineCommand extends Command {
} }
if (data.events.length === 0) { if (data.events.length === 0) {
console.log(chalk.yellow('No timeline events found.')); warn('No timeline events found.');
console.log(chalk.dim('Events are recorded during skill execution, git commits, and observations.')); console.log(colors.muted('Events are recorded during skill execution, git commits, and observations.'));
return 0; return 0;
} }
+49 -49
View File
@@ -1,7 +1,7 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'; import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, basename, dirname } from 'node:path'; import { join, basename, dirname } from 'node:path';
import chalk from 'chalk'; import { colors, warn, success, error } from '../onboarding/index.js';
import { import {
type AgentType, type AgentType,
translateSkill, translateSkill,
@@ -102,15 +102,15 @@ export class TranslateCommand extends Command {
// Validate target agent // Validate target agent
if (!this.to) { if (!this.to) {
console.error(chalk.red('Error: --to/-t target agent is required')); error('--to/-t target agent is required');
console.log(chalk.gray('Use --list to see all supported agents')); console.log(colors.muted('Use --list to see all supported agents'));
return 1; return 1;
} }
const targetAgent = this.to as AgentType; const targetAgent = this.to as AgentType;
if (!getSupportedTranslationAgents().includes(targetAgent)) { if (!getSupportedTranslationAgents().includes(targetAgent)) {
console.error(chalk.red(`Error: Unknown target agent "${this.to}"`)); error(`Unknown target agent "${this.to}"`);
console.log(chalk.gray('Use --list to see all supported agents')); console.log(colors.muted('Use --list to see all supported agents'));
return 1; return 1;
} }
@@ -121,7 +121,7 @@ export class TranslateCommand extends Command {
// Translate single skill // Translate single skill
if (!this.source) { if (!this.source) {
console.error(chalk.red('Error: Please specify a skill name or path, or use --all')); error('Please specify a skill name or path, or use --all');
return 1; return 1;
} }
@@ -132,7 +132,7 @@ export class TranslateCommand extends Command {
* List all supported agents and their formats * List all supported agents and their formats
*/ */
private listAgents(): number { private listAgents(): number {
console.log(chalk.bold('\nSupported Agents for Translation:\n')); console.log(colors.bold('\nSupported Agents for Translation:\n'));
const agents = getSupportedTranslationAgents(); const agents = getSupportedTranslationAgents();
const adapters = getAllAdapters(); const adapters = getAllAdapters();
@@ -154,17 +154,17 @@ export class TranslateCommand extends Command {
}; };
for (const [format, formatAgents] of Object.entries(byFormat)) { for (const [format, formatAgents] of Object.entries(byFormat)) {
console.log(chalk.cyan(` ${formatNames[format] || format}:`)); console.log(colors.cyan(` ${formatNames[format] || format}:`));
for (const agent of formatAgents) { for (const agent of formatAgents) {
const adapter = adapters.find(a => a.type === agent); const adapter = adapters.find(a => a.type === agent);
const name = adapter?.name || agent; const name = adapter?.name || agent;
console.log(` ${chalk.green(agent.padEnd(16))} ${chalk.gray(name)}`); console.log(` ${colors.success(agent.padEnd(16))} ${colors.muted(name)}`);
} }
console.log(); console.log();
} }
console.log(chalk.gray('All formats can translate to any other format.')); console.log(colors.muted('All formats can translate to any other format.'));
console.log(chalk.gray('Use --compat to see compatibility details.\n')); console.log(colors.muted('Use --compat to see compatibility details.\n'));
return 0; return 0;
} }
@@ -174,7 +174,7 @@ export class TranslateCommand extends Command {
*/ */
private showCompatibility(): number { private showCompatibility(): number {
if (!this.from || !this.to) { if (!this.from || !this.to) {
console.error(chalk.red('Error: Both --from and --to are required for compatibility check')); error('Both --from and --to are required for compatibility check');
return 1; return 1;
} }
@@ -183,26 +183,26 @@ export class TranslateCommand extends Command {
const info = translatorRegistry.getCompatibilityInfo(fromAgent, toAgent); const info = translatorRegistry.getCompatibilityInfo(fromAgent, toAgent);
console.log(chalk.bold(`\nTranslation: ${fromAgent} → ${toAgent}\n`)); console.log(colors.bold(`\nTranslation: ${fromAgent} → ${toAgent}\n`));
if (info.supported) { if (info.supported) {
console.log(chalk.green(' ✓ Translation supported')); console.log(colors.success(' ✓ Translation supported'));
} else { } else {
console.log(chalk.red(' ✗ Translation not supported')); console.log(colors.error(' ✗ Translation not supported'));
return 1; return 1;
} }
if (info.warnings.length > 0) { if (info.warnings.length > 0) {
console.log(chalk.yellow('\n Warnings:')); warn('\n Warnings:');
for (const warning of info.warnings) { for (const warning of info.warnings) {
console.log(chalk.yellow(` • ${warning}`)); console.log(colors.warning(` • ${warning}`));
} }
} }
if (info.lossyFields.length > 0) { if (info.lossyFields.length > 0) {
console.log(chalk.gray('\n Fields with reduced functionality:')); console.log(colors.muted('\n Fields with reduced functionality:'));
for (const field of info.lossyFields) { for (const field of info.lossyFields) {
console.log(chalk.gray(` • ${field}`)); console.log(colors.muted(` • ${field}`));
} }
} }
@@ -218,19 +218,19 @@ export class TranslateCommand extends Command {
const skills = findAllSkills(searchDirs); const skills = findAllSkills(searchDirs);
if (skills.length === 0) { if (skills.length === 0) {
console.log(chalk.yellow('No skills found to translate')); warn('No skills found to translate');
return 0; return 0;
} }
console.log(chalk.bold(`\nTranslating ${skills.length} skill(s) to ${targetAgent}...\n`)); console.log(colors.bold(`\nTranslating ${skills.length} skill(s) to ${targetAgent}...\n`));
let success = 0; let successCount = 0;
let failed = 0; let failed = 0;
for (const skill of skills) { for (const skill of skills) {
const skillMdPath = join(skill.path, 'SKILL.md'); const skillMdPath = join(skill.path, 'SKILL.md');
if (!existsSync(skillMdPath)) { if (!existsSync(skillMdPath)) {
console.log(chalk.yellow(` ⚠ ${skill.name}: No SKILL.md found`)); warn(` ⚠ ${skill.name}: No SKILL.md found`);
failed++; failed++;
continue; continue;
} }
@@ -241,10 +241,10 @@ export class TranslateCommand extends Command {
if (result.success) { if (result.success) {
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.green(` ✓ ${skill.name} → ${result.filename} (dry run)`)); success(` ✓ ${skill.name} → ${result.filename} (dry run)`);
if (result.warnings.length > 0) { if (result.warnings.length > 0) {
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.gray(` ${warning}`)); console.log(colors.muted(` ${warning}`));
} }
} }
} else { } else {
@@ -259,33 +259,33 @@ export class TranslateCommand extends Command {
const outputPath = join(outputDir, result.filename); const outputPath = join(outputDir, result.filename);
if (existsSync(outputPath) && !this.force) { if (existsSync(outputPath) && !this.force) {
console.log(chalk.yellow(` ⚠ ${skill.name}: ${outputPath} exists (use --force)`)); warn(` ⚠ ${skill.name}: ${outputPath} exists (use --force)`);
failed++; failed++;
continue; continue;
} }
writeFileSync(outputPath, result.content, 'utf-8'); writeFileSync(outputPath, result.content, 'utf-8');
console.log(chalk.green(` ✓ ${skill.name} → ${outputPath}`)); success(` ✓ ${skill.name} → ${outputPath}`);
} }
if (result.incompatible.length > 0) { if (result.incompatible.length > 0) {
for (const item of result.incompatible) { for (const item of result.incompatible) {
console.log(chalk.gray(` ⚠ ${item}`)); console.log(colors.muted(` ⚠ ${item}`));
} }
} }
success++; successCount++;
} else { } else {
console.log(chalk.red(` ✗ ${skill.name}: Translation failed`)); console.log(colors.error(` ✗ ${skill.name}: Translation failed`));
for (const item of result.incompatible) { for (const item of result.incompatible) {
console.log(chalk.red(` ${item}`)); console.log(colors.error(` ${item}`));
} }
failed++; failed++;
} }
} }
console.log(); console.log();
console.log(chalk.bold(`Translated: ${success}, Failed: ${failed}`)); console.log(colors.bold(`Translated: ${successCount}, Failed: ${failed}`));
return failed > 0 ? 1 : 0; return failed > 0 ? 1 : 0;
} }
@@ -322,10 +322,10 @@ export class TranslateCommand extends Command {
} }
if (!found) { if (!found) {
console.error(chalk.red(`Error: Skill "${source}" not found`)); error(`Skill "${source}" not found`);
console.log(chalk.gray('Searched in:')); console.log(colors.muted('Searched in:'));
for (const dir of searchDirs) { for (const dir of searchDirs) {
console.log(chalk.gray(` ${dir}`)); console.log(colors.muted(` ${dir}`));
} }
return 1; return 1;
} }
@@ -339,35 +339,35 @@ export class TranslateCommand extends Command {
}); });
if (!result.success) { if (!result.success) {
console.error(chalk.red('Translation failed:')); error('Translation failed:');
for (const item of result.incompatible) { for (const item of result.incompatible) {
console.error(chalk.red(` ${item}`)); console.log(colors.muted(` ${item}`));
} }
return 1; return 1;
} }
// Show warnings // Show warnings
if (result.warnings.length > 0) { if (result.warnings.length > 0) {
console.log(chalk.yellow('\nWarnings:')); warn('\nWarnings:');
for (const warning of result.warnings) { for (const warning of result.warnings) {
console.log(chalk.yellow(` • ${warning}`)); console.log(colors.warning(` • ${warning}`));
} }
} }
// Show incompatible features // Show incompatible features
if (result.incompatible.length > 0) { if (result.incompatible.length > 0) {
console.log(chalk.gray('\nIncompatible features:')); console.log(colors.muted('\nIncompatible features:'));
for (const item of result.incompatible) { for (const item of result.incompatible) {
console.log(chalk.gray(` • ${item}`)); console.log(colors.muted(` • ${item}`));
} }
} }
// Dry run - just show preview // Dry run - just show preview
if (this.dryRun) { if (this.dryRun) {
console.log(chalk.bold(`\nTranslated content (${result.filename}):\n`)); console.log(colors.bold(`\nTranslated content (${result.filename}):\n`));
console.log(chalk.gray('─'.repeat(60))); console.log(colors.muted('─'.repeat(60)));
console.log(result.content); console.log(result.content);
console.log(chalk.gray('─'.repeat(60))); console.log(colors.muted('─'.repeat(60)));
return 0; return 0;
} }
@@ -388,8 +388,8 @@ export class TranslateCommand extends Command {
// Check for existing file // Check for existing file
if (existsSync(outputPath) && !this.force) { if (existsSync(outputPath) && !this.force) {
console.error(chalk.red(`Error: ${outputPath} already exists`)); error(`${outputPath} already exists`);
console.log(chalk.gray('Use --force to overwrite')); console.log(colors.muted('Use --force to overwrite'));
return 1; return 1;
} }
@@ -401,9 +401,9 @@ export class TranslateCommand extends Command {
writeFileSync(outputPath, result.content, 'utf-8'); writeFileSync(outputPath, result.content, 'utf-8');
console.log(chalk.green(`\n✓ Translated to ${outputPath}`)); success(`\n✓ Translated to ${outputPath}`);
console.log(chalk.gray(` Format: ${result.targetFormat}`)); console.log(colors.muted(` Format: ${result.targetFormat}`));
console.log(chalk.gray(` Agent: ${result.targetAgent}`)); console.log(colors.muted(` Agent: ${result.targetAgent}`));
return 0; return 0;
} }
+59 -25
View File
@@ -1,10 +1,9 @@
import { existsSync, rmSync, cpSync } from 'node:fs'; import { existsSync, rmSync, cpSync } from 'node:fs';
import { join } from 'node:path'; import { join } from 'node:path';
import chalk from 'chalk';
import ora from 'ora';
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { findAllSkills, findSkill, detectProvider, isLocalPath } from '@skillkit/core'; import { findAllSkills, findSkill, detectProvider, isLocalPath, computeSkillChecksum, addSkillToLock } from '@skillkit/core';
import { getSearchDirs, loadSkillMetadata, saveSkillMetadata } from '../helpers.js'; import { getSearchDirs, loadSkillMetadata, saveSkillMetadata, fetchGitHubActivity } from '../helpers.js';
import { colors, spinner, warn, step } from '../onboarding/index.js';
export class UpdateCommand extends Command { export class UpdateCommand extends Command {
static override paths = [['update'], ['u']]; static override paths = [['update'], ['u']];
@@ -25,7 +24,7 @@ export class UpdateCommand extends Command {
}); });
async execute(): Promise<number> { async execute(): Promise<number> {
const spinner = ora(); const s = spinner();
const searchDirs = getSearchDirs(); const searchDirs = getSearchDirs();
let skillsToUpdate; let skillsToUpdate;
@@ -37,18 +36,18 @@ export class UpdateCommand extends Command {
const notFound = this.skills.filter(name => !findSkill(name, searchDirs)); const notFound = this.skills.filter(name => !findSkill(name, searchDirs));
if (notFound.length > 0) { if (notFound.length > 0) {
console.log(chalk.yellow(`Skills not found: ${notFound.join(', ')}`)); warn(`Skills not found: ${notFound.join(', ')}`);
} }
} else { } else {
skillsToUpdate = findAllSkills(searchDirs); skillsToUpdate = findAllSkills(searchDirs);
} }
if (skillsToUpdate.length === 0) { if (skillsToUpdate.length === 0) {
console.log(chalk.yellow('No skills to update')); warn('No skills to update');
return 0; return 0;
} }
console.log(chalk.cyan(`Updating ${skillsToUpdate.length} skill(s)...\n`)); step(`Updating ${skillsToUpdate.length} skill(s)...`);
let updated = 0; let updated = 0;
let skipped = 0; let skipped = 0;
@@ -58,12 +57,12 @@ export class UpdateCommand extends Command {
const metadata = loadSkillMetadata(skill.path); const metadata = loadSkillMetadata(skill.path);
if (!metadata) { if (!metadata) {
console.log(chalk.dim(`Skipping ${skill.name} (no metadata, reinstall needed)`)); console.log(colors.muted(`Skipping ${skill.name} (no metadata, reinstall needed)`));
skipped++; skipped++;
continue; continue;
} }
spinner.start(`Updating ${skill.name}...`); s.start(`Updating ${skill.name}...`);
try { try {
if (isLocalPath(metadata.source)) { if (isLocalPath(metadata.source)) {
@@ -72,14 +71,14 @@ export class UpdateCommand extends Command {
: metadata.source; : metadata.source;
if (!existsSync(localPath)) { if (!existsSync(localPath)) {
spinner.warn(chalk.yellow(`${skill.name}: local source missing`)); s.stop(colors.warning(`${skill.name}: local source missing`));
skipped++; skipped++;
continue; continue;
} }
const skillMdPath = join(localPath, 'SKILL.md'); const skillMdPath = join(localPath, 'SKILL.md');
if (!existsSync(skillMdPath)) { if (!existsSync(skillMdPath)) {
spinner.warn(chalk.yellow(`${skill.name}: no SKILL.md at source`)); s.stop(colors.warning(`${skill.name}: no SKILL.md at source`));
skipped++; skipped++;
continue; continue;
} }
@@ -87,24 +86,45 @@ export class UpdateCommand extends Command {
rmSync(skill.path, { recursive: true, force: true }); rmSync(skill.path, { recursive: true, force: true });
cpSync(localPath, skill.path, { recursive: true, dereference: true }); cpSync(localPath, skill.path, { recursive: true, dereference: true });
metadata.checksum = computeSkillChecksum(skill.path);
metadata.updatedAt = new Date().toISOString(); metadata.updatedAt = new Date().toISOString();
saveSkillMetadata(skill.path, metadata); saveSkillMetadata(skill.path, metadata);
addSkillToLock(skill.name, {
source: metadata.source,
sourceType: metadata.sourceType,
installedAt: metadata.installedAt,
updatedAt: metadata.updatedAt,
checksum: metadata.checksum,
agents: [],
path: skill.path,
});
spinner.succeed(chalk.green(`Updated ${skill.name}`)); s.stop(`Updated ${skill.name}`);
updated++; updated++;
} else { } else {
const provider = detectProvider(metadata.source); const provider = detectProvider(metadata.source);
if (!provider) { if (!provider) {
spinner.warn(chalk.yellow(`${skill.name}: unknown provider`)); s.stop(colors.warning(`${skill.name}: unknown provider`));
skipped++; skipped++;
continue; continue;
} }
const parsed = provider.parseSource?.(metadata.source);
if (!this.force && parsed && 'owner' in parsed && 'repo' in parsed && (provider.type === 'github' || provider.type === 'skills-sh')) {
const activity = await fetchGitHubActivity(parsed.owner, parsed.repo);
const localDate = metadata.updatedAt ?? metadata.installedAt;
if (activity?.pushedAt && localDate && activity.pushedAt <= localDate) {
s.stop(`${skill.name}: no changes detected`);
skipped++;
continue;
}
}
const result = await provider.clone(metadata.source, '', { depth: 1 }); const result = await provider.clone(metadata.source, '', { depth: 1 });
if (!result.success || !result.path) { if (!result.success || !result.path) {
spinner.fail(chalk.red(`${skill.name}: ${result.error || 'clone failed'}`)); s.stop(colors.error(`${skill.name}: ${result.error || 'clone failed'}`));
failed++; failed++;
continue; continue;
} }
@@ -115,7 +135,15 @@ export class UpdateCommand extends Command {
const skillMdPath = join(sourcePath, 'SKILL.md'); const skillMdPath = join(sourcePath, 'SKILL.md');
if (!existsSync(skillMdPath)) { if (!existsSync(skillMdPath)) {
spinner.warn(chalk.yellow(`${skill.name}: no SKILL.md in source`)); s.stop(colors.warning(`${skill.name}: no SKILL.md in source`));
rmSync(result.path, { recursive: true, force: true });
skipped++;
continue;
}
const newChecksum = computeSkillChecksum(sourcePath);
if (!this.force && newChecksum && metadata.checksum && newChecksum === metadata.checksum) {
s.stop(`${skill.name}: already up to date`);
rmSync(result.path, { recursive: true, force: true }); rmSync(result.path, { recursive: true, force: true });
skipped++; skipped++;
continue; continue;
@@ -126,25 +154,31 @@ export class UpdateCommand extends Command {
rmSync(result.path, { recursive: true, force: true }); rmSync(result.path, { recursive: true, force: true });
metadata.checksum = computeSkillChecksum(skill.path);
metadata.updatedAt = new Date().toISOString(); metadata.updatedAt = new Date().toISOString();
saveSkillMetadata(skill.path, metadata); saveSkillMetadata(skill.path, metadata);
addSkillToLock(skill.name, {
source: metadata.source,
sourceType: metadata.sourceType,
installedAt: metadata.installedAt,
updatedAt: metadata.updatedAt,
checksum: metadata.checksum,
agents: [],
path: skill.path,
});
spinner.succeed(chalk.green(`Updated ${skill.name}`)); s.stop(`Updated ${skill.name}`);
updated++; updated++;
} }
} catch (error) { } catch (err) {
spinner.fail(chalk.red(`Failed to update ${skill.name}`)); s.stop(colors.error(`Failed to update ${skill.name}`));
console.error(chalk.dim(error instanceof Error ? error.message : String(error))); console.log(colors.muted(err instanceof Error ? err.message : String(err)));
failed++; failed++;
} }
} }
console.log(); console.log();
console.log( step(`Updated: ${updated}, Skipped: ${skipped}, Failed: ${failed}`);
chalk.cyan(
`Updated: ${updated}, Skipped: ${skipped}, Failed: ${failed}`
)
);
return failed > 0 ? 1 : 0; return failed > 0 ? 1 : 0;
} }
+5 -5
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, success } from '../../onboarding/index.js';
import { createWorkflowTemplate, saveWorkflow, serializeWorkflow } from '@skillkit/core'; import { createWorkflowTemplate, saveWorkflow, serializeWorkflow } from '@skillkit/core';
/** /**
@@ -52,11 +52,11 @@ export class WorkflowCreateCommand extends Command {
const filePath = saveWorkflow(targetPath, workflow); const filePath = saveWorkflow(targetPath, workflow);
console.log(chalk.green(`✓ Created workflow: ${chalk.bold(this.workflowName)}`)); success(`✓ Created workflow: ${colors.bold(this.workflowName)}`);
console.log(chalk.dim(` File: ${filePath}`)); console.log(colors.muted(` File: ${filePath}`));
console.log(); console.log();
console.log(chalk.dim('Edit the workflow file to add skills and configure waves.')); console.log(colors.muted('Edit the workflow file to add skills and configure waves.'));
console.log(chalk.dim('Run with: skillkit workflow run ' + this.workflowName)); console.log(colors.muted('Run with: skillkit workflow run ' + this.workflowName));
return 0; return 0;
} }
+14 -14
View File
@@ -1,6 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, warn, error, step } from '../../onboarding/index.js';
import { listWorkflows } from '@skillkit/core'; import { listWorkflows } from '@skillkit/core';
/** /**
@@ -43,8 +43,8 @@ export class WorkflowListCommand extends Command {
try { try {
workflows = listWorkflows(targetPath); workflows = listWorkflows(targetPath);
} catch (err) { } catch (err) {
console.log(chalk.red('Failed to list workflows.')); error('Failed to list workflows.');
console.log(chalk.dim(String(err))); console.log(colors.muted(String(err)));
return 1; return 1;
} }
@@ -54,40 +54,40 @@ export class WorkflowListCommand extends Command {
} }
if (workflows.length === 0) { if (workflows.length === 0) {
console.log(chalk.yellow('No workflows found.')); warn('No workflows found.');
console.log(chalk.dim('Create a workflow with: skillkit workflow create')); console.log(colors.muted('Create a workflow with: skillkit workflow create'));
console.log(chalk.dim('Or add YAML files to .skillkit/workflows/')); console.log(colors.muted('Or add YAML files to .skillkit/workflows/'));
return 0; return 0;
} }
console.log(chalk.cyan(`Available Workflows (${workflows.length}):\n`)); step(`Available Workflows (${workflows.length}):\n`);
for (const workflow of workflows) { for (const workflow of workflows) {
console.log(` ${chalk.bold(workflow.name)}`); console.log(` ${colors.bold(workflow.name)}`);
if (workflow.description) { if (workflow.description) {
console.log(` ${chalk.dim(workflow.description)}`); console.log(` ${colors.muted(workflow.description)}`);
} }
if (this.verbose) { if (this.verbose) {
console.log(` Version: ${chalk.dim(workflow.version || 'N/A')}`); console.log(` Version: ${colors.muted(workflow.version || 'N/A')}`);
console.log(` Waves: ${chalk.dim(workflow.waves.length.toString())}`); console.log(` Waves: ${colors.muted(workflow.waves.length.toString())}`);
const totalSkills = workflow.waves.reduce( const totalSkills = workflow.waves.reduce(
(sum, wave) => sum + wave.skills.length, (sum, wave) => sum + wave.skills.length,
0 0
); );
console.log(` Total Skills: ${chalk.dim(totalSkills.toString())}`); console.log(` Total Skills: ${colors.muted(totalSkills.toString())}`);
if (workflow.tags && workflow.tags.length > 0) { if (workflow.tags && workflow.tags.length > 0) {
console.log(` Tags: ${chalk.dim(workflow.tags.join(', '))}`); console.log(` Tags: ${colors.muted(workflow.tags.join(', '))}`);
} }
} }
console.log(); console.log();
} }
console.log(chalk.dim('Run a workflow with: skillkit workflow run <name>')); console.log(colors.muted('Run a workflow with: skillkit workflow run <name>'));
return 0; return 0;
} }
+22 -22
View File
@@ -1,5 +1,5 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import chalk from 'chalk'; import { colors, warn, success, error, step } from '../../onboarding/index.js';
import { import {
BUILTIN_PIPELINES, BUILTIN_PIPELINES,
getBuiltinPipeline, getBuiltinPipeline,
@@ -31,21 +31,21 @@ export class WorkflowPipelineCommand extends Command {
async execute(): Promise<number> { async execute(): Promise<number> {
if (!this.pipeline) { if (!this.pipeline) {
console.log(chalk.cyan('Usage: skillkit workflow pipeline <name>\n')); step('Usage: skillkit workflow pipeline <name>\n');
console.log('Available pipelines:'); console.log('Available pipelines:');
for (const p of BUILTIN_PIPELINES) { for (const p of BUILTIN_PIPELINES) {
console.log(` ${chalk.bold(p.id)} - ${p.description}`); console.log(` ${colors.bold(p.id)} - ${p.description}`);
} }
console.log(); console.log();
console.log(chalk.dim('Run: skillkit workflow pipeline list for details')); console.log(colors.muted('Run: skillkit workflow pipeline list for details'));
return 0; return 0;
} }
const pipeline = getBuiltinPipeline(this.pipeline); const pipeline = getBuiltinPipeline(this.pipeline);
if (!pipeline) { if (!pipeline) {
console.log(chalk.red(`Pipeline not found: ${this.pipeline}`)); error(`Pipeline not found: ${this.pipeline}`);
console.log(chalk.dim('Run `skillkit workflow pipeline list` to see available pipelines')); console.log(colors.muted('Run `skillkit workflow pipeline list` to see available pipelines'));
return 1; return 1;
} }
@@ -57,46 +57,46 @@ export class WorkflowPipelineCommand extends Command {
} }
private showPipeline(pipeline: AgentPipeline): number { private showPipeline(pipeline: AgentPipeline): number {
console.log(chalk.cyan(`Pipeline: ${pipeline.name}\n`)); step(`Pipeline: ${pipeline.name}\n`);
console.log(`Description: ${pipeline.description}`); console.log(`Description: ${pipeline.description}`);
console.log(); console.log();
console.log(chalk.bold('Stages:')); console.log(colors.bold('Stages:'));
for (let i = 0; i < pipeline.stages.length; i++) { for (let i = 0; i < pipeline.stages.length; i++) {
const stage = pipeline.stages[i]; const stage = pipeline.stages[i];
const arrow = i < pipeline.stages.length - 1 ? '→' : ''; const arrow = i < pipeline.stages.length - 1 ? '→' : '';
console.log(` ${i + 1}. ${chalk.bold(stage.name)} (@${stage.agent})`); console.log(` ${i + 1}. ${colors.bold(stage.name)} (@${stage.agent})`);
console.log(` ${chalk.dim(stage.description)}`); console.log(` ${colors.muted(stage.description)}`);
if (arrow) { if (arrow) {
console.log(` ${chalk.dim(arrow)}`); console.log(` ${colors.muted(arrow)}`);
} }
} }
console.log(); console.log();
console.log(chalk.dim('(dry-run mode - no execution)')); console.log(colors.muted('(dry-run mode - no execution)'));
return 0; return 0;
} }
private async runPipeline(pipeline: AgentPipeline): Promise<number> { private async runPipeline(pipeline: AgentPipeline): Promise<number> {
console.log(chalk.cyan(`Starting Pipeline: ${pipeline.name}\n`)); step(`Starting Pipeline: ${pipeline.name}\n`);
for (let i = 0; i < pipeline.stages.length; i++) { for (let i = 0; i < pipeline.stages.length; i++) {
const stage = pipeline.stages[i]; const stage = pipeline.stages[i];
const stageNum = `[${i + 1}/${pipeline.stages.length}]`; const stageNum = `[${i + 1}/${pipeline.stages.length}]`;
console.log(`${chalk.blue(stageNum)} ${chalk.bold(stage.name)}`); console.log(`${colors.info(stageNum)} ${colors.bold(stage.name)}`);
console.log(` Agent: @${stage.agent}`); console.log(` Agent: @${stage.agent}`);
console.log(` ${chalk.dim(stage.description)}`); console.log(` ${colors.muted(stage.description)}`);
console.log(); console.log();
console.log(chalk.yellow(` → Invoke @${stage.agent} for: ${stage.description}`)); warn(` → Invoke @${stage.agent} for: ${stage.description}`);
console.log(chalk.dim(' (Manual agent invocation required in current implementation)')); console.log(colors.muted(' (Manual agent invocation required in current implementation)'));
console.log(); console.log();
} }
console.log(chalk.green('✓ Pipeline stages displayed')); success('✓ Pipeline stages displayed');
console.log(chalk.dim('Execute each stage by invoking the agents in order')); console.log(colors.muted('Execute each stage by invoking the agents in order'));
return 0; return 0;
} }
@@ -122,16 +122,16 @@ export class WorkflowPipelineListCommand extends Command {
return 0; return 0;
} }
console.log(chalk.cyan(`Available Pipelines (${pipelines.length}):\n`)); step(`Available Pipelines (${pipelines.length}):\n`);
for (const pipeline of pipelines) { for (const pipeline of pipelines) {
console.log(chalk.bold(` ${pipeline.id}`)); console.log(colors.bold(` ${pipeline.id}`));
console.log(` ${pipeline.name}: ${pipeline.description}`); console.log(` ${pipeline.name}: ${pipeline.description}`);
console.log(` Stages: ${pipeline.stages.map(s => s.name).join(' → ')}`); console.log(` Stages: ${pipeline.stages.map(s => s.name).join(' → ')}`);
console.log(); console.log();
} }
console.log(chalk.dim('Run with: skillkit workflow pipeline <name>')); console.log(colors.muted('Run with: skillkit workflow pipeline <name>'));
return 0; return 0;
} }
+31 -36
View File
@@ -1,7 +1,6 @@
import { Command, Option } from 'clipanion'; import { Command, Option } from 'clipanion';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import chalk from 'chalk'; import { colors, success, error as errorFn, spinner } from '../../onboarding/index.js';
import ora from 'ora';
import { import {
loadWorkflowByName, loadWorkflowByName,
loadWorkflow, loadWorkflow,
@@ -87,25 +86,25 @@ export class WorkflowRunCommand extends Command {
} else if (this.workflowName) { } else if (this.workflowName) {
workflow = loadWorkflowByName(targetPath, this.workflowName); workflow = loadWorkflowByName(targetPath, this.workflowName);
if (!workflow) { if (!workflow) {
console.error(chalk.red(`Workflow "${this.workflowName}" not found`)); errorFn(`Workflow "${this.workflowName}" not found`);
console.log(chalk.dim('List available workflows: skillkit workflow list')); console.log(colors.muted('List available workflows: skillkit workflow list'));
return 1; return 1;
} }
} else { } else {
console.error(chalk.red('Please specify a workflow name or --file')); errorFn('Please specify a workflow name or --file');
return 1; return 1;
} }
} catch (error) { } catch (err) {
console.error(chalk.red(`Failed to load workflow: ${error}`)); errorFn(`Failed to load workflow: ${err}`);
return 1; return 1;
} }
// Validate workflow // Validate workflow
const validation = validateWorkflow(workflow); const validation = validateWorkflow(workflow);
if (!validation.valid) { if (!validation.valid) {
console.error(chalk.red('Invalid workflow:')); errorFn('Invalid workflow:');
for (const error of validation.errors) { for (const validationError of validation.errors) {
console.error(chalk.red(` • ${error}`)); errorFn(` • ${validationError}`);
} }
return 1; return 1;
} }
@@ -117,13 +116,13 @@ export class WorkflowRunCommand extends Command {
} }
// Execute workflow // Execute workflow
console.log(chalk.cyan(`Executing workflow: ${chalk.bold(workflow.name)}`)); console.log(colors.cyan(`Executing workflow: ${colors.bold(workflow.name)}`));
if (workflow.description) { if (workflow.description) {
console.log(chalk.dim(workflow.description)); console.log(colors.muted(workflow.description));
} }
console.log(); console.log();
const spinner = ora(); const spin = spinner();
let currentWave = -1; let currentWave = -1;
// Create the skill executor (real or simulated) // Create the skill executor (real or simulated)
@@ -132,7 +131,7 @@ export class WorkflowRunCommand extends Command {
delay: 500, delay: 500,
onExecute: (skillName) => { onExecute: (skillName) => {
if (this.verbose && !this.json) { if (this.verbose && !this.json) {
console.log(chalk.dim(` [Simulated] ${skillName}`)); console.log(colors.muted(` [Simulated] ${skillName}`));
} }
}, },
}) })
@@ -144,17 +143,17 @@ export class WorkflowRunCommand extends Command {
if (this.verbose && !this.json) { if (this.verbose && !this.json) {
switch (event.type) { switch (event.type) {
case 'skill_found': case 'skill_found':
console.log(chalk.dim(` Found: ${event.message}`)); console.log(colors.muted(` Found: ${event.message}`));
break; break;
case 'skill_not_found': case 'skill_not_found':
console.log(chalk.red(` Not found: ${event.skillName}`)); console.log(colors.error(` Not found: ${event.skillName}`));
break; break;
case 'agent_selected': case 'agent_selected':
console.log(chalk.dim(` Agent: ${event.agent}`)); console.log(colors.muted(` Agent: ${event.agent}`));
break; break;
case 'execution_complete': case 'execution_complete':
if (!event.success) { if (!event.success) {
console.log(chalk.red(` Error: ${event.error}`)); console.log(colors.error(` Error: ${event.error}`));
} }
break; break;
} }
@@ -171,38 +170,34 @@ export class WorkflowRunCommand extends Command {
switch (event.type) { switch (event.type) {
case 'wave_start': case 'wave_start':
currentWave = event.waveIndex || 0; currentWave = event.waveIndex || 0;
spinner.start(`Wave ${currentWave + 1}: ${event.waveName || 'Executing...'}`); spin.start(`Wave ${currentWave + 1}: ${event.waveName || 'Executing...'}`);
break; break;
case 'skill_start': case 'skill_start':
if (this.verbose) { if (this.verbose) {
spinner.text = `Wave ${currentWave + 1}: Running ${event.skillName}...`; spin.message(`Wave ${currentWave + 1}: Running ${event.skillName}...`);
} }
break; break;
case 'skill_complete': case 'skill_complete':
if (this.verbose) { if (this.verbose) {
const icon = event.status === 'completed' ? chalk.green('✓') : chalk.red('✗'); const icon = event.status === 'completed' ? colors.success('✓') : colors.error('✗');
console.log(` ${icon} ${event.skillName}`); console.log(` ${icon} ${event.skillName}`);
} }
break; break;
case 'wave_complete': case 'wave_complete':
const waveIcon = event.status === 'completed' ? chalk.green('✓') : chalk.red('✗'); spin.stop(`Wave ${(event.waveIndex || 0) + 1}: ${event.waveName || 'Complete'}`);
spinner.stopAndPersist({
symbol: waveIcon,
text: `Wave ${(event.waveIndex || 0) + 1}: ${event.waveName || 'Complete'}`,
});
break; break;
case 'workflow_complete': case 'workflow_complete':
console.log(); console.log();
if (event.status === 'completed') { if (event.status === 'completed') {
console.log(chalk.green('✓ Workflow completed successfully')); success('✓ Workflow completed successfully');
} else { } else {
console.log(chalk.red(`✗ Workflow ${event.status}`)); errorFn(`✗ Workflow ${event.status}`);
if (event.error) { if (event.error) {
console.log(chalk.red(` Error: ${event.error}`)); errorFn(` Error: ${event.error}`);
} }
} }
break; break;
@@ -220,19 +215,19 @@ export class WorkflowRunCommand extends Command {
} }
private showDryRun(workflow: { name: string; description?: string; waves: Array<{ name?: string; parallel: boolean; skills: Array<string | { skill: string }> }> }): void { private showDryRun(workflow: { name: string; description?: string; waves: Array<{ name?: string; parallel: boolean; skills: Array<string | { skill: string }> }> }): void {
console.log(chalk.cyan('Dry Run - Workflow Execution Plan')); console.log(colors.cyan('Dry Run - Workflow Execution Plan'));
console.log(); console.log();
console.log(`Workflow: ${chalk.bold(workflow.name)}`); console.log(`Workflow: ${colors.bold(workflow.name)}`);
if (workflow.description) { if (workflow.description) {
console.log(`Description: ${chalk.dim(workflow.description)}`); console.log(`Description: ${colors.muted(workflow.description)}`);
} }
console.log(); console.log();
for (let i = 0; i < workflow.waves.length; i++) { for (let i = 0; i < workflow.waves.length; i++) {
const wave = workflow.waves[i]; const wave = workflow.waves[i];
const modeLabel = wave.parallel ? chalk.blue('[parallel]') : chalk.yellow('[sequential]'); const modeLabel = wave.parallel ? colors.info('[parallel]') : colors.warning('[sequential]');
console.log(`${chalk.cyan(`Wave ${i + 1}`)}: ${wave.name || 'Unnamed'} ${modeLabel}`); console.log(`${colors.cyan(`Wave ${i + 1}`)}: ${wave.name || 'Unnamed'} ${modeLabel}`);
for (const skill of wave.skills) { for (const skill of wave.skills) {
const skillName = typeof skill === 'string' ? skill : skill.skill; const skillName = typeof skill === 'string' ? skill : skill.skill;
@@ -242,7 +237,7 @@ export class WorkflowRunCommand extends Command {
console.log(); console.log();
} }
console.log(chalk.dim('This is a dry run. No skills were executed.')); console.log(colors.muted('This is a dry run. No skills were executed.'));
console.log(chalk.dim('Remove --dry-run to execute the workflow.')); console.log(colors.muted('Remove --dry-run to execute the workflow.'));
} }
} }
+83 -36
View File
@@ -1,4 +1,6 @@
// Re-export commonly used functions with proper adapters import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { homedir } from 'node:os';
import { import {
loadConfig, loadConfig,
getSearchDirs as coreGetSearchDirs, getSearchDirs as coreGetSearchDirs,
@@ -8,59 +10,40 @@ import {
loadSkillMetadata as coreLoadSkillMetadata, loadSkillMetadata as coreLoadSkillMetadata,
saveSkillMetadata as coreSaveSkillMetadata, saveSkillMetadata as coreSaveSkillMetadata,
} from "@skillkit/core"; } from "@skillkit/core";
import { getAdapter, detectAgent } from "@skillkit/agents"; import { getAdapter, detectAgent, getAllAdapters } from "@skillkit/agents";
import type { AgentType, AgentAdapterInfo } from "@skillkit/core"; import type { AgentType, AgentAdapterInfo } from "@skillkit/core";
// Re-export metadata functions directly (they don't need adapter bridging)
export const loadSkillMetadata = coreLoadSkillMetadata; export const loadSkillMetadata = coreLoadSkillMetadata;
export const saveSkillMetadata = coreSaveSkillMetadata; export const saveSkillMetadata = coreSaveSkillMetadata;
function toAdapterInfo(adapter: { type: AgentType; name: string; skillsDir: string; configFile: string }): AgentAdapterInfo {
return { type: adapter.type, name: adapter.name, skillsDir: adapter.skillsDir, configFile: adapter.configFile };
}
export function getSearchDirs(agentType?: AgentType): string[] { export function getSearchDirs(agentType?: AgentType): string[] {
const type = agentType || loadConfig().agent; const dirs = new Set<string>();
const adapter = getAdapter(type); const adapters = agentType ? [getAdapter(agentType)] : getAllAdapters();
const adapterInfo: AgentAdapterInfo = { for (const adapter of adapters) {
type: adapter.type, for (const dir of coreGetSearchDirs(toAdapterInfo(adapter))) {
name: adapter.name, dirs.add(dir);
skillsDir: adapter.skillsDir, }
configFile: adapter.configFile, }
}; return [...dirs];
return coreGetSearchDirs(adapterInfo);
} }
export function getInstallDir(global = false, agentType?: AgentType): string { export function getInstallDir(global = false, agentType?: AgentType): string {
const type = agentType || loadConfig().agent; const type = agentType || loadConfig().agent;
const adapter = getAdapter(type); return coreGetInstallDir(toAdapterInfo(getAdapter(type)), global);
const adapterInfo: AgentAdapterInfo = {
type: adapter.type,
name: adapter.name,
skillsDir: adapter.skillsDir,
configFile: adapter.configFile,
};
return coreGetInstallDir(adapterInfo, global);
} }
export function getAgentConfigPath(agentType?: AgentType): string { export function getAgentConfigPath(agentType?: AgentType): string {
const type = agentType || loadConfig().agent; const type = agentType || loadConfig().agent;
const adapter = getAdapter(type); return coreGetAgentConfigPath(toAdapterInfo(getAdapter(type)));
const adapterInfo: AgentAdapterInfo = {
type: adapter.type,
name: adapter.name,
skillsDir: adapter.skillsDir,
configFile: adapter.configFile,
};
return coreGetAgentConfigPath(adapterInfo);
} }
export async function initProject(agentType?: AgentType): Promise<void> { export async function initProject(agentType?: AgentType): Promise<void> {
const type = agentType || (await detectAgent()); const type = agentType || (await detectAgent());
const adapter = getAdapter(type); return coreInitProject(type, toAdapterInfo(getAdapter(type)));
const adapterInfo: AgentAdapterInfo = {
type: adapter.type,
name: adapter.name,
skillsDir: adapter.skillsDir,
configFile: adapter.configFile,
};
return coreInitProject(type, adapterInfo);
} }
export function formatCount(count: number): string { export function formatCount(count: number): string {
@@ -68,3 +51,67 @@ export function formatCount(count: number): string {
if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`; if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`;
return String(count); return String(count);
} }
export function timeAgo(dateStr: string): string {
const now = Date.now();
const then = new Date(dateStr).getTime();
if (Number.isNaN(then)) return 'unknown';
const days = Math.floor((now - then) / 86_400_000);
if (days === 0) return 'today';
if (days === 1) return 'yesterday';
if (days < 30) return `${days}d ago`;
if (days < 365) return `${Math.floor(days / 30)}mo ago`;
return `${Math.floor(days / 365)}y ago`;
}
export interface TapEntry {
source: string;
name?: string;
addedAt: string;
}
export interface TapsFile {
version: 1;
taps: TapEntry[];
}
const TAPS_FILE = join(homedir(), '.skillkit', 'taps.json');
export function loadTaps(): TapsFile {
if (!existsSync(TAPS_FILE)) return { version: 1, taps: [] };
try {
const data = JSON.parse(readFileSync(TAPS_FILE, 'utf-8'));
if (data && data.version === 1 && Array.isArray(data.taps)) {
return data as TapsFile;
}
return { version: 1, taps: [] };
} catch {
return { version: 1, taps: [] };
}
}
export function saveTaps(taps: TapsFile): void {
const dir = dirname(TAPS_FILE);
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
writeFileSync(TAPS_FILE, JSON.stringify(taps, null, 2), 'utf-8');
}
export async function fetchGitHubActivity(
owner: string,
repo: string,
): Promise<{ stars: number; pushedAt: string | null } | null> {
try {
const response = await fetch(
`https://api.github.com/repos/${owner}/${repo}`,
{ signal: AbortSignal.timeout(5000) },
);
if (!response.ok) return null;
const data = (await response.json()) as Record<string, unknown>;
return {
stars: typeof data.stargazers_count === 'number' ? data.stargazers_count : 0,
pushedAt: typeof data.pushed_at === 'string' ? data.pushed_at : null,
};
} catch {
return null;
}
}
+3
View File
@@ -4,5 +4,8 @@ export * from './commands/index.js';
// Export helper functions // Export helper functions
export * from './helpers.js'; export * from './helpers.js';
// Export onboarding utilities
export { setVersion, setAgentCount } from './onboarding/index.js';
// Re-export commonly used types from core // Re-export commonly used types from core
export type { AgentType, Skill, SkillMetadata, SkillkitConfig } from '@skillkit/core'; export type { AgentType, Skill, SkillMetadata, SkillkitConfig } from '@skillkit/core';
+21 -15
View File
@@ -12,6 +12,7 @@ export {
formatQualityBadge, formatQualityBadge,
formatQualityBadgeCompact, formatQualityBadgeCompact,
getQualityGradeFromScore, getQualityGradeFromScore,
formatTrustBadge,
} from './theme.js'; } from './theme.js';
export { export {
@@ -42,6 +43,7 @@ export {
select, select,
agentMultiselect, agentMultiselect,
quickAgentSelect, quickAgentSelect,
quickSkillSelect,
skillMultiselect, skillMultiselect,
groupMultiselect, groupMultiselect,
stepTrail, stepTrail,
@@ -87,8 +89,8 @@ import {
getLastAgents, getLastAgents,
} from './preferences.js'; } from './preferences.js';
let VERSION = '1.7.6'; let VERSION = 'dev';
let AGENT_COUNT = 44; let AGENT_COUNT = 0;
export function setVersion(version: string): void { export function setVersion(version: string): void {
VERSION = version; VERSION = version;
@@ -161,18 +163,22 @@ export async function runInstallFlow(options: InstallFlowOptions): Promise<Insta
} }
prompts.step(`Source: ${colors.cyan(source)}`); prompts.step(`Source: ${colors.cyan(source)}`);
prompts.step(`Found ${discoveredSkills.length} skill${discoveredSkills.length !== 1 ? 's' : ''}`);
const skillNames = discoveredSkills.map(s => s.name); let selectedSkills: string[];
const skillResult = await prompts.skillMultiselect({
message: 'Select skills to install',
skills: discoveredSkills.map(s => ({ name: s.name })),
initialValues: skillNames,
});
if (prompts.isCancel(skillResult)) { if (discoveredSkills.length > 1) {
prompts.cancel('Installation cancelled'); const skillResult = await prompts.quickSkillSelect({
return { selectedSkills: [], selectedAgents: [], installMethod: 'symlink', cancelled: true }; skills: discoveredSkills.map(s => ({ name: s.name })),
});
if (prompts.isCancel(skillResult)) {
prompts.cancel('Installation cancelled');
return { selectedSkills: [], selectedAgents: [], installMethod: 'symlink', cancelled: true };
}
selectedSkills = (skillResult as { skills: string[] }).skills;
} else {
selectedSkills = discoveredSkills.map(s => s.name);
} }
if (detectedAgents.length > 1) { if (detectedAgents.length > 1) {
@@ -190,7 +196,7 @@ export async function runInstallFlow(options: InstallFlowOptions): Promise<Insta
if (prompts.isCancel(agentResult)) { if (prompts.isCancel(agentResult)) {
prompts.cancel('Installation cancelled'); prompts.cancel('Installation cancelled');
return { selectedSkills: skillResult as string[], selectedAgents: [], installMethod: 'symlink', cancelled: true }; return { selectedSkills, selectedAgents: [], installMethod: 'symlink', cancelled: true };
} }
saveLastAgents(agentResult as string[]); saveLastAgents(agentResult as string[]);
@@ -202,7 +208,7 @@ export async function runInstallFlow(options: InstallFlowOptions): Promise<Insta
if (prompts.isCancel(methodResult)) { if (prompts.isCancel(methodResult)) {
prompts.cancel('Installation cancelled'); prompts.cancel('Installation cancelled');
return { return {
selectedSkills: skillResult as string[], selectedSkills,
selectedAgents: agentResult as string[], selectedAgents: agentResult as string[],
installMethod: 'symlink', installMethod: 'symlink',
cancelled: true, cancelled: true,
@@ -210,7 +216,7 @@ export async function runInstallFlow(options: InstallFlowOptions): Promise<Insta
} }
return { return {
selectedSkills: skillResult as string[], selectedSkills,
selectedAgents: agentResult as string[], selectedAgents: agentResult as string[],
installMethod: methodResult as 'symlink' | 'copy', installMethod: methodResult as 'symlink' | 'copy',
cancelled: false, cancelled: false,
+37
View File
@@ -213,6 +213,43 @@ export async function skillMultiselect(options: {
}); });
} }
export async function quickSkillSelect(options: {
message?: string;
skills: SkillOption[];
}): Promise<{ skills: string[]; method: 'all' | 'select' } | symbol> {
const { skills } = options;
const result = await clack.select({
message: options.message || `Found ${skills.length} skills — how would you like to install?`,
options: [
{ value: 'all' as const, label: 'Install all skills', hint: `${skills.length} skills` },
{ value: 'select' as const, label: 'Select specific skills', hint: 'Choose manually' },
],
});
if (clack.isCancel(result)) {
return result;
}
const method = result as 'all' | 'select';
if (method === 'all') {
return { skills: skills.map(s => s.name), method };
}
const selected = await skillMultiselect({
message: 'Select skills to install',
skills,
initialValues: [],
});
if (clack.isCancel(selected)) {
return selected;
}
return { skills: selected as string[], method };
}
export async function groupMultiselect<T extends string>(options: { export async function groupMultiselect<T extends string>(options: {
message: string; message: string;
options: Record<string, Array<{ value: T; label: string; hint?: string }>>; options: Record<string, Array<{ value: T; label: string; hint?: string }>>;

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