@hasna/skills 0.1.26 → 0.1.29

package/skills/brand-photo-shoot/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: brand-photo-shoot
+description: Generate hosted brand or product photo shoot sets
+---
+
+# Brand Photo Shoot
+
+Create a hosted premium product or brand photo shoot set with prompt planning, multiple scenes, selectable aspect ratios, gallery exports, captions, manifests, and receipts.
+
+## Usage
+
+```bash
+skills run brand-photo-shoot "premium coffee subscription campaign" --scenes 8 --aspect-ratios "1:1,4:5,16:9"
+skills run brand-photo-shoot --brief ./brand.md --style "editorial daylight studio"
+```
+
+## Output
+
+- `gallery/scene-*.png`
+- `prompt-plan.md`
+- `captions.csv`
+- `manifest.json`
+- `receipt.json`
+
+## Requirements
+
+Hosted premium execution requires `SKILLS_API_KEY` or `skills auth login`.
+Provider keys stay server-side.

package/skills/brand-photo-shoot/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "brand-photo-shoot",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Hosted premium brand photo shoot package generator",
+  "type": "module",
+  "bin": {
+    "brand-photo-shoot": "./src/index.ts"
+  }
+}

package/skills/brand-style-guide/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: Brand Style Guide
+name: brand-style-guide
 version: 1.0.0
 description: Perform brand style guide operations
 author: skills.md
@@ -10,4 +10,4 @@ tags:
 ---
 --brand "Brightwave"
   --voice "Optimistic, transparent, empowering"
-  --audience "Gen Z investors"
+  --audience "Gen Z investors"

package/skills/budget-variance-analyzer/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: Budget Variance Analyzer
+name: budget-variance-analyzer
 version: 0.1.0
 description: Explain budget versus actual variances with performance insights, key drivers, and recommended actions
 author: skills.md
@@ -80,4 +80,4 @@ skills run budget-variance-analyzer -- --text "Engineering: Budget 500k, Actual
 ## Requirements
 
 - `OPENAI_API_KEY` environment variable.
-- Bun runtime.
+- Bun runtime.

package/skills/businessactivity/package.json

@@ -4,7 +4,7 @@
   "type": "module",
   "description": "Business activity, workflow, and ownership management service",
   "bin": {
-    "businessactivity": "./bin/cli.ts"
+    "businessactivity": "src/index.ts"
   },
   "scripts": {
     "dev": "bun run bin/cli.ts",

package/skills/businessactivity/src/index.ts

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

package/skills/calendar-events/src/ai-parser.ts

@@ -0,0 +1,103 @@
+import { REQUEST_TIMEOUT_MS } from "./config";
+import { getOpenAIKey } from "./auth";
+import { log } from "./logger";
+import type { ParsedEvent } from "./types";
+
+export 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

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

@@ -0,0 +1,157 @@
+import { CALENDAR_API_BASE, REQUEST_TIMEOUT_MS } from "./config";
+import { log } from "./logger";
+import type { Calendar, CalendarEvent, CalendarListResponse, EventsListResponse } from "./types";
+
+export 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
+
+export async function listCalendars(accessToken: string): Promise<Calendar[]> {
+  const response = await calendarRequest<CalendarListResponse>(
+    "/users/me/calendarList",
+    accessToken
+  );
+  return response.items || [];
+}
+
+// List events
+export 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
+export async function getEvent(
+  accessToken: string,
+  calendarId: string,
+  eventId: string
+): Promise<CalendarEvent> {
+  return calendarRequest(
+    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`,
+    accessToken
+  );
+}
+
+// Create event
+export 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
+export 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
+export 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

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

@@ -0,0 +1,22 @@
+import { log } from "./logger";
+
+export 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
+export function getOpenAIKey(): string | null {
+  return process.env.OPENAI_API_KEY || null;
+}
+
+// Make authenticated Calendar API request

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

@@ -0,0 +1,6 @@
+export const CALENDAR_API_BASE = "https://www.googleapis.com/calendar/v3";
+
+// Request timeout in milliseconds (30 seconds)
+export const REQUEST_TIMEOUT_MS = 30000;
+
+// Constants

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

@@ -0,0 +1,96 @@
+import type { Calendar, CalendarEvent } from "./types";
+
+export 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
+export 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
+export 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
+export 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
+export 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
+export 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

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

@@ -0,0 +1,54 @@
+export 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.
+`);
+}
+
+// Main function