@hasna/skills 0.0.2

package/skills/skill-managemcp/scripts/migrate.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+
+import { sql, testConnection, closeConnection } from '../src/db';
+
+console.log('Running database migrations...');
+
+const connected = await testConnection();
+if (!connected) {
+  console.error('Failed to connect to database');
+  process.exit(1);
+}
+
+console.log('Database connected\n');
+
+try {
+  console.log('Creating tables...');
+  await sql`
+    CREATE TABLE IF NOT EXISTS items (
+      id SERIAL PRIMARY KEY,
+      name VARCHAR(255) NOT NULL,
+      description TEXT,
+      metadata JSONB DEFAULT '{}',
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+
+  console.log('Creating indexes...');
+  await sql`CREATE INDEX IF NOT EXISTS idx_items_name ON items(name)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_items_created_at ON items(created_at DESC)`;
+
+  console.log('Creating triggers...');
+  await sql`
+    CREATE OR REPLACE FUNCTION update_updated_at_column()
+    RETURNS TRIGGER AS $$
+    BEGIN
+      NEW.updated_at = CURRENT_TIMESTAMP;
+      RETURN NEW;
+    END;
+    $$ language 'plpgsql'
+  `;
+
+  await sql`DROP TRIGGER IF EXISTS update_items_updated_at ON items`;
+  await sql`
+    CREATE TRIGGER update_items_updated_at
+    BEFORE UPDATE ON items
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column()
+  `;
+
+  console.log('\nMigrations completed successfully');
+} catch (error) {
+  console.error('\nMigration failed:', error);
+  process.exit(1);
+} finally {
+  await closeConnection();
+}

package/skills/skill-managemcp/scripts/seed.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+
+import { sql, testConnection, closeConnection } from '../src/db';
+
+console.log('Seeding database...');
+
+const connected = await testConnection();
+if (!connected) {
+  console.error('Failed to connect to database');
+  process.exit(1);
+}
+
+console.log('Database connected\n');
+
+try {
+  const [{ count }] = await sql`SELECT COUNT(*) as count FROM items`;
+
+  if (parseInt(count) > 0) {
+    console.log(`Database already has ${count} items - skipping seed`);
+    console.log('To re-seed, truncate the items table first\n');
+    process.exit(0);
+  }
+
+  console.log('Inserting seed data...');
+
+  const seedItems = [
+    {
+      name: 'Example Item 1',
+      description: 'This is the first example item',
+      metadata: { category: 'example', priority: 'high' },
+    },
+    {
+      name: 'Example Item 2',
+      description: 'This is the second example item',
+      metadata: { category: 'sample', priority: 'medium' },
+    },
+    {
+      name: 'Example Item 3',
+      description: 'This is the third example item',
+      metadata: { category: 'demo', priority: 'low' },
+    },
+  ];
+
+  for (const item of seedItems) {
+    await sql`
+      INSERT INTO items (name, description, metadata)
+      VALUES (${item.name}, ${item.description}, ${JSON.stringify(item.metadata)})
+    `;
+    console.log(`  Created: ${item.name}`);
+  }
+
+  console.log(`\nSeeded ${seedItems.length} items successfully`);
+} catch (error) {
+  console.error('\nSeeding failed:', error);
+  process.exit(1);
+} finally {
+  await closeConnection();
+}

package/skills/skill-managemcp/src/db/index.ts

@@ -0,0 +1,37 @@
+import postgres from 'postgres';
+
+function getConnectionString(): string {
+  if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
+
+  const {
+    DB_USER = 'postgres',
+    DB_PASSWORD = 'postgres',
+    DB_HOST = 'localhost',
+    DB_PORT = '5432',
+    DB_NAME = 'app_db',
+  } = process.env;
+
+  return `postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}`;
+}
+
+export const sql = postgres(getConnectionString(), {
+  max: 10,
+  idle_timeout: 20,
+  connect_timeout: 10,
+});
+
+export async function testConnection(): Promise<boolean> {
+  try {
+    await sql`SELECT 1`;
+    return true;
+  } catch (error) {
+    console.error('Database connection failed:', error instanceof Error ? error.message : 'Unknown error');
+    return false;
+  }
+}
+
+export async function closeConnection(): Promise<void> {
+  await sql.end({ timeout: 5 });
+}
+
+export type Sql = typeof sql;

package/skills/skill-managemcp/src/lib/api-client.ts

@@ -0,0 +1,108 @@
+import { getApiKey, getApiUrl } from './config';
+
+export interface ApiItem {
+  id: string;
+  name: string;
+  description?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface ListOptions {
+  filter?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface CreateItemData {
+  name: string;
+  description?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public response?: unknown
+  ) {
+    super(message);
+    this.name = 'ApiError';
+  }
+}
+
+async function makeRequest<T>(
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<T> {
+  const apiUrl = await getApiUrl();
+  const apiKey = await getApiKey();
+
+  if (!apiUrl) {
+    throw new ApiError('API URL not configured. Run: {{name}} config --set-api-url <url>');
+  }
+
+  if (!apiKey) {
+    throw new ApiError('API key not configured. Run: {{name}} config --set-api-key <key>');
+  }
+
+  const url = `${apiUrl}${endpoint}`;
+  const headers = {
+    'Authorization': `Bearer ${apiKey}`,
+    'Content-Type': 'application/json',
+    ...options.headers,
+  };
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => null);
+      const message = errorData?.error || response.statusText;
+      throw new ApiError(`API request failed: ${message}`, response.status, errorData);
+    }
+
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+export async function listItems(options: ListOptions = {}): Promise<ApiItem[]> {
+  const params = new URLSearchParams();
+  if (options.filter) params.set('filter', options.filter);
+  if (options.limit) params.set('limit', options.limit.toString());
+  if (options.offset) params.set('offset', options.offset.toString());
+
+  const query = params.toString();
+  const endpoint = `/items${query ? `?${query}` : ''}`;
+
+  const response = await makeRequest<{ items: ApiItem[] }>(endpoint);
+  return response.items;
+}
+
+export async function getItem(id: string): Promise<ApiItem> {
+  return await makeRequest<ApiItem>(`/items/${id}`);
+}
+
+export async function searchItems(query: string, limit = 10): Promise<ApiItem[]> {
+  const params = new URLSearchParams({
+    q: query,
+    limit: limit.toString(),
+  });
+
+  const response = await makeRequest<{ items: ApiItem[] }>(`/items/search?${params}`);
+  return response.items;
+}
+
+export async function createItem(data: CreateItemData): Promise<ApiItem> {
+  return await makeRequest<ApiItem>('/items', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  });
+}

package/skills/skill-managemcp/src/lib/config.ts

@@ -0,0 +1,34 @@
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export interface Config {
+  apiUrl?: string;
+  apiKey?: string;
+}
+
+export const CONFIG_FILE = join(homedir(), '.{{name}}.json');
+
+export async function loadConfig(): Promise<Config> {
+  try {
+    const data = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
+    throw error;
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export async function getApiKey(): Promise<string | undefined> {
+  const config = await loadConfig();
+  return config.apiKey || process.env.API_KEY;
+}
+
+export async function getApiUrl(): Promise<string | undefined> {
+  const config = await loadConfig();
+  return config.apiUrl || process.env.API_URL;
+}

package/skills/skill-managemcp/src/lib/installer.ts

@@ -0,0 +1,140 @@
+import { readFile, writeFile, readdir, unlink, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getItem } from './api-client';
+
+export type Target = 'claude' | 'codex';
+export type ConflictStrategy = 'skip' | 'overwrite';
+
+export interface InstallResult {
+  success: boolean;
+  message: string;
+  itemId: string;
+}
+
+export interface InstalledItem {
+  id: string;
+  name: string;
+  target: Target;
+  installedAt: string;
+}
+
+const CLAUDE_DIR = join(homedir(), '.claude', 'skills');
+const CODEX_DIR = join(homedir(), '.codex', 'skills');
+
+function getTargetDir(target: Target): string {
+  return target === 'claude' ? CLAUDE_DIR : CODEX_DIR;
+}
+
+async function ensureDir(dir: string): Promise<void> {
+  await mkdir(dir, { recursive: true });
+}
+
+async function writeItemFile(
+  target: Target,
+  itemId: string,
+  content: string,
+  strategy: ConflictStrategy
+): Promise<boolean> {
+  const dir = getTargetDir(target);
+  await ensureDir(dir);
+
+  const filePath = join(dir, `${itemId}.json`);
+
+  try {
+    await readFile(filePath);
+    if (strategy === 'skip') return false;
+  } catch {
+    // File doesn't exist, proceed
+  }
+
+  await writeFile(filePath, content, 'utf-8');
+  return true;
+}
+
+async function installToTarget(
+  target: Target,
+  itemId: string,
+  strategy: ConflictStrategy = 'skip'
+): Promise<InstallResult> {
+  try {
+    const item = await getItem(itemId);
+    const content = JSON.stringify(item, null, 2);
+    const written = await writeItemFile(target, itemId, content, strategy);
+
+    const targetName = target.charAt(0).toUpperCase() + target.slice(1);
+    return {
+      success: true,
+      message: written
+        ? `Installed to ${targetName}: ${item.name}`
+        : `Skipped (already exists): ${item.name}`,
+      itemId,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to install to ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      itemId,
+    };
+  }
+}
+
+export async function install(
+  itemId: string,
+  target: Target | 'both' = 'both',
+  strategy: ConflictStrategy = 'skip'
+): Promise<InstallResult> {
+  if (target === 'both') {
+    const claudeResult = await installToTarget('claude', itemId, strategy);
+    const codexResult = await installToTarget('codex', itemId, strategy);
+
+    return {
+      success: claudeResult.success && codexResult.success,
+      message: `${claudeResult.message}\n${codexResult.message}`,
+      itemId,
+    };
+  }
+
+  return await installToTarget(target, itemId, strategy);
+}
+
+export async function clearTarget(target?: Target | 'both'): Promise<void> {
+  const targets: Target[] = target === 'both' || !target ? ['claude', 'codex'] : [target];
+
+  for (const t of targets) {
+    const dir = getTargetDir(t);
+    try {
+      const files = await readdir(dir);
+      const jsonFiles = files.filter((f) => f.endsWith('.json')).map((f) => unlink(join(dir, f)));
+      await Promise.all(jsonFiles);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+export async function listInstalled(target?: Target | 'both'): Promise<InstalledItem[]> {
+  const targets: Target[] = target === 'both' || !target ? ['claude', 'codex'] : [target];
+  const items: InstalledItem[] = [];
+
+  for (const t of targets) {
+    const dir = getTargetDir(t);
+    try {
+      const files = await readdir(dir);
+      for (const file of files.filter((f) => f.endsWith('.json'))) {
+        const content = await readFile(join(dir, file), 'utf-8');
+        const item = JSON.parse(content);
+        items.push({
+          id: item.id,
+          name: item.name,
+          target: t,
+          installedAt: file,
+        });
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+  }
+
+  return items;
+}

package/skills/skill-managemcp/src/lib/service-dir.ts

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const SERVICE_NAME = "service-{{name}}";
+const SERVICE_DIR_NAME = `.${SERVICE_NAME}`;
+
+export function getServiceDir(): string {
+  return join(homedir(), SERVICE_DIR_NAME);
+}
+
+export function getLogFilePath(): string {
+  return join(getServiceDir(), `${SERVICE_NAME}.log`);
+}
+
+export function getReadmePath(): string {
+  return join(getServiceDir(), "README.md");
+}
+
+export function isServiceDirInstalled(): boolean {
+  return existsSync(getServiceDir());
+}
+
+export function ensureServiceDir(): void {
+  if (!isServiceDirInstalled()) {
+    initServiceDir();
+  }
+}
+
+export function initServiceDir(force = false): { success: boolean; path: string; message: string } {
+  const serviceDir = getServiceDir();
+
+  if (existsSync(serviceDir) && !force) {
+    return {
+      success: false,
+      path: serviceDir,
+      message: "Already installed. Use --force to reinstall.",
+    };
+  }
+
+  mkdirSync(serviceDir, { recursive: true });
+
+  const readmeContent = generateReadme();
+  writeFileSync(getReadmePath(), readmeContent);
+
+  const logHeader = `# ${SERVICE_NAME} log file
+# Created: ${new Date().toISOString()}
+# This file contains activity history and logs.
+# -------------------------------------------------------
+
+`;
+  writeFileSync(getLogFilePath(), logHeader);
+
+  return {
+    success: true,
+    path: serviceDir,
+    message: `Installed at ${serviceDir}`,
+  };
+}
+
+function generateReadme(): string {
+  return `# .${SERVICE_NAME}
+
+This directory contains local configuration and logs for \`${SERVICE_NAME}\`.
+
+## Files
+
+| Path | Description |
+|------|-------------|
+| \`${SERVICE_NAME}.log\` | Activity log |
+| \`README.md\` | This file |
+
+## What is ${SERVICE_NAME}?
+
+\`${SERVICE_NAME}\` is a {{description}}.
+
+## Log File
+
+The \`${SERVICE_NAME}.log\` file contains:
+- Activity logs
+- Error logs
+- API activity
+
+## More Information
+
+For full documentation, run:
+
+\`\`\`bash
+${SERVICE_NAME} --help
+\`\`\`
+`;
+}
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export function logToFile(message: string, level: LogLevel = "info"): void {
+  ensureServiceDir();
+
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+
+  try {
+    appendFileSync(getLogFilePath(), logLine);
+  } catch {
+    // Silently fail
+  }
+}
+
+export function logInfo(message: string): void {
+  logToFile(message, "info");
+}
+
+export function logError(message: string): void {
+  logToFile(message, "error");
+}
+
+export function logWarn(message: string): void {
+  logToFile(message, "warn");
+}

package/skills/skill-managemcp/src/server/index.ts

@@ -0,0 +1,108 @@
+import { sql, testConnection, closeConnection } from '../db';
+
+const PORT = parseInt(process.env.PORT || '3000');
+const PATH_PREFIX = '/{{name}}';
+const API_KEY = process.env.API_KEY || '';
+
+// API Key validation
+function validateApiKey(req: Request): boolean {
+  if (!API_KEY) return true; // No key configured = open access
+
+  const authHeader = req.headers.get('Authorization');
+  if (!authHeader?.startsWith('Bearer ')) return false;
+
+  return authHeader.slice(7) === API_KEY;
+}
+
+const connected = await testConnection();
+if (!connected) {
+  console.error('Failed to connect to database');
+  process.exit(1);
+}
+
+console.log('Database connection successful');
+
+async function handleRequest(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  let { pathname } = url;
+  const { searchParams } = url;
+  const method = req.method;
+
+  // Strip path prefix if present (for ALB routing)
+  if (pathname.startsWith(PATH_PREFIX)) {
+    pathname = pathname.slice(PATH_PREFIX.length) || '/';
+  }
+
+  try {
+    // Health check (no auth required)
+    if (pathname === '/health' && method === 'GET') {
+      return Response.json({
+        status: 'ok',
+        service: 'service-{{name}}',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    // All routes below require authentication
+    if (!validateApiKey(req)) {
+      return Response.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    // List items
+    if (pathname === '/api/items' && method === 'GET') {
+      const limit = Math.min(parseInt(searchParams.get('limit') || '10'), 100);
+      const offset = Math.max(parseInt(searchParams.get('offset') || '0'), 0);
+
+      const items = await sql`
+        SELECT * FROM items
+        ORDER BY created_at DESC
+        LIMIT ${limit}
+        OFFSET ${offset}
+      `;
+      return Response.json({ items });
+    }
+
+    // Create item
+    if (pathname === '/api/items' && method === 'POST') {
+      const body = await req.json();
+
+      if (!body.name) {
+        return Response.json({ error: 'Name is required' }, { status: 400 });
+      }
+
+      const [item] = await sql`
+        INSERT INTO items (name, description, metadata)
+        VALUES (${body.name}, ${body.description || null}, ${JSON.stringify(body.metadata || {})})
+        RETURNING *
+      `;
+      return Response.json(item, { status: 201 });
+    }
+
+    return Response.json({ error: 'Not found' }, { status: 404 });
+  } catch (error) {
+    console.error('Request error:', error);
+    return Response.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
+
+const server = Bun.serve({
+  port: PORT,
+  fetch: handleRequest,
+});
+
+console.log(`Server running at http://localhost:${PORT}`);
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\nShutting down gracefully...');
+  server.stop();
+  await closeConnection();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\nShutting down gracefully...');
+  server.stop();
+  await closeConnection();
+  process.exit(0);
+});

package/skills/skill-managemcp/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["bun"]
+  },
+  "include": ["src/**/*", "bin/**/*", "scripts/**/*"],
+  "exclude": ["node_modules"]
+}

package/skills/skill-manageskill/.env.example

@@ -0,0 +1,16 @@
+# Database (individual connection params)
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME={{name}}_db
+DB_USER=postgres
+DB_PASSWORD=postgres
+
+# Or use a full connection string
+# DATABASE_URL=postgres://user:password@host:port/dbname
+
+# Server
+PORT=3000
+
+# API (for CLI usage)
+API_URL=https://api.example.com
+API_KEY=your-api-key-here