@hasna/skills 0.0.2

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

@@ -0,0 +1,93 @@
+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/skill-timesheet/src/lib/employees.ts

@@ -0,0 +1,56 @@
+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/skill-timesheet/src/lib/export.ts

@@ -0,0 +1,123 @@
+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/skill-timesheet/src/lib/holidays.ts

@@ -0,0 +1,79 @@
+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/skill-timesheet/src/lib/paths.ts

@@ -0,0 +1,59 @@
+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/skill-timesheet/src/lib/profiles.ts

@@ -0,0 +1,168 @@
+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/skill-timesheet/src/lib/storage.ts

@@ -0,0 +1,83 @@
+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}`;
+}