@hasna/skills 0.1.26 → 0.1.29

package/skills/calendar-events/src/index.ts

@@ -6,532 +6,29 @@
  */
 
 import { parseArgs } from "util";
-import { existsSync, mkdirSync, appendFileSync } from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-
-// Google Calendar API base URL
-const CALENDAR_API_BASE = "https://www.googleapis.com/calendar/v3";
-
-// Request timeout in milliseconds (30 seconds)
-const REQUEST_TIMEOUT_MS = 30000;
-
-// Constants
-const SKILL_NAME = "calendar-events";
-const SESSION_ID = randomUUID().slice(0, 8);
-const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
-const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
-const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
-
-// Ensure directories exist
-function ensureDir(dir: string) {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-// Logger
-function log(message: string, level: "info" | "error" | "success" | "debug" = "info") {
-  ensureDir(LOGS_DIR);
-  const timestamp = new Date().toISOString();
-  const logFile = join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
-  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-  appendFileSync(logFile, logEntry);
-
-  const prefix = level === "error" ? "❌" : level === "success" ? "✅" : level === "debug" ? "🔍" : "ℹ️";
-  if (level === "error") {
-    console.error(`${prefix} ${message}`);
-  } else if (level !== "debug") {
-    console.log(`${prefix} ${message}`);
-  }
-}
-
-// Types
-interface CalendarEvent {
-  id: string;
-  summary?: string;
-  description?: string;
-  location?: string;
-  start: {
-    dateTime?: string;
-    date?: string;
-    timeZone?: string;
-  };
-  end: {
-    dateTime?: string;
-    date?: string;
-    timeZone?: string;
-  };
-  attendees?: Array<{
-    email: string;
-    displayName?: string;
-    responseStatus?: string;
-  }>;
-  htmlLink?: string;
-  status?: string;
-  created?: string;
-  updated?: string;
-  organizer?: {
-    email: string;
-    displayName?: string;
-  };
-  reminders?: {
-    useDefault: boolean;
-    overrides?: Array<{
-      method: string;
-      minutes: number;
-    }>;
-  };
-}
-
-interface Calendar {
-  id: string;
-  summary: string;
-  description?: string;
-  primary?: boolean;
-  backgroundColor?: string;
-  accessRole?: string;
-}
-
-interface EventsListResponse {
-  items?: CalendarEvent[];
-  nextPageToken?: string;
-}
-
-interface CalendarListResponse {
-  items?: Calendar[];
-}
-
-// Parsed event from AI
-interface ParsedEvent {
-  title: string;
-  startDateTime: string; // ISO 8601
-  endDateTime: string; // ISO 8601
-  isAllDay: boolean;
-  location?: string;
-  description?: string;
-  attendees?: string[];
-}
-
-// Get access token from environment
-function getAccessToken(): string {
-  const token = process.env.GOOGLE_CALENDAR_ACCESS_TOKEN;
-  if (!token) {
-    log("Error: Google Calendar not connected.", "error");
-    console.error("");
-    console.error("To use this skill, you need to connect your Google Calendar:");
-    console.error("1. Go to https://skills.md/dashboard/connectors");
-    console.error("2. Click 'Connect' on the Google Calendar connector");
-    console.error("3. Authorize access to your Google Calendar");
-    process.exit(1);
-  }
-  return token;
-}
-
-// Get OpenAI API key
-function getOpenAIKey(): string | null {
-  return process.env.OPENAI_API_KEY || null;
-}
-
-// Make authenticated Calendar API request
-async function calendarRequest<T>(
-  endpoint: string,
-  accessToken: string,
-  options: RequestInit = {}
-): Promise<T> {
-  const url = `${CALENDAR_API_BASE}${endpoint}`;
-
-  log(`Calendar API request: ${options.method || "GET"} ${endpoint}`, "debug");
-
-  try {
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        ...options.headers,
-      },
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-    });
-
-    log(`Calendar API response: ${response.status}`, "debug");
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      if (response.status === 401) {
-        log("Error: Google Calendar access token expired or invalid.", "error");
-        console.error("Please reconnect your Google Calendar in the Connectors dashboard.");
-        process.exit(1);
-      }
-      throw new Error(error.error?.message || `Calendar API error: ${response.status}`);
-    }
-
-    // Handle empty responses
-    if (response.status === 204) {
-      return {} as T;
-    }
-
-    return response.json();
-  } catch (error) {
-    if (error instanceof Error && error.name === "TimeoutError") {
-      throw new Error(`Calendar API request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
-    }
-    throw error;
-  }
-}
-
-// Parse natural language event using OpenAI
-async function parseEventWithAI(
-  text: string,
-  timezone: string
-): Promise<ParsedEvent> {
-  const openaiKey = getOpenAIKey();
-  if (!openaiKey) {
-    throw new Error("OPENAI_API_KEY is required for natural language parsing. Use 'create' command with explicit options instead.");
-  }
-
-  const now = new Date();
-  const currentDate = now.toISOString().split("T")[0];
-  const currentTime = now.toTimeString().split(" ")[0];
-  const dayOfWeek = now.toLocaleDateString("en-US", { weekday: "long" });
-
-  const systemPrompt = `You are a calendar event parser. Extract event details from natural language and return a JSON object.
-
-Current context:
-- Today is ${dayOfWeek}, ${currentDate}
-- Current time is ${currentTime}
-- Timezone: ${timezone}
-
-Rules:
-1. Parse the input and extract: title, start date/time, end date/time, location, description, attendees
-2. For relative dates like "tomorrow", "next week", "next Monday", calculate the actual date
-3. "Next week" means 7 days from today
-4. If only a time is given (e.g., "at 5am"), assume it's the next occurrence of that time
-5. If no duration is specified, default to 1 hour for meetings/events
-6. For all-day events (like "vacation on Dec 25"), set isAllDay to true
-7. Return dates in ISO 8601 format with timezone offset
-
-Return ONLY a valid JSON object with this structure:
-{
-  "title": "Event title",
-  "startDateTime": "2025-01-15T10:00:00-08:00",
-  "endDateTime": "2025-01-15T11:00:00-08:00",
-  "isAllDay": false,
-  "location": "optional location",
-  "description": "optional description",
-  "attendees": ["email@example.com"]
-}
-
-For all-day events, use date format without time:
-{
-  "title": "Vacation",
-  "startDateTime": "2025-01-15",
-  "endDateTime": "2025-01-16",
-  "isAllDay": true
-}`;
-
-  log(`OpenAI API request: Parsing event`, "debug");
-
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${openaiKey}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      model: "gpt-4o-mini",
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: text },
-      ],
-      temperature: 0,
-      response_format: { type: "json_object" },
-    }),
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-  });
-
-  log(`OpenAI API response: ${response.status}`, "debug");
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({}));
-    throw new Error(error.error?.message || `OpenAI API error: ${response.status}`);
-  }
-
-  const data = await response.json();
-  const content = data.choices?.[0]?.message?.content;
-
-  if (!content) {
-    throw new Error("Failed to parse event from AI response");
-  }
-
-  try {
-    const parsed = JSON.parse(content) as ParsedEvent;
-
-    // Validate required fields
-    if (!parsed.title || !parsed.startDateTime || !parsed.endDateTime) {
-      throw new Error("AI response missing required fields");
-    }
-
-    return parsed;
-  } catch (e) {
-    throw new Error(`Failed to parse AI response: ${e instanceof Error ? e.message : "Invalid JSON"}`);
-  }
-}
 
-// List calendars
-async function listCalendars(accessToken: string): Promise<Calendar[]> {
-  const response = await calendarRequest<CalendarListResponse>(
-    "/users/me/calendarList",
-    accessToken
-  );
-  return response.items || [];
-}
-
-// List events
-async function listEvents(
-  accessToken: string,
-  options: {
-    calendarId: string;
-    timeMin?: string;
-    timeMax?: string;
-    maxResults?: number;
-    pageToken?: string;
-  }
-): Promise<EventsListResponse> {
-  const params = new URLSearchParams();
-
-  if (options.timeMin) {
-    params.set("timeMin", options.timeMin);
-  }
-  if (options.timeMax) {
-    params.set("timeMax", options.timeMax);
-  }
-  if (options.maxResults) {
-    params.set("maxResults", options.maxResults.toString());
-  }
-  if (options.pageToken) {
-    params.set("pageToken", options.pageToken);
-  }
-
-  params.set("singleEvents", "true");
-  params.set("orderBy", "startTime");
-
-  return calendarRequest(
-    `/calendars/${encodeURIComponent(options.calendarId)}/events?${params.toString()}`,
-    accessToken
-  );
-}
-
-// Get single event
-async function getEvent(
-  accessToken: string,
-  calendarId: string,
-  eventId: string
-): Promise<CalendarEvent> {
-  return calendarRequest(
-    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`,
-    accessToken
-  );
-}
-
-// Create event
-async function createEvent(
-  accessToken: string,
-  calendarId: string,
-  event: Partial<CalendarEvent>
-): Promise<CalendarEvent> {
-  return calendarRequest(
-    `/calendars/${encodeURIComponent(calendarId)}/events`,
-    accessToken,
-    {
-      method: "POST",
-      body: JSON.stringify(event),
-    }
-  );
-}
-
-// Update event
-async function updateEvent(
-  accessToken: string,
-  calendarId: string,
-  eventId: string,
-  updates: Partial<CalendarEvent>
-): Promise<CalendarEvent> {
-  return calendarRequest(
-    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`,
-    accessToken,
-    {
-      method: "PATCH",
-      body: JSON.stringify(updates),
-    }
-  );
-}
-
-// Delete event
-async function deleteEvent(
-  accessToken: string,
-  calendarId: string,
-  eventId: string
-): Promise<void> {
-  await calendarRequest(
-    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`,
-    accessToken,
-    {
-      method: "DELETE",
-    }
-  );
-}
-
-// Format date for display
-function formatDate(dateStr: string): string {
-  const date = new Date(dateStr);
-  return date.toLocaleDateString("en-US", {
-    weekday: "short",
-    month: "short",
-    day: "numeric",
-    year: "numeric",
-  });
-}
-
-// Format time for display
-function formatTime(dateStr: string): string {
-  const date = new Date(dateStr);
-  return date.toLocaleTimeString("en-US", {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true,
-  });
-}
-
-// Format events for text output
-function formatEventsText(events: CalendarEvent[]): string {
-  if (events.length === 0) {
-    return "No upcoming events found.";
-  }
-
-  const lines: string[] = [];
-  let currentDate = "";
-
-  for (const event of events) {
-    const startDate = event.start.dateTime || event.start.date || "";
-    const eventDate = formatDate(startDate);
-
-    if (eventDate !== currentDate) {
-      if (currentDate !== "") lines.push("");
-      lines.push(eventDate);
-      currentDate = eventDate;
-    }
-
-    const isAllDay = !event.start.dateTime;
-    if (isAllDay) {
-      lines.push(`  All Day     ${event.summary || "(No title)"}`);
-    } else {
-      const startTime = formatTime(event.start.dateTime!);
-      const endTime = formatTime(event.end.dateTime!);
-      lines.push(`  ${startTime} - ${endTime}  ${event.summary || "(No title)"}`);
-    }
-
-    if (event.location) {
-      lines.push(`              Location: ${event.location}`);
-    }
-
-    lines.push(`              ID: ${event.id}`);
-  }
-
-  return lines.join("\n");
-}
-
-// Format calendars for text output
-function formatCalendarsText(calendars: Calendar[]): string {
-  const lines = ["Your Calendars", "==============", ""];
-
-  for (const cal of calendars) {
-    const primary = cal.primary ? " (primary)" : "";
-    lines.push(`${cal.summary}${primary}`);
-    lines.push(`  ID: ${cal.id}`);
-    if (cal.description) {
-      lines.push(`  Description: ${cal.description}`);
-    }
-    lines.push("");
-  }
-
-  return lines.join("\n");
-}
-
-// Parse attendees from comma-separated string
-function parseAttendees(input: string): Array<{ email: string }> {
-  return input
-    .split(",")
-    .map((email) => email.trim())
-    .filter(Boolean)
-    .map((email) => ({ email }));
-}
-
-// Parse reminder minutes from comma-separated string
-function parseReminders(input: string): Array<{ method: string; minutes: number }> {
-  return input
-    .split(",")
-    .map((m) => parseInt(m.trim(), 10))
-    .filter((m) => !isNaN(m))
-    .map((minutes) => ({ method: "popup", minutes }));
-}
-
-// Show help
-function showHelp(): void {
-  console.log(`
-Calendar Events - Manage Google Calendar events
-
-Usage:
-  skills run calendar-events -- <command> [options]
-
-Commands:
-  list                List upcoming events
-  create              Create a new event with explicit options
-  add <text>          Create event from natural language (AI-powered)
-  update              Update an existing event
-  delete              Delete an event
-  get                 Get details of a specific event
-  calendars           List available calendars
-
-Options:
-  --days <n>          Days to look ahead (for list) [default: 14]
-  --max <n>           Maximum events to return [default: 50]
-  --calendar <id>     Calendar ID [default: primary]
-  --id <event-id>     Event ID (for get/update/delete)
-  --title <text>      Event title
-  --start <datetime>  Start time (ISO 8601: "2025-01-15T10:00:00")
-  --end <datetime>    End time (ISO 8601: "2025-01-15T11:00:00")
-  --duration <mins>   Duration in minutes (alternative to --end)
-  --date <date>       Date for all-day event (YYYY-MM-DD)
-  --all-day           Create as all-day event
-  --location <text>   Event location
-  --description <text> Event description
-  --attendees <emails> Comma-separated attendee emails (create/update)
-  --reminder <mins>   Reminder minutes (comma-separated, e.g., 10,30)
-  --format <format>   Output format: text or json [default: text]
-  --help, -h          Show this help
-
-Examples:
-  # List events for next 7 days
-  skills run calendar-events -- list --days 7
-
-  # Create an event with explicit options
-  skills run calendar-events -- create --title "Meeting" --start "2025-01-15T10:00:00" --end "2025-01-15T11:00:00"
-
-  # Create an event using natural language (AI-powered)
-  skills run calendar-events -- add "Team standup next Monday at 9am for 30 minutes"
-  skills run calendar-events -- add "Lunch with Sarah tomorrow at noon at Cafe Milano"
-  skills run calendar-events -- add "Vacation Dec 25-27"
-
-  # Delete an event
-  skills run calendar-events -- delete --id abc123
-
-Note: The 'add' command requires OPENAI_API_KEY for natural language parsing.
-`);
-}
+import { getAccessToken } from "./auth";
+import { parseEventWithAI } from "./ai-parser";
+import {
+  createEvent,
+  deleteEvent,
+  getEvent,
+  listCalendars,
+  listEvents,
+  updateEvent,
+} from "./api";
+import {
+  formatCalendarsText,
+  formatDate,
+  formatEventsText,
+  formatTime,
+  parseAttendees,
+  parseReminders,
+} from "./format";
+import { showHelp } from "./help";
+import { log, SESSION_ID, SKILL_NAME } from "./logger";
+import type { CalendarEvent } from "./types";
 
-// Main function
 async function main() {
   log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`, "debug");
 

package/skills/calendar-events/src/logger.ts

@@ -0,0 +1,34 @@
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import { join } from "path";
+
+export const SKILL_NAME = "calendar-events";
+export const SESSION_ID = randomUUID().slice(0, 8);
+export const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
+export const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
+export const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
+
+// Ensure directories exist
+export function ensureDir(dir: string) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Logger
+export function log(message: string, level: "info" | "error" | "success" | "debug" = "info") {
+  ensureDir(LOGS_DIR);
+  const timestamp = new Date().toISOString();
+  const logFile = join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
+  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+  appendFileSync(logFile, logEntry);
+
+  const prefix = level === "error" ? "❌" : level === "success" ? "✅" : level === "debug" ? "🔍" : "ℹ️";
+  if (level === "error") {
+    console.error(`${prefix} ${message}`);
+  } else if (level !== "debug") {
+    console.log(`${prefix} ${message}`);
+  }
+}
+
+// Types

package/skills/calendar-events/src/types.ts

@@ -0,0 +1,67 @@
+export interface CalendarEvent {
+  id: string;
+  summary?: string;
+  description?: string;
+  location?: string;
+  start: {
+    dateTime?: string;
+    date?: string;
+    timeZone?: string;
+  };
+  end: {
+    dateTime?: string;
+    date?: string;
+    timeZone?: string;
+  };
+  attendees?: Array<{
+    email: string;
+    displayName?: string;
+    responseStatus?: string;
+  }>;
+  htmlLink?: string;
+  status?: string;
+  created?: string;
+  updated?: string;
+  organizer?: {
+    email: string;
+    displayName?: string;
+  };
+  reminders?: {
+    useDefault: boolean;
+    overrides?: Array<{
+      method: string;
+      minutes: number;
+    }>;
+  };
+}
+
+export interface Calendar {
+  id: string;
+  summary: string;
+  description?: string;
+  primary?: boolean;
+  backgroundColor?: string;
+  accessRole?: string;
+}
+
+export interface EventsListResponse {
+  items?: CalendarEvent[];
+  nextPageToken?: string;
+}
+
+export interface CalendarListResponse {
+  items?: Calendar[];
+}
+
+// Parsed event from AI
+export interface ParsedEvent {
+  title: string;
+  startDateTime: string; // ISO 8601
+  endDateTime: string; // ISO 8601
+  isAllDay: boolean;
+  location?: string;
+  description?: string;
+  attendees?: string[];
+}
+
+// Get access token from environment

package/skills/compress-video/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: Compress Video
+name: compress-video
 version: 0.1.0
 description: Compress videos while preserving quality using FFmpeg with multiple codec options and preset configurations
 author: skills.md
@@ -76,4 +76,4 @@ skills run compress-video -- vlog.mp4 \
 ## Requirements
 
 - FFmpeg installed and in PATH.
-- Bun runtime.
+- Bun runtime.

package/skills/consolelog/package.json

@@ -9,7 +9,7 @@
     "access": "restricted"
   },
   "bin": {
-    "consolelog": "./bin/cli.ts"
+    "consolelog": "src/index.ts"
   },
   "files": [
     "bin",

package/skills/consolelog/src/index.ts

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