@hasna/skills 0.1.59 → 0.1.61

package/skills/timesheet/src/commands/vacation.ts

@@ -1,93 +0,0 @@
-import { Command } from 'commander';
-import { listVacations, getVacationsForEmployee, addVacation, removeVacation } from '../lib/vacations';
-import { getEmployee } from '../lib/employees';
-import { resolveProfile } from '../lib/profiles';
-import type { VacationType } from '../types';
-
-export const vacationCommand = new Command('vacation')
-  .description('Manage vacations');
-
-vacationCommand
-  .command('list')
-  .description('List all vacations')
-  .option('-e, --employee <id>', 'Filter by employee ID')
-  .action(async (options) => {
-    const profileName = await resolveProfile((vacationCommand.parent as Command)?.opts().profile);
-
-    let vacations;
-    if (options.employee) {
-      vacations = await getVacationsForEmployee(profileName, options.employee);
-    } else {
-      vacations = await listVacations(profileName);
-    }
-
-    if (vacations.length === 0) {
-      console.log(`No vacations in profile "${profileName}".`);
-      console.log('\nAdd one with:');
-      console.log('  service-timesheetgenerate vacation add -e <employee-id> -s YYYY-MM-DD -n YYYY-MM-DD');
-      return;
-    }
-
-    console.log(`Vacations in "${profileName}":\n`);
-    for (const vacation of vacations) {
-      console.log(`  [${vacation.id}] Employee: ${vacation.employeeId}`);
-      console.log(`      ${vacation.startDate} to ${vacation.endDate} (${vacation.type})`);
-      if (vacation.notes) {
-        console.log(`      Notes: ${vacation.notes}`);
-      }
-    }
-  });
-
-vacationCommand
-  .command('add')
-  .description('Add a new vacation')
-  .requiredOption('-e, --employee <id>', 'Employee ID')
-  .requiredOption('-s, --start <date>', 'Start date (YYYY-MM-DD)')
-  .requiredOption('-n, --end <date>', 'End date (YYYY-MM-DD)')
-  .option('-t, --type <type>', 'Vacation type (vacation, sick_leave, personal_leave, maternity_leave, paternity_leave)', 'vacation')
-  .option('--notes <notes>', 'Notes')
-  .action(async (options) => {
-    const profileName = await resolveProfile((vacationCommand.parent as Command)?.opts().profile);
-
-    // Validate date formats
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(options.start)) {
-      console.error('Invalid start date format. Use YYYY-MM-DD.');
-      process.exit(1);
-    }
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(options.end)) {
-      console.error('Invalid end date format. Use YYYY-MM-DD.');
-      process.exit(1);
-    }
-
-    // Verify employee exists
-    const employee = await getEmployee(profileName, options.employee);
-    if (!employee) {
-      console.error(`Employee "${options.employee}" not found.`);
-      process.exit(1);
-    }
-
-    const vacation = await addVacation(profileName, {
-      employeeId: options.employee,
-      startDate: options.start,
-      endDate: options.end,
-      type: options.type as VacationType,
-      notes: options.notes,
-    });
-
-    console.log(`Vacation added for ${employee.name}: ${vacation.startDate} to ${vacation.endDate}`);
-  });
-
-vacationCommand
-  .command('remove <id>')
-  .description('Remove a vacation')
-  .action(async (id) => {
-    const profileName = await resolveProfile((vacationCommand.parent as Command)?.opts().profile);
-
-    const removed = await removeVacation(profileName, id);
-    if (!removed) {
-      console.error(`Vacation "${id}" not found.`);
-      process.exit(1);
-    }
-
-    console.log(`Vacation "${id}" removed.`);
-  });

package/skills/timesheet/src/index.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env bun
-
-console.log("Usage: skills run timesheet -- <command> [options]");

package/skills/timesheet/src/lib/employees.ts

@@ -1,56 +0,0 @@
-import { getEmployeesPath } from './paths';
-import { readArray, appendToArray, updateInArray, removeFromArray, findById, generateId } from './storage';
-import type { Employee, EmployeeStatus } from '../types';
-
-// List all employees for a profile
-export async function listEmployees(profileName: string): Promise<Employee[]> {
-  return readArray<Employee>(getEmployeesPath(profileName));
-}
-
-// Get employee by ID
-export async function getEmployee(profileName: string, employeeId: string): Promise<Employee | null> {
-  return findById<Employee>(getEmployeesPath(profileName), employeeId);
-}
-
-// Add a new employee
-export async function addEmployee(
-  profileName: string,
-  data: {
-    name: string;
-    email?: string;
-    status?: EmployeeStatus;
-    dailyHours?: number;
-  }
-): Promise<Employee> {
-  const employee: Employee = {
-    id: generateId('emp'),
-    name: data.name,
-    email: data.email,
-    status: data.status || 'active',
-    dailyHours: data.dailyHours ?? 8,
-    createdAt: new Date().toISOString(),
-  };
-
-  return appendToArray(getEmployeesPath(profileName), employee);
-}
-
-// Update an employee
-export async function updateEmployee(
-  profileName: string,
-  employeeId: string,
-  data: Partial<Omit<Employee, 'id' | 'createdAt'>>
-): Promise<Employee | null> {
-  return updateInArray<Employee>(getEmployeesPath(profileName), employeeId, data);
-}
-
-// Remove an employee
-export async function removeEmployee(profileName: string, employeeId: string): Promise<boolean> {
-  return removeFromArray<Employee>(getEmployeesPath(profileName), employeeId);
-}
-
-// Find employee by name (case-insensitive partial match)
-export async function findEmployeeByName(profileName: string, name: string): Promise<Employee | null> {
-  const employees = await listEmployees(profileName);
-  const lowerName = name.toLowerCase();
-  return employees.find((e) => e.name.toLowerCase().includes(lowerName)) || null;
-}

package/skills/timesheet/src/lib/export.ts

@@ -1,123 +0,0 @@
-import { mkdir, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getExportsDir } from './paths';
-import { generateTimesheetData } from './timesheet';
-import type { TimesheetData, ExportRecord } from '../types';
-import { readArray, appendToArray, generateId } from './storage';
-
-function generateFilename(profileName: string, startDate: string, endDate: string, format: string): string {
-  const sanitizedName = profileName.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
-  const startStr = startDate.replace(/-/g, '');
-  const endStr = endDate.replace(/-/g, '');
-  const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
-
-  return `${sanitizedName}_${startStr}_${endStr}_${timestamp}.${format}`;
-}
-
-export function timesheetToCSV(data: TimesheetData): string {
-  const dates = Object.keys(data.rows[0]?.entries || {}).sort();
-
-  // Build header row
-  const headers = ['Employee', 'Status', 'Daily Hours', 'Total Hours', ...dates];
-
-  // Build data rows
-  const rows = data.rows.map((row) => {
-    const values = [
-      `"${row.employee}"`,
-      row.employeeStatus,
-      row.dailyHours.toString(),
-      row.totalHours.toString(),
-      ...dates.map((date) => {
-        const entry = row.entries[date];
-        return typeof entry === 'number' ? entry.toString() : `"${entry}"`;
-      }),
-    ];
-    return values.join(',');
-  });
-
-  return [headers.join(','), ...rows].join('\n');
-}
-
-export function timesheetToJSON(data: TimesheetData): string {
-  return JSON.stringify(
-    {
-      profile: data.profile,
-      startDate: data.startDate,
-      endDate: data.endDate,
-      generatedAt: data.generatedAt,
-      employees: data.rows.map((row) => ({
-        name: row.employee,
-        status: row.employeeStatus,
-        dailyHours: row.dailyHours,
-        totalHours: row.totalHours,
-        entries: row.entries,
-      })),
-    },
-    null,
-    2
-  );
-}
-
-function getExportsIndexPath(profileName: string): string {
-  return join(getExportsDir(profileName), 'exports.json');
-}
-
-export async function exportTimesheet(
-  profileName: string,
-  startDate: Date,
-  endDate: Date,
-  format: 'csv' | 'json' = 'csv'
-): Promise<ExportRecord> {
-  // Generate timesheet data
-  const timesheetData = await generateTimesheetData({
-    profileName,
-    startDate,
-    endDate,
-  });
-
-  // Convert to desired format
-  const content = format === 'csv' ? timesheetToCSV(timesheetData) : timesheetToJSON(timesheetData);
-
-  // Ensure exports directory exists
-  const exportsDir = getExportsDir(profileName);
-  if (!existsSync(exportsDir)) {
-    await mkdir(exportsDir, { recursive: true });
-  }
-
-  // Generate filename and save
-  const filename = generateFilename(profileName, timesheetData.startDate, timesheetData.endDate, format);
-  const filePath = join(exportsDir, filename);
-  await writeFile(filePath, content, 'utf-8');
-
-  // Record export
-  const exportRecord: ExportRecord = {
-    id: generateId('exp'),
-    startDate: timesheetData.startDate,
-    endDate: timesheetData.endDate,
-    format,
-    filePath,
-    createdAt: new Date().toISOString(),
-  };
-
-  await appendToArray(getExportsIndexPath(profileName), exportRecord);
-
-  return exportRecord;
-}
-
-export async function exportMonthlyTimesheet(
-  profileName: string,
-  year: number,
-  month: number,
-  format: 'csv' | 'json' = 'csv'
-): Promise<ExportRecord> {
-  const startDate = new Date(Date.UTC(year, month - 1, 1));
-  const endDate = new Date(Date.UTC(year, month, 0)); // Last day of month
-
-  return exportTimesheet(profileName, startDate, endDate, format);
-}
-
-export async function listExports(profileName: string): Promise<ExportRecord[]> {
-  const exports = await readArray<ExportRecord>(getExportsIndexPath(profileName));
-  return exports.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}

package/skills/timesheet/src/lib/holidays.ts

@@ -1,79 +0,0 @@
-import { getHolidaysPath } from './paths';
-import { readArray, appendToArray, removeFromArray, generateId } from './storage';
-import type { Holiday } from '../types';
-
-// List all holidays for a profile
-export async function listHolidays(profileName: string): Promise<Holiday[]> {
-  return readArray<Holiday>(getHolidaysPath(profileName));
-}
-
-// Get holidays for a specific year (including recurring)
-export async function getHolidaysForYear(profileName: string, year: number): Promise<Holiday[]> {
-  const holidays = await listHolidays(profileName);
-  return holidays.filter((h) => {
-    const holidayYear = parseInt(h.date.split('-')[0]);
-    return h.recurring || holidayYear === year;
-  });
-}
-
-// Get holidays within a date range
-export async function getHolidaysInRange(
-  profileName: string,
-  startDate: string,
-  endDate: string
-): Promise<Holiday[]> {
-  const holidays = await listHolidays(profileName);
-  const startYear = parseInt(startDate.split('-')[0]);
-  const endYear = parseInt(endDate.split('-')[0]);
-
-  const result: Holiday[] = [];
-
-  for (const holiday of holidays) {
-    if (holiday.recurring) {
-      // For recurring holidays, check each year in range
-      for (let year = startYear; year <= endYear; year++) {
-        const monthDay = holiday.date.slice(5); // MM-DD
-        const dateInYear = `${year}-${monthDay}`;
-        if (dateInYear >= startDate && dateInYear <= endDate) {
-          result.push({ ...holiday, date: dateInYear });
-        }
-      }
-    } else {
-      // Non-recurring: check if within range
-      if (holiday.date >= startDate && holiday.date <= endDate) {
-        result.push(holiday);
-      }
-    }
-  }
-
-  return result;
-}
-
-// Add a new holiday
-export async function addHoliday(
-  profileName: string,
-  data: {
-    name: string;
-    date: string;
-    recurring?: boolean;
-  }
-): Promise<Holiday> {
-  const holiday: Holiday = {
-    id: generateId('hol'),
-    name: data.name,
-    date: data.date,
-    recurring: data.recurring ?? false,
-  };
-
-  return appendToArray(getHolidaysPath(profileName), holiday);
-}
-
-// Remove a holiday
-export async function removeHoliday(profileName: string, holidayId: string): Promise<boolean> {
-  return removeFromArray<Holiday>(getHolidaysPath(profileName), holidayId);
-}
-
-// Check if a date is a holiday
-export function isHoliday(date: string, holidays: Holiday[]): Holiday | undefined {
-  return holidays.find((h) => h.date === date);
-}

package/skills/timesheet/src/lib/paths.ts

@@ -1,59 +0,0 @@
-import { join } from 'path';
-import { homedir } from 'os';
-
-const SERVICE_NAME = 'service-timesheetgenerate';
-
-// Base service directory: ~/.service/service-timesheetgenerate/
-export function getServiceDir(): string {
-  return join(homedir(), '.service', SERVICE_NAME);
-}
-
-// Global config: ~/.service/service-timesheetgenerate/config.json
-export function getConfigPath(): string {
-  return join(getServiceDir(), 'config.json');
-}
-
-// Profiles directory: ~/.service/service-timesheetgenerate/profiles/
-export function getProfilesDir(): string {
-  return join(getServiceDir(), 'profiles');
-}
-
-// Single profile directory: ~/.service/service-timesheetgenerate/profiles/{name}/
-export function getProfileDir(profileName: string): string {
-  return join(getProfilesDir(), profileName);
-}
-
-// Profile config: ~/.service/service-timesheetgenerate/profiles/{name}/profile.json
-export function getProfileConfigPath(profileName: string): string {
-  return join(getProfileDir(profileName), 'profile.json');
-}
-
-// Employees file: ~/.service/service-timesheetgenerate/profiles/{name}/employees.json
-export function getEmployeesPath(profileName: string): string {
-  return join(getProfileDir(profileName), 'employees.json');
-}
-
-// Holidays file: ~/.service/service-timesheetgenerate/profiles/{name}/holidays.json
-export function getHolidaysPath(profileName: string): string {
-  return join(getProfileDir(profileName), 'holidays.json');
-}
-
-// Vacations file: ~/.service/service-timesheetgenerate/profiles/{name}/vacations.json
-export function getVacationsPath(profileName: string): string {
-  return join(getProfileDir(profileName), 'vacations.json');
-}
-
-// Exports directory: ~/.service/service-timesheetgenerate/profiles/{name}/exports/
-export function getExportsDir(profileName: string): string {
-  return join(getProfileDir(profileName), 'exports');
-}
-
-// Logs directory: ~/.service/service-timesheetgenerate/logs/
-export function getLogsDir(): string {
-  return join(getServiceDir(), 'logs');
-}
-
-// Log file: ~/.service/service-timesheetgenerate/logs/timesheetgenerate.log
-export function getLogFilePath(): string {
-  return join(getLogsDir(), 'timesheetgenerate.log');
-}

package/skills/timesheet/src/lib/profiles.ts

@@ -1,168 +0,0 @@
-import { existsSync } from 'fs';
-import { readdir, mkdir, rm } from 'fs/promises';
-import {
-  getServiceDir,
-  getConfigPath,
-  getProfilesDir,
-  getProfileDir,
-  getProfileConfigPath,
-  getEmployeesPath,
-  getHolidaysPath,
-  getVacationsPath,
-  getExportsDir,
-  getLogsDir,
-} from './paths';
-import { readJson, writeJson } from './storage';
-import type { Profile, GlobalConfig } from '../types';
-
-const DEFAULT_CONFIG: GlobalConfig = {
-  version: '1.0.0',
-};
-
-// Check if service is set up
-export function isServiceSetup(): boolean {
-  return existsSync(getServiceDir());
-}
-
-// Get global config
-export async function getConfig(): Promise<GlobalConfig> {
-  return readJson<GlobalConfig>(getConfigPath(), DEFAULT_CONFIG);
-}
-
-// Save global config
-export async function saveConfig(config: GlobalConfig): Promise<void> {
-  await writeJson(getConfigPath(), config);
-}
-
-// Get default profile name
-export async function getDefaultProfile(): Promise<string | undefined> {
-  const config = await getConfig();
-  return config.defaultProfile;
-}
-
-// Set default profile
-export async function setDefaultProfile(profileName: string): Promise<void> {
-  const config = await getConfig();
-  config.defaultProfile = profileName;
-  await saveConfig(config);
-}
-
-// List all profiles
-export async function listProfiles(): Promise<string[]> {
-  const profilesDir = getProfilesDir();
-  if (!existsSync(profilesDir)) {
-    return [];
-  }
-
-  const entries = await readdir(profilesDir, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-}
-
-// Check if profile exists
-export function profileExists(profileName: string): boolean {
-  return existsSync(getProfileDir(profileName));
-}
-
-// Get profile data
-export async function getProfile(profileName: string): Promise<Profile | null> {
-  const configPath = getProfileConfigPath(profileName);
-  if (!existsSync(configPath)) {
-    return null;
-  }
-  return readJson<Profile>(configPath, null as any);
-}
-
-// Create a new profile
-export async function createProfile(
-  name: string,
-  data: Omit<Profile, 'name' | 'createdAt'>
-): Promise<Profile> {
-  const profileDir = getProfileDir(name);
-
-  if (existsSync(profileDir)) {
-    throw new Error(`Profile "${name}" already exists`);
-  }
-
-  // Create profile directory structure
-  await mkdir(profileDir, { recursive: true });
-  await mkdir(getExportsDir(name), { recursive: true });
-
-  const profile: Profile = {
-    name,
-    country: data.country,
-    timezone: data.timezone,
-    weekendDays: data.weekendDays,
-    createdAt: new Date().toISOString(),
-  };
-
-  // Write profile config
-  await writeJson(getProfileConfigPath(name), profile);
-
-  // Initialize empty data files
-  await writeJson(getEmployeesPath(name), []);
-  await writeJson(getHolidaysPath(name), []);
-  await writeJson(getVacationsPath(name), []);
-
-  return profile;
-}
-
-// Delete a profile
-export async function deleteProfile(profileName: string): Promise<boolean> {
-  const profileDir = getProfileDir(profileName);
-
-  if (!existsSync(profileDir)) {
-    return false;
-  }
-
-  await rm(profileDir, { recursive: true, force: true });
-
-  // Clear default if it was this profile
-  const config = await getConfig();
-  if (config.defaultProfile === profileName) {
-    config.defaultProfile = undefined;
-    await saveConfig(config);
-  }
-
-  return true;
-}
-
-// Initialize service directory
-export async function setupService(): Promise<{ created: boolean; path: string }> {
-  const serviceDir = getServiceDir();
-  const wasNew = !existsSync(serviceDir);
-
-  await mkdir(serviceDir, { recursive: true });
-  await mkdir(getProfilesDir(), { recursive: true });
-  await mkdir(getLogsDir(), { recursive: true });
-
-  // Initialize config if not exists
-  if (!existsSync(getConfigPath())) {
-    await writeJson(getConfigPath(), DEFAULT_CONFIG);
-  }
-
-  return {
-    created: wasNew,
-    path: serviceDir,
-  };
-}
-
-// Resolve profile name (use provided or default)
-export async function resolveProfile(providedProfile?: string): Promise<string> {
-  if (providedProfile) {
-    if (!profileExists(providedProfile)) {
-      throw new Error(`Profile "${providedProfile}" does not exist`);
-    }
-    return providedProfile;
-  }
-
-  const defaultProfile = await getDefaultProfile();
-  if (!defaultProfile) {
-    throw new Error('No profile specified and no default profile set. Use -p <profile> or run: timesheetgenerate profile use <name>');
-  }
-
-  if (!profileExists(defaultProfile)) {
-    throw new Error(`Default profile "${defaultProfile}" does not exist`);
-  }
-
-  return defaultProfile;
-}

package/skills/timesheet/src/lib/storage.ts

@@ -1,83 +0,0 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { dirname } from 'path';
-
-// Read JSON file, return default value if file doesn't exist
-export async function readJson<T>(path: string, defaultValue: T): Promise<T> {
-  try {
-    const content = await readFile(path, 'utf-8');
-    return JSON.parse(content) as T;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return defaultValue;
-    }
-    throw error;
-  }
-}
-
-// Write JSON file, creating directories if needed
-export async function writeJson<T>(path: string, data: T): Promise<void> {
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true });
-  }
-  await writeFile(path, JSON.stringify(data, null, 2), 'utf-8');
-}
-
-// Read array from JSON file
-export async function readArray<T>(path: string): Promise<T[]> {
-  return readJson<T[]>(path, []);
-}
-
-// Append item to array in JSON file, returns the item
-export async function appendToArray<T extends { id: string }>(path: string, item: T): Promise<T> {
-  const array = await readArray<T>(path);
-  array.push(item);
-  await writeJson(path, array);
-  return item;
-}
-
-// Update item in array by ID
-export async function updateInArray<T extends { id: string }>(
-  path: string,
-  id: string,
-  updates: Partial<T>
-): Promise<T | null> {
-  const array = await readArray<T>(path);
-  const index = array.findIndex((item) => item.id === id);
-
-  if (index === -1) {
-    return null;
-  }
-
-  array[index] = { ...array[index], ...updates };
-  await writeJson(path, array);
-  return array[index];
-}
-
-// Remove item from array by ID
-export async function removeFromArray<T extends { id: string }>(path: string, id: string): Promise<boolean> {
-  const array = await readArray<T>(path);
-  const index = array.findIndex((item) => item.id === id);
-
-  if (index === -1) {
-    return false;
-  }
-
-  array.splice(index, 1);
-  await writeJson(path, array);
-  return true;
-}
-
-// Find item in array by ID
-export async function findById<T extends { id: string }>(path: string, id: string): Promise<T | null> {
-  const array = await readArray<T>(path);
-  return array.find((item) => item.id === id) || null;
-}
-
-// Generate a short unique ID
-export function generateId(prefix: string): string {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `${prefix}_${timestamp}${random}`;
-}