@hasna/skills 0.0.2

package/skills/skill-businessactivity/scripts/publish.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+/**
+ * Auto-versioning publish script
+ * - Fetches current npm version
+ * - Auto-bumps patch version if local version <= npm version
+ * - Creates git tag
+ * - Publishes to npm
+ */
+
+import { $ } from 'bun';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+type BumpType = 'patch' | 'minor' | 'major';
+
+function parseVersion(version: string): { major: number; minor: number; patch: number } {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major, minor, patch };
+}
+
+function bumpVersion(version: string, type: BumpType = 'patch'): string {
+  const { major, minor, patch } = parseVersion(version);
+
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+    default:
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+function compareVersions(a: string, b: string): number {
+  const vA = parseVersion(a);
+  const vB = parseVersion(b);
+
+  if (vA.major !== vB.major) return vA.major - vB.major;
+  if (vA.minor !== vB.minor) return vA.minor - vB.minor;
+  return vA.patch - vB.patch;
+}
+
+async function getNpmVersion(packageName: string): Promise<string | null> {
+  try {
+    const result = await $`npm view ${packageName} version 2>/dev/null`.text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function hasUncommittedChanges(): Promise<boolean> {
+  try {
+    const result = await $`git status --porcelain`.text();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function isGitRepo(): Promise<boolean> {
+  try {
+    await $`git rev-parse --git-dir 2>/dev/null`.text();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createGitTag(version: string, packageName: string): Promise<boolean> {
+  const tagName = `${packageName}@${version}`;
+
+  try {
+    // Check if tag already exists
+    const existingTags = await $`git tag -l ${tagName}`.text();
+    if (existingTags.trim()) {
+      console.log(`⚠️  Tag ${tagName} already exists, skipping tag creation`);
+      return true;
+    }
+
+    await $`git tag -a ${tagName} -m "Release ${tagName}"`;
+    console.log(`✅ Created git tag: ${tagName}`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to create git tag: ${error}`);
+    return false;
+  }
+}
+
+async function commitVersionBump(version: string, packageName: string): Promise<boolean> {
+  try {
+    await $`git add package.json`;
+    await $`git commit -m "chore(${packageName}): bump version to ${version}"`;
+    console.log(`✅ Committed version bump`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to commit: ${error}`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const bumpType = (args.find(a => ['patch', 'minor', 'major'].includes(a)) || 'patch') as BumpType;
+  const skipGit = args.includes('--skip-git');
+  const dryRun = args.includes('--dry-run');
+  const force = args.includes('--force');
+
+  // Read package.json
+  const pkgPath = join(process.cwd(), 'package.json');
+  const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+  console.log(`\n📦 Publishing ${pkg.name}\n`);
+
+  // Get current npm version
+  const npmVersion = await getNpmVersion(pkg.name);
+  let newVersion = pkg.version;
+
+  if (npmVersion) {
+    console.log(`📌 Current npm version: ${npmVersion}`);
+    console.log(`📌 Local version: ${pkg.version}`);
+
+    // Check if we need to bump
+    if (compareVersions(pkg.version, npmVersion) <= 0) {
+      newVersion = bumpVersion(npmVersion, bumpType);
+      console.log(`🔄 Auto-bumping to: ${newVersion}`);
+    } else {
+      console.log(`✅ Local version is ahead, using: ${pkg.version}`);
+    }
+  } else {
+    console.log(`📌 Package not yet published to npm`);
+    console.log(`📌 Using local version: ${pkg.version}`);
+  }
+
+  // Update package.json if version changed
+  if (newVersion !== pkg.version) {
+    if (dryRun) {
+      console.log(`\n🧪 DRY RUN: Would update version to ${newVersion}`);
+    } else {
+      pkg.version = newVersion;
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+      console.log(`✅ Updated package.json to version ${newVersion}`);
+    }
+  }
+
+  // Git operations
+  const isGit = await isGitRepo();
+
+  if (isGit && !skipGit) {
+    const hasChanges = await hasUncommittedChanges();
+
+    if (hasChanges && newVersion !== pkg.version) {
+      if (dryRun) {
+        console.log(`🧪 DRY RUN: Would commit version bump`);
+      } else {
+        await commitVersionBump(newVersion, pkg.name.replace('@hasnaxyz/', ''));
+      }
+    }
+
+    if (dryRun) {
+      console.log(`🧪 DRY RUN: Would create tag ${pkg.name}@${newVersion}`);
+    } else {
+      await createGitTag(newVersion, pkg.name.replace('@hasnaxyz/', ''));
+    }
+  }
+
+  // Build
+  console.log(`\n🔨 Building...`);
+  if (!dryRun) {
+    await $`bun run build`;
+  } else {
+    console.log(`🧪 DRY RUN: Would run build`);
+  }
+
+  // Publish
+  console.log(`\n🚀 Publishing to npm...`);
+  if (dryRun) {
+    console.log(`🧪 DRY RUN: Would publish ${pkg.name}@${newVersion}`);
+  } else {
+    try {
+      await $`npm publish`;
+      console.log(`\n✅ Successfully published ${pkg.name}@${newVersion}`);
+    } catch (error) {
+      console.error(`\n❌ Publish failed: ${error}`);
+      process.exit(1);
+    }
+  }
+
+  // Push tags
+  if (isGit && !skipGit && !dryRun) {
+    console.log(`\n📤 Pushing tags to remote...`);
+    try {
+      await $`git push --tags`;
+      console.log(`✅ Pushed tags to remote`);
+    } catch {
+      console.log(`⚠️  Could not push tags (no remote or not configured)`);
+    }
+  }
+
+  console.log(`\n✨ Done!\n`);
+}
+
+main().catch(console.error);

package/skills/skill-businessactivity/src/commands/activity.ts

@@ -0,0 +1,211 @@
+import { Command } from 'commander';
+import { requireProfile } from '../lib/config';
+import { getActivitiesPath, getFunctionsPath } from '../lib/paths';
+import { readArray, appendToArray, updateInArray, removeFromArray, findById, generateId, timestamp } from '../lib/storage';
+import { printTable, success, error, info, formatDate } from '../lib/output';
+import type { Activity, Function, ActivityStatus } from '../types';
+import { ACTIVITY_STATUSES } from '../types';
+
+export function registerActivityCommands(program: Command): void {
+  const activityCmd = program
+    .command('activity')
+    .description('Manage activities');
+
+  // activity:create
+  activityCmd
+    .command('create')
+    .description('Create a new activity under a function')
+    .requiredOption('-n, --name <name>', 'Activity name')
+    .requiredOption('-f, --function <functionId>', 'Parent function ID')
+    .option('-d, --description <description>', 'Activity description')
+    .option('-s, --status <status>', 'Initial status (pending, in_progress, completed, cancelled)', 'pending')
+    .option('-m, --metadata <json>', 'Metadata as JSON')
+    .action(async (options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const activitiesPath = getActivitiesPath(profileName);
+        const functionsPath = getFunctionsPath(profileName);
+
+        // Verify function exists
+        const func = await findById<Function>(functionsPath, options.function);
+        if (!func) {
+          error(`Function with ID "${options.function}" not found`);
+          process.exit(1);
+        }
+
+        if (!ACTIVITY_STATUSES.includes(options.status)) {
+          error(`Invalid status. Must be one of: ${ACTIVITY_STATUSES.join(', ')}`);
+          process.exit(1);
+        }
+
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+
+        const activity: Activity = {
+          id: generateId('act'),
+          functionId: options.function,
+          name: options.name,
+          description: options.description,
+          status: options.status as ActivityStatus,
+          metadata,
+          createdAt: timestamp(),
+          updatedAt: timestamp(),
+        };
+
+        await appendToArray(activitiesPath, activity);
+        success(`Activity "${activity.name}" created with ID: ${activity.id}`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to create activity');
+        process.exit(1);
+      }
+    });
+
+  // activity:list
+  activityCmd
+    .command('list')
+    .description('List activities')
+    .option('-f, --function <functionId>', 'Filter by function ID')
+    .option('-s, --status <status>', 'Filter by status')
+    .action(async (options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const activitiesPath = getActivitiesPath(profileName);
+        const functionsPath = getFunctionsPath(profileName);
+
+        let activities = await readArray<Activity>(activitiesPath);
+        const functions = await readArray<Function>(functionsPath);
+        const functionMap = new Map(functions.map(f => [f.id, f.name]));
+
+        if (options.function) {
+          activities = activities.filter(a => a.functionId === options.function);
+        }
+        if (options.status) {
+          activities = activities.filter(a => a.status === options.status);
+        }
+
+        if (activities.length === 0) {
+          info('No activities found');
+          return;
+        }
+
+        const rows = activities.map(a => [
+          a.id.slice(0, 12) + '...',
+          a.name,
+          functionMap.get(a.functionId) || '-',
+          a.status,
+          a.description || '-',
+        ]);
+
+        printTable(['ID', 'Name', 'Function', 'Status', 'Description'], rows);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to list activities');
+        process.exit(1);
+      }
+    });
+
+  // activity:get
+  activityCmd
+    .command('get <id>')
+    .description('Get activity details')
+    .action(async (id) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const activitiesPath = getActivitiesPath(profileName);
+        const functionsPath = getFunctionsPath(profileName);
+
+        const activity = await findById<Activity>(activitiesPath, id);
+
+        if (!activity) {
+          error(`Activity with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        const func = await findById<Function>(functionsPath, activity.functionId);
+
+        console.log(`\nActivity: ${activity.name}`);
+        console.log(`ID: ${activity.id}`);
+        console.log(`Function: ${func?.name || '-'}`);
+        console.log(`Status: ${activity.status}`);
+        console.log(`Description: ${activity.description || '-'}`);
+        if (activity.metadata) {
+          console.log(`Metadata: ${JSON.stringify(activity.metadata, null, 2)}`);
+        }
+        console.log(`Created: ${formatDate(activity.createdAt)}`);
+        console.log(`Updated: ${formatDate(activity.updatedAt)}`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get activity');
+        process.exit(1);
+      }
+    });
+
+  // activity:update
+  activityCmd
+    .command('update <id>')
+    .description('Update an activity')
+    .option('-n, --name <name>', 'New name')
+    .option('-d, --description <description>', 'New description')
+    .option('-s, --status <status>', 'New status')
+    .option('-m, --metadata <json>', 'New metadata as JSON')
+    .action(async (id, options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const activitiesPath = getActivitiesPath(profileName);
+
+        const updates: Partial<Activity> = {};
+        if (options.name) updates.name = options.name;
+        if (options.description) updates.description = options.description;
+        if (options.status) {
+          if (!ACTIVITY_STATUSES.includes(options.status)) {
+            error(`Invalid status. Must be one of: ${ACTIVITY_STATUSES.join(', ')}`);
+            process.exit(1);
+          }
+          updates.status = options.status;
+        }
+        if (options.metadata) {
+          updates.metadata = JSON.parse(options.metadata);
+        }
+
+        const activity = await updateInArray<Activity>(activitiesPath, id, updates);
+
+        if (!activity) {
+          error(`Activity with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        success(`Activity "${activity.name}" updated`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to update activity');
+        process.exit(1);
+      }
+    });
+
+  // activity:delete
+  activityCmd
+    .command('delete <id>')
+    .description('Delete an activity')
+    .option('-f, --force', 'Skip confirmation')
+    .action(async (id, options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const activitiesPath = getActivitiesPath(profileName);
+
+        const activity = await findById<Activity>(activitiesPath, id);
+
+        if (!activity) {
+          error(`Activity with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          info(`This will delete activity "${activity.name}".`);
+          info('Use --force to confirm deletion.');
+          return;
+        }
+
+        await removeFromArray<Activity>(activitiesPath, id);
+        success(`Activity "${activity.name}" deleted`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to delete activity');
+        process.exit(1);
+      }
+    });
+}

package/skills/skill-businessactivity/src/commands/function.ts

@@ -0,0 +1,227 @@
+import { Command } from 'commander';
+import { requireProfile } from '../lib/config';
+import { getFunctionsPath } from '../lib/paths';
+import { readArray, appendToArray, updateInArray, removeFromArray, findById, generateId, timestamp } from '../lib/storage';
+import { printTable, success, error, info, formatDate, buildTree, printTree } from '../lib/output';
+import type { Function } from '../types';
+
+export function registerFunctionCommands(program: Command): void {
+  const functionCmd = program
+    .command('function')
+    .description('Manage business functions');
+
+  // function:create
+  functionCmd
+    .command('create')
+    .description('Create a new business function')
+    .requiredOption('-n, --name <name>', 'Function name')
+    .option('-d, --description <description>', 'Function description')
+    .option('-p, --parent <parentId>', 'Parent function ID (for hierarchy)')
+    .option('-m, --metadata <json>', 'Metadata as JSON')
+    .action(async (options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const path = getFunctionsPath(profileName);
+
+        // Verify parent exists if provided
+        if (options.parent) {
+          const parent = await findById<Function>(path, options.parent);
+          if (!parent) {
+            error(`Parent function with ID "${options.parent}" not found`);
+            process.exit(1);
+          }
+        }
+
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+
+        const func: Function = {
+          id: generateId('func'),
+          name: options.name,
+          description: options.description,
+          parentId: options.parent,
+          metadata,
+          createdAt: timestamp(),
+          updatedAt: timestamp(),
+        };
+
+        await appendToArray(path, func);
+        success(`Function "${func.name}" created with ID: ${func.id}`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to create function');
+        process.exit(1);
+      }
+    });
+
+  // function:list
+  functionCmd
+    .command('list')
+    .description('List all functions')
+    .option('--flat', 'Show as flat list instead of tree')
+    .action(async (options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const path = getFunctionsPath(profileName);
+
+        const functions = await readArray<Function>(path);
+
+        if (functions.length === 0) {
+          info('No functions found');
+          return;
+        }
+
+        if (options.flat) {
+          const rows = functions.map(f => [
+            f.id.slice(0, 12) + '...',
+            f.name,
+            f.parentId ? f.parentId.slice(0, 12) + '...' : '-',
+            f.description || '-',
+          ]);
+
+          printTable(['ID', 'Name', 'Parent', 'Description'], rows);
+        } else {
+          console.log('\nBusiness Functions:\n');
+          const tree = buildTree(functions);
+          printTree(tree);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to list functions');
+        process.exit(1);
+      }
+    });
+
+  // function:get
+  functionCmd
+    .command('get <id>')
+    .description('Get function details')
+    .action(async (id) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const path = getFunctionsPath(profileName);
+
+        const func = await findById<Function>(path, id);
+
+        if (!func) {
+          error(`Function with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        // Get parent name if exists
+        let parentName = '-';
+        if (func.parentId) {
+          const parent = await findById<Function>(path, func.parentId);
+          if (parent) parentName = parent.name;
+        }
+
+        // Get children
+        const allFunctions = await readArray<Function>(path);
+        const children = allFunctions.filter(f => f.parentId === id);
+
+        console.log(`\nFunction: ${func.name}`);
+        console.log(`ID: ${func.id}`);
+        console.log(`Description: ${func.description || '-'}`);
+        console.log(`Parent: ${parentName}`);
+        if (func.metadata) {
+          console.log(`Metadata: ${JSON.stringify(func.metadata, null, 2)}`);
+        }
+        console.log(`Created: ${formatDate(func.createdAt)}`);
+        console.log(`Updated: ${formatDate(func.updatedAt)}`);
+
+        if (children.length > 0) {
+          console.log(`\nChild Functions (${children.length}):`);
+          children.forEach(c => {
+            console.log(`  - ${c.name} (${c.id.slice(0, 12)}...)`);
+          });
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get function');
+        process.exit(1);
+      }
+    });
+
+  // function:update
+  functionCmd
+    .command('update <id>')
+    .description('Update a function')
+    .option('-n, --name <name>', 'New name')
+    .option('-d, --description <description>', 'New description')
+    .option('-p, --parent <parentId>', 'New parent function ID')
+    .option('--no-parent', 'Remove parent (make root level)')
+    .option('-m, --metadata <json>', 'New metadata as JSON')
+    .action(async (id, options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const path = getFunctionsPath(profileName);
+
+        const updates: Partial<Function> = {};
+        if (options.name) updates.name = options.name;
+        if (options.description) updates.description = options.description;
+        if (options.parent === false) {
+          updates.parentId = undefined;
+        } else if (options.parent) {
+          if (options.parent === id) {
+            error('A function cannot be its own parent');
+            process.exit(1);
+          }
+          const parent = await findById<Function>(path, options.parent);
+          if (!parent) {
+            error(`Parent function with ID "${options.parent}" not found`);
+            process.exit(1);
+          }
+          updates.parentId = options.parent;
+        }
+        if (options.metadata) {
+          updates.metadata = JSON.parse(options.metadata);
+        }
+
+        const func = await updateInArray<Function>(path, id, updates);
+
+        if (!func) {
+          error(`Function with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        success(`Function "${func.name}" updated`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to update function');
+        process.exit(1);
+      }
+    });
+
+  // function:delete
+  functionCmd
+    .command('delete <id>')
+    .description('Delete a function')
+    .option('-f, --force', 'Skip confirmation')
+    .action(async (id, options) => {
+      try {
+        const { name: profileName } = await requireProfile();
+        const path = getFunctionsPath(profileName);
+
+        const func = await findById<Function>(path, id);
+
+        if (!func) {
+          error(`Function with ID "${id}" not found`);
+          process.exit(1);
+        }
+
+        // Check for children
+        const allFunctions = await readArray<Function>(path);
+        const children = allFunctions.filter(f => f.parentId === id);
+
+        if (!options.force) {
+          info(`This will delete function "${func.name}" and all related activities.`);
+          if (children.length > 0) {
+            info(`Warning: This function has ${children.length} child function(s) that will become orphaned.`);
+          }
+          info('Use --force to confirm deletion.');
+          return;
+        }
+
+        await removeFromArray<Function>(path, id);
+        success(`Function "${func.name}" deleted`);
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to delete function');
+        process.exit(1);
+      }
+    });
+}