@chakresh/kresh 0.1.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@chakresh/kresh",
+  "version": "0.1.0",
+  "bin": {
+    "kresh": "./src/index.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "axios": "^1.6.8",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "inquirer": "^9.2.16"
+  }
+}

package/src/commands/install.js

@@ -0,0 +1,34 @@
+import ora from 'ora';
+import os from 'os';
+import path from 'path';
+import { api } from '../services/api.js';
+import { writeLocalSkill } from '../services/filesystem.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Installs a skill from the registry locally.
+ */
+export async function installSkill(skillSlug) {
+  const spinner = ora(`Fetching skill "${skillSlug}"...`).start();
+  try {
+    const response = await api.get(`/api/skills/${skillSlug}`);
+    const { skillContent, ...metadata } = response.data;
+
+    spinner.text = 'Writing skill files locally...';
+    const savedDir = await writeLocalSkill(skillSlug, skillContent, metadata);
+
+    spinner.succeed(`Successfully installed ${logger.bold(metadata.name)} (v${metadata.currentVersion}) by @${metadata.ownerUsername}`);
+    logger.info(`Saved to: ${logger.bold(savedDir)}`);
+  } catch (error) {
+    spinner.fail(`Installation failed for "${skillSlug}"`);
+    if (error.response) {
+      if (error.response.status === 404) {
+        logger.error(`Skill "${skillSlug}" was not found in the registry.`);
+      } else {
+        logger.error(`Registry error: ${error.response.data?.error || error.response.statusText}`);
+      }
+    } else {
+      logger.error(`Connection error: ${error.message}`);
+    }
+  }
+}

package/src/commands/ls.js

@@ -0,0 +1,23 @@
+import { listLocalSkills } from '../services/filesystem.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Lists all installed skills locally.
+ */
+export async function listInstalledSkills() {
+  const skills = await listLocalSkills();
+
+  if (skills.length === 0) {
+    logger.info('No skills installed locally. Run `kresh install <skill>` to install one.');
+    return;
+  }
+
+  logger.success(`Installed skills (${skills.length}):\n`);
+  skills.forEach((skill) => {
+    console.log(` • ${logger.bold(skill.name)} (${logger.dim(skill.slug)}) [v${skill.version}]`);
+    if (skill.description) {
+      console.log(`   ${logger.dim(skill.description)}`);
+    }
+  });
+  console.log();
+}

package/src/commands/publish.js

@@ -0,0 +1,13 @@
+import { logger } from '../utils/logger.js';
+
+/**
+ * Explains how users can publish a skill to the registry.
+ */
+export async function publishSkill() {
+  logger.info("To publish an intelligence skill, please follow these steps:");
+  console.log(" 1. Create a markdown file named SKILL.md specifying agent instructions.");
+  console.log(" 2. Open the publisher page: http://localhost:3000/dashboard/publish");
+  console.log(" 3. Enter the name, category, version, and upload or paste your SKILL.md content.");
+  console.log();
+  logger.success("Once published, anyone can install it with `kresh install <slug>`.");
+}

package/src/commands/remove.js

@@ -0,0 +1,20 @@
+import ora from 'ora';
+import { removeLocalSkill, readLocalSkillMetadata } from '../services/filesystem.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Removes/uninstalls a skill locally.
+ */
+export async function removeSkill(skillSlug) {
+  const metadata = await readLocalSkillMetadata(skillSlug);
+  const displayName = metadata ? metadata.name : skillSlug;
+  const spinner = ora(`Uninstalling local skill "${displayName}"...`).start();
+
+  try {
+    await removeLocalSkill(skillSlug);
+    spinner.succeed(`Successfully uninstalled "${logger.bold(displayName)}"`);
+  } catch (error) {
+    spinner.fail(`Failed to uninstall "${skillSlug}"`);
+    logger.error(error.message);
+  }
+}

package/src/commands/search.js

@@ -0,0 +1,37 @@
+import ora from 'ora';
+import { api } from '../services/api.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Searches the registry for skills matching the query.
+ */
+export async function searchSkills(query) {
+  const spinner = ora(`Searching registry for "${query}"...`).start();
+  try {
+    const response = await api.get(`/api/skills`, { params: { q: query } });
+    const skills = response.data;
+
+    if (skills.length === 0) {
+      spinner.info(`No skills found matching "${query}"`);
+      return;
+    }
+
+    spinner.succeed(`Found ${skills.length} matching skill(s):\n`);
+
+    skills.forEach((skill) => {
+      console.log(` ${logger.bold(skill.name)} (${logger.dim(skill.slug)})`);
+      console.log(`   ${logger.dim('Version:')} v${skill.currentVersion || '1.0.0'}  |  ${logger.dim('Publisher:')} @${skill.ownerUsername || 'unknown'}`);
+      if (skill.description) {
+        console.log(`   ${skill.description}`);
+      }
+      console.log();
+    });
+  } catch (error) {
+    spinner.fail(`Search query failed for "${query}"`);
+    if (error.response) {
+      logger.error(`Registry error: ${error.response.data?.error || error.response.statusText}`);
+    } else {
+      logger.error(`Connection error: ${error.message}`);
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { installSkill } from './commands/install.js';
+import { searchSkills } from './commands/search.js';
+import { listInstalledSkills } from './commands/ls.js';
+import { removeSkill } from './commands/remove.js';
+import { publishSkill } from './commands/publish.js';
+
+const program = new Command();
+
+program
+  .name('kresh')
+  .description('Install and manage intelligence skills')
+  .version('0.1.0');
+
+program
+  .command('install <skill>')
+  .alias('i')
+  .description('Install a skill locally')
+  .action(async (skill) => {
+    await installSkill(skill);
+  });
+
+program
+  .command('search <query>')
+  .alias('s')
+  .description('Search skills in the registry')
+  .action(async (query) => {
+    await searchSkills(query);
+  });
+
+program
+  .command('ls')
+  .alias('list')
+  .description('List installed skills')
+  .action(async () => {
+    await listInstalledSkills();
+  });
+
+program
+  .command('remove <skill>')
+  .alias('rm')
+  .description('Remove an installed skill')
+  .action(async (skill) => {
+    await removeSkill(skill);
+  });
+
+program
+  .command('publish')
+  .description('Publish a skill')
+  .action(async () => {
+    await publishSkill();
+  });
+
+program.parse();

package/src/services/api.js

@@ -0,0 +1,12 @@
+import axios from 'axios';
+
+const baseURL = process.env.KRESH_API_URL || 'http://localhost:3000';
+
+export const api = axios.create({
+  baseURL,
+  timeout: 10000,
+  headers: {
+    'Accept': 'application/json',
+    'Content-Type': 'application/json'
+  }
+});

package/src/services/filesystem.js

@@ -0,0 +1,83 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Writes the SKILL.md and metadata.json files directly in a folder named after the skill's slug inside the skills folder.
+ */
+export async function writeLocalSkill(slug, skillContent, metadata) {
+  try {
+    // Sanitize folder name, use slug
+    const folderName = slug || metadata.slug;
+    const targetDir = path.join(process.cwd(), 'skills', folderName);
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.writeFile(path.join(targetDir, 'SKILL.md'), skillContent, 'utf8');
+    await fs.writeFile(path.join(targetDir, 'metadata.json'), JSON.stringify(metadata, null, 2), 'utf8');
+    return targetDir;
+  } catch (error) {
+    console.error('Failed to write skill files in the skills directory:', error);
+    throw new Error(`Local file system write failed: ${error.message}`);
+  }
+}
+
+/**
+ * Reads the local metadata.json of a specific skill if it exists.
+ */
+export async function readLocalSkillMetadata(slug) {
+  try {
+    const metadataPath = path.join(process.cwd(), 'skills', slug, 'metadata.json');
+    const data = await fs.readFile(metadataPath, 'utf8');
+    return JSON.parse(data);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Removes the skill directory.
+ */
+export async function removeLocalSkill(slug) {
+  try {
+    const targetDir = path.join(process.cwd(), 'skills', slug);
+    await fs.rm(targetDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    console.error('Failed to remove skill files from the skills directory:', error);
+    throw new Error(`Local file system removal failed: ${error.message}`);
+  }
+}
+
+/**
+ * Lists all installed skills by inspecting the skills directory.
+ */
+export async function listLocalSkills() {
+  try {
+    const skillsDir = path.join(process.cwd(), 'skills');
+    let entries = [];
+    try {
+      entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    } catch (e) {
+      if (e.code === 'ENOENT') return [];
+      throw e;
+    }
+
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const metadata = await readLocalSkillMetadata(entry.name);
+        if (metadata) {
+          skills.push({
+            slug: metadata.slug || entry.name,
+            installed: true,
+            version: metadata.version || metadata.currentVersion || 'unknown',
+            name: metadata.name || 'unknown',
+            description: metadata.description || ''
+          });
+        }
+      }
+    }
+    return skills;
+  } catch (error) {
+    console.error('Failed to list local skills:', error);
+    return [];
+  }
+}

package/src/utils/logger.js

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg) => console.log(chalk.green('✔'), msg),
+  warning: (msg) => console.log(chalk.yellow('⚠'), msg),
+  error: (msg) => console.log(chalk.red('✖'), msg),
+  bold: (msg) => chalk.bold(msg),
+  dim: (msg) => chalk.dim(msg)
+};