@hasna/skills 0.1.60 → 0.1.62

package/skills/budget-variance-analyzer/src/index.ts

@@ -1,298 +0,0 @@
-#!/usr/bin/env bun
-/**
- * budget-variance-analyzer
- * Explains budget vs actual variances using OpenAI.
- */
-
-import { parseArgs } from "util";
-import { existsSync, mkdirSync, appendFileSync, readFileSync } from "fs";
-import { join, dirname, resolve } from "path";
-import { randomUUID } from "crypto";
-
-type OutputFormat = "markdown" | "json";
-
-type VarianceTemplate = {
-  categories?: Array<Record<string, unknown>>;
-  notes?: string;
-};
-
-interface SkillOptions {
-  dataset: string;
-  period?: string;
-  audience?: string;
-  threshold: string;
-  currency?: string;
-  format: OutputFormat;
-  model: string;
-  output?: string;
-  template?: VarianceTemplate;
-}
-
-interface OpenAIChatResponse {
-  choices?: Array<{
-    message?: {
-      content?: string | null;
-    };
-  }>;
-  error?: {
-    message?: string;
-  };
-}
-
-const SKILL_SLUG = "budget-variance-analyzer";
-const SESSION_ID = randomUUID().slice(0, 8);
-
-function ensureDir(path: string) {
-  if (!existsSync(path)) {
-    mkdirSync(path, { recursive: true });
-  }
-}
-
-function getPaths() {
-  const sessionStamp = new Date().toISOString().replace(/[:.]/g, "_").replace(/-/g, "_");
-  const exportsRoot = process.env.SKILLS_EXPORTS_DIR || join(process.cwd(), ".skills", "exports");
-  const logsRoot = process.env.SKILLS_LOGS_DIR || join(process.cwd(), ".skills", "logs");
-
-  const skillExportsDir = join(exportsRoot, SKILL_SLUG);
-  const skillLogsDir = join(logsRoot, SKILL_SLUG);
-
-  ensureDir(skillExportsDir);
-  ensureDir(skillLogsDir);
-
-  return {
-    sessionStamp,
-    skillExportsDir,
-    skillLogsDir,
-  };
-}
-
-function createLogger(logDir: string, sessionStamp: string) {
-  const logFile = join(logDir, `log_${sessionStamp}_${SESSION_ID}.log`);
-
-  function write(level: "info" | "success" | "error", message: string) {
-    const timestamp = new Date().toISOString();
-    const entry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-    appendFileSync(logFile, entry);
-    const prefix = level === "success" ? "✅" : level === "error" ? "❌" : "ℹ️";
-    if (level === "error") {
-      console.error(`${prefix} ${message}`);
-    } else {
-      console.log(`${prefix} ${message}`);
-    }
-  }
-
-  return {
-    info: (message: string) => write("info", message),
-    success: (message: string) => write("success", message),
-    error: (message: string) => write("error", message),
-    logFile,
-  };
-}
-
-function slugify(value: string): string {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 40) || "budget-variance";
-}
-
-function parseJsonTemplate(content: string): VarianceTemplate | undefined {
-  try {
-    const data = JSON.parse(content);
-    if (typeof data === "object" && data !== null) {
-      return data as VarianceTemplate;
-    }
-  } catch (_error) {
-    // treat as plain text when parsing fails
-  }
-  return undefined;
-}
-
-function parseOptions(): SkillOptions {
-  const { values, positionals } = parseArgs({
-    args: Bun.argv.slice(2),
-    options: {
-      text: { type: "string" },
-      period: { type: "string" },
-      audience: { type: "string" },
-      threshold: { type: "string", default: "5%" },
-      currency: { type: "string" },
-      format: { type: "string", default: "markdown" },
-      model: { type: "string", default: "gpt-4o-mini" },
-      output: { type: "string" },
-      help: { type: "boolean", short: "h" },
-    },
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    console.log(`
-Budget Variance Analyzer - Explains budget vs actual variances
-
-Usage:
-  skills run budget-variance-analyzer -- [options] <file-path>
-
-Options:
-  --text <string>      Raw budget data
-  --period <string>    Analysis period
-  --audience <string>  Target audience
-  --threshold <string> Variance threshold (default: 5%)
-  --currency <string>  Currency symbol/code
-  --format <fmt>       Output format: markdown, json (default: markdown)
-  --model <model>      OpenAI model to use (default: gpt-4o-mini)
-  --output <path>      Save report to file
-  --help, -h           Show this help
-`);
-    process.exit(0);
-  }
-
-  let dataset = values.text || "";
-  let template: VarianceTemplate | undefined;
-
-  if (!dataset && positionals[0]) {
-    const filePath = resolve(positionals[0]);
-    if (!existsSync(filePath)) {
-      throw new Error(`File not found: ${filePath}`);
-    }
-    const content = readFileSync(filePath, "utf-8");
-    template = parseJsonTemplate(content);
-    dataset = template ? "" : content;
-  }
-
-  if (!dataset.trim() && !template) {
-    throw new Error("Provide budget vs actual data via file path, JSON template, or --text.");
-  }
-
-  const format: OutputFormat =
-    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
-
-  return {
-    dataset,
-    period: values.period as string,
-    audience: values.audience as string,
-    threshold: values.threshold as string,
-    currency: values.currency as string,
-    format,
-    model: values.model as string,
-    output: values.output as string,
-    template,
-  };
-}
-
-function buildPrompt(options: SkillOptions) {
-  const system = `You are an FP&A analyst explaining budget variances.
-Identify the largest variances, classify them as favorable or unfavorable, explain drivers, and recommend actions.
-Respect the specified threshold and tailor commentary to the audience.`;
-
-  const instructions =
-    options.format === "json"
-      ? "Respond in JSON with keys: summary, variances, drivers, risks, opportunities, actions. Each variance should include category, budget, actual, variance_value, variance_percent, classification, cause, owner." 
-      : "Respond in polished Markdown. Start with an executive summary, table major variances (category, budget, actual, variance %, driver), discuss root causes, highlight risks/opportunities, and list recommended actions with owners and due dates.";
-
-  const payload = {
-    period: options.period || "current period",
-    audience: options.audience || "Finance",
-    threshold: options.threshold,
-    currency: options.currency || "USD",
-    dataset_text: options.dataset.substring(0, 6000),
-    structured_template: options.template,
-  };
-
-  const user = `${instructions}\n\n${JSON.stringify(payload, null, 2)}`;
-
-  return { system, user };
-}
-
-async function callOpenAI(options: SkillOptions, system: string, user: string): Promise<string> {
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error("OPENAI_API_KEY environment variable is required.");
-  }
-
-  const body = {
-    model: options.model,
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: user },
-    ],
-    temperature: 0.35,
-    max_tokens: options.format === "json" ? 2200 : 2000,
-  };
-
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  const data: OpenAIChatResponse = await response.json();
-
-  if (!response.ok) {
-    throw new Error(data.error?.message || `OpenAI API error (${response.status})`);
-  }
-
-  const content = data.choices?.[0]?.message?.content;
-  if (!content) {
-    throw new Error("OpenAI response did not include content.");
-  }
-
-  return content.trim();
-}
-
-async function writeExport(path: string, content: string) {
-  ensureDir(dirname(path));
-  await Bun.write(path, content);
-}
-
-function buildExportPath(skillExportsDir: string, sessionStamp: string, options: SkillOptions) {
-  if (options.output) {
-    return resolve(options.output);
-  }
-
-  const descriptorParts = [options.period || "period", options.audience || "audience"];
-  const base = slugify(descriptorParts.filter(Boolean).join("-"));
-  const extension = options.format === "json" ? "json" : "md";
-  return join(skillExportsDir, `${base}_${sessionStamp}.${extension}`);
-}
-
-function preview(content: string) {
-  const lines = content.split(/\r?\n/).slice(0, 8);
-  lines.forEach(line => console.log(`   ${line}`));
-  if (content.split(/\r?\n/).length > 8) {
-    console.log("   ...");
-  }
-}
-
-async function main() {
-  const { sessionStamp, skillExportsDir, skillLogsDir } = getPaths();
-  const logger = createLogger(skillLogsDir, sessionStamp);
-
-  try {
-    logger.info(`Starting ${SKILL_SLUG} session: ${SESSION_ID}`);
-    const options = parseOptions();
-    logger.info("Parsed variance data and options.");
-
-    const { system, user } = buildPrompt(options);
-    logger.info("Constructed variance analysis prompt.");
-
-    const content = await callOpenAI(options, system, user);
-    logger.success("Received variance analysis from OpenAI.");
-
-    const exportPath = buildExportPath(skillExportsDir, sessionStamp, options);
-    await writeExport(exportPath, content);
-    logger.success(`Saved variance report to ${exportPath}`);
-
-    console.log("\nPreview:");
-    preview(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.error(message);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/budget-variance-analyzer/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "./dist",
-    "rootDir": ".",
-    "types": [
-      "bun"
-    ]
-  },
-  "include": [
-    "src/**/*",
-    "bin/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/skills/calendar-events/CLAUDE.md

@@ -1,19 +0,0 @@
-# calendar-events
-
-Calendar Events skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-calendar-events run
-```
-
-## Data Directory
-
-~/.skill/calendar-events/

package/skills/calendar-events/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "calendar-events",
-  "version": "0.1.0",
-  "description": "Calendar Events skill",
-  "type": "module",
-  "bin": {
-    "calendar-events": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  },
-  "publishConfig": {
-    "access": "restricted",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src",
-    "tsconfig.json"
-  ]
-}

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

@@ -1,103 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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