@hasna/skills 0.1.60 → 0.1.62

package/skills/advanced-math/src/cli.ts

@@ -1,130 +0,0 @@
-import { parseArgs } from "util";
-import { log } from "./runtime";
-import type {
-  FinanceType,
-  MathOptions,
-  MatrixOperation,
-  Mode,
-  NumberFormat,
-  OutputFormat,
-  SymbolicOperation,
-} from "./types";
-
-export function parseMathCli(): { input: string; mode: Mode; precision: number; options: MathOptions; positionals: string[] } {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-      mode: { type: "string", default: "calc" },
-      precision: { type: "string", default: "10" },
-      format: { type: "string", default: "number" },
-      output: { type: "string", default: "text" },
-      "show-steps": { type: "boolean", default: false },
-      stats: { type: "string" },
-      matrix: { type: "string" },
-      from: { type: "string" },
-      to: { type: "string" },
-      finance: { type: "string" },
-      principal: { type: "string" },
-      rate: { type: "string" },
-      years: { type: "string" },
-      periods: { type: "string" },
-      payment: { type: "string" },
-      cashflows: { type: "string" },
-      operation: { type: "string" },
-      var: { type: "string", default: "x" },
-      help: { type: "boolean", short: "h" },
-    },
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    console.log(`
-╔═══════════════════════════════════════════════════════════════════════════════╗
-║                        ADVANCED MATH - Calculation Engine                      ║
-║     Perform complex mathematical operations, statistics, and symbolic math     ║
-╚═══════════════════════════════════════════════════════════════════════════════╝
-
-USAGE:
-  skills run advanced-math -- "<expression or data>" [options]
-
-MODES:
-  calc      Basic expression evaluation and scientific calculations
-  stats     Statistical analysis (mean, median, std dev, etc.)
-  matrix    Matrix operations (determinant, inverse, eigenvalues)
-  convert   Unit conversions (length, weight, temperature, etc.)
-  finance   Financial calculations (compound interest, NPV, IRR)
-  symbolic  AI-powered symbolic math (derivatives, integrals)
-
-OPTIONS:
-  --mode <mode>           Calculation mode [default: calc]
-  --precision <n>         Decimal places [default: 10]
-  --format <format>       Output format: number, scientific, fraction, percentage
-  --output <format>       Result format: text, json, latex [default: text]
-  --show-steps           Show calculation steps
-
-CALC MODE:
-  skills run advanced-math -- "2 + 2 * 3"
-  skills run advanced-math -- "sin(pi/4) + cos(pi/4)"
-  skills run advanced-math -- "sqrt(16) + log10(100)"
-
-STATS MODE:
-  skills run advanced-math -- "1,2,3,4,5" --mode stats
-  skills run advanced-math -- "10,20,30" --mode stats --stats mean,median
-
-MATRIX MODE:
-  skills run advanced-math -- "[[1,2],[3,4]]" --mode matrix --matrix determinant
-  skills run advanced-math -- "[[4,7],[2,6]]" --mode matrix --matrix inverse
-
-CONVERT MODE:
-  skills run advanced-math -- "100" --mode convert --from celsius --to fahrenheit
-  skills run advanced-math -- "1" --mode convert --from kilometer --to mile
-
-FINANCE MODE:
-  skills run advanced-math -- --mode finance --finance compound --principal 1000 --rate 5 --years 10
-  skills run advanced-math -- --mode finance --finance pmt --principal 200000 --rate 4.5 --years 30
-
-SYMBOLIC MODE (requires OPENAI_API_KEY):
-  skills run advanced-math -- "x^2 + 3*x" --mode symbolic --operation derivative --var x
-  skills run advanced-math -- "2*x + 3" --mode symbolic --operation integral --show-steps
-
-For full documentation, see SKILL.md
-`);
-    process.exit(0);
-  }
-
-  const input = positionals.join(" ");
-  const mode = values.mode as Mode;
-  const precision = parseInt(values.precision as string);
-
-  if (isNaN(precision) || precision < 0 || precision > 100) {
-    log("Error: Precision must be a number between 0 and 100", "error");
-    process.exit(1);
-  }
-
-  return {
-    input,
-    mode,
-    precision,
-    positionals,
-    options: {
-      mode,
-      precision,
-      format: values.format as NumberFormat,
-      output: values.output as OutputFormat,
-      showSteps: values["show-steps"] as boolean,
-      stats: values.stats as string,
-      matrix: values.matrix as MatrixOperation,
-      from: values.from as string,
-      to: values.to as string,
-      finance: values.finance as FinanceType,
-      principal: values.principal ? parseFloat(values.principal as string) : undefined,
-      rate: values.rate ? parseFloat(values.rate as string) : undefined,
-      years: values.years ? parseFloat(values.years as string) : undefined,
-      periods: values.periods ? parseFloat(values.periods as string) : undefined,
-      payment: values.payment ? parseFloat(values.payment as string) : undefined,
-      cashflows: values.cashflows as string,
-      operation: values.operation as SymbolicOperation,
-      var: values.var as string,
-    },
-  };
-}

package/skills/advanced-math/src/conversion.ts

@@ -1,90 +0,0 @@
-import { mathConfig } from "./runtime";
-
-// ============================================================================
-// Unit Conversion Mode
-// ============================================================================
-const unitMappings: Record<string, string> = {
-  // Length
-  "meter": "m", "meters": "m", "m": "m",
-  "kilometer": "km", "kilometers": "km", "km": "km",
-  "centimeter": "cm", "centimeters": "cm", "cm": "cm",
-  "millimeter": "mm", "millimeters": "mm", "mm": "mm",
-  "mile": "mile", "miles": "mile",
-  "yard": "yard", "yards": "yard",
-  "foot": "ft", "feet": "ft", "ft": "ft",
-  "inch": "inch", "inches": "inch", "in": "inch",
-
-  // Mass
-  "kilogram": "kg", "kilograms": "kg", "kg": "kg",
-  "gram": "g", "grams": "g", "g": "g",
-  "milligram": "mg", "milligrams": "mg", "mg": "mg",
-  "pound": "lb", "pounds": "lb", "lb": "lb", "lbs": "lb",
-  "ounce": "oz", "ounces": "oz", "oz": "oz",
-  "ton": "ton", "tons": "ton",
-
-  // Time
-  "second": "s", "seconds": "s", "s": "s", "sec": "s",
-  "minute": "min", "minutes": "min", "min": "min",
-  "hour": "hour", "hours": "hour", "hr": "hour", "h": "hour",
-  "day": "day", "days": "day",
-  "week": "week", "weeks": "week",
-  "month": "month", "months": "month",
-  "year": "year", "years": "year", "yr": "year",
-};
-
-export function convertUnit(value: number, from: string, to: string): number {
-  const fromUnit = unitMappings[from.toLowerCase()] || from;
-  const toUnit = unitMappings[to.toLowerCase()] || to;
-
-  // Handle temperature separately (not supported by mathjs unit system)
-  if (["celsius", "fahrenheit", "kelvin"].includes(from.toLowerCase())) {
-    return convertTemperature(value, from.toLowerCase(), to.toLowerCase());
-  }
-
-  // Handle data sizes separately
-  if (["bit", "byte", "kilobyte", "megabyte", "gigabyte", "terabyte", "petabyte"].includes(from.toLowerCase())) {
-    return convertDataSize(value, from.toLowerCase(), to.toLowerCase());
-  }
-
-  try {
-    const result = mathConfig.evaluate(`${value} ${fromUnit} to ${toUnit}`);
-    return Number(result.toNumeric(toUnit));
-  } catch (error) {
-    throw new Error(`Failed to convert ${from} to ${to}: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-
-function convertTemperature(value: number, from: string, to: string): number {
-  let celsius: number;
-
-  // Convert to Celsius first
-  switch (from) {
-    case "celsius": celsius = value; break;
-    case "fahrenheit": celsius = (value - 32) * 5 / 9; break;
-    case "kelvin": celsius = value - 273.15; break;
-    default: throw new Error(`Unknown temperature unit: ${from}`);
-  }
-
-  // Convert from Celsius to target
-  switch (to) {
-    case "celsius": return celsius;
-    case "fahrenheit": return celsius * 9 / 5 + 32;
-    case "kelvin": return celsius + 273.15;
-    default: throw new Error(`Unknown temperature unit: ${to}`);
-  }
-}
-
-function convertDataSize(value: number, from: string, to: string): number {
-  const bytes: Record<string, number> = {
-    "bit": 0.125,
-    "byte": 1,
-    "kilobyte": 1024,
-    "megabyte": 1024 ** 2,
-    "gigabyte": 1024 ** 3,
-    "terabyte": 1024 ** 4,
-    "petabyte": 1024 ** 5,
-  };
-
-  const valueInBytes = value * bytes[from];
-  return valueInBytes / bytes[to];
-}

package/skills/advanced-math/src/finance.ts

@@ -1,75 +0,0 @@
-import type { FinanceType, MathOptions } from "./types";
-
-// ============================================================================
-// Finance Mode
-// ============================================================================
-export function calculateFinance(type: FinanceType, options: MathOptions): number {
-  const { principal = 0, rate = 0, years = 0, periods, payment = 0, cashflows } = options;
-  const r = rate / 100; // Convert percentage to decimal
-
-  switch (type) {
-    case "compound":
-      // FV = PV * (1 + r)^n
-      const n = periods || years;
-      return principal * Math.pow(1 + r, n);
-
-    case "simple":
-      // FV = PV * (1 + r*n)
-      return principal * (1 + r * years);
-
-    case "npv":
-      // NPV = sum(CF_t / (1+r)^t)
-      if (!cashflows) throw new Error("Cash flows required for NPV");
-      const flows = cashflows.split(",").map(Number);
-      return flows.reduce((npv, cf, t) => npv + cf / Math.pow(1 + r, t), 0);
-
-    case "irr":
-      // IRR calculation using Newton-Raphson method
-      if (!cashflows) throw new Error("Cash flows required for IRR");
-      return calculateIRR(cashflows.split(",").map(Number));
-
-    case "pmt":
-      // PMT = PV * (r * (1+r)^n) / ((1+r)^n - 1)
-      const monthlyRate = r / 12;
-      const numPayments = years * 12;
-      return principal * (monthlyRate * Math.pow(1 + monthlyRate, numPayments)) /
-             (Math.pow(1 + monthlyRate, numPayments) - 1);
-
-    case "fv":
-      // Future Value = PV * (1 + r)^n
-      return principal * Math.pow(1 + r, years);
-
-    case "pv":
-      // Present Value = FV / (1 + r)^n
-      return payment / Math.pow(1 + r, years);
-
-    default:
-      throw new Error(`Unknown finance type: ${type}`);
-  }
-}
-
-function calculateIRR(cashflows: number[], guess: number = 0.1): number {
-  const maxIterations = 100;
-  const tolerance = 0.0001;
-  let rate = guess;
-
-  for (let i = 0; i < maxIterations; i++) {
-    let npv = 0;
-    let dnpv = 0;
-
-    for (let t = 0; t < cashflows.length; t++) {
-      npv += cashflows[t] / Math.pow(1 + rate, t);
-      dnpv -= t * cashflows[t] / Math.pow(1 + rate, t + 1);
-    }
-
-    const newRate = rate - npv / dnpv;
-
-    if (Math.abs(newRate - rate) < tolerance) {
-      return newRate * 100; // Return as percentage
-    }
-
-    rate = newRate;
-  }
-
-  throw new Error("IRR did not converge");
-}

package/skills/advanced-math/src/formatting.ts

@@ -1,95 +0,0 @@
-import { mathConfig } from "./runtime";
-import type { MathOptions, NumberFormat, Result } from "./types";
-
-// ============================================================================
-// Formatting Functions
-// ============================================================================
-export function formatNumber(value: any, format: NumberFormat, precision: number): string {
-  // Convert mathjs BigNumber to regular number
-  let num: number;
-  if (value && typeof value === "object" && "toNumber" in value) {
-    num = value.toNumber();
-  } else if (typeof value === "number") {
-    num = value;
-  } else {
-    num = Number(value);
-  }
-
-  switch (format) {
-    case "scientific":
-      return num.toExponential(precision);
-
-    case "fraction":
-      return mathConfig.format(mathConfig.fraction(num), { precision });
-
-    case "percentage":
-      return (num * 100).toFixed(precision) + "%";
-
-    case "number":
-    default:
-      return num.toFixed(precision);
-  }
-}
-
-export function formatResult(result: Result, options: MathOptions): string {
-  // Helper to convert BigNumber to string
-  const toString = (val: any): string => {
-    if (val && typeof val === "object" && "toString" in val) {
-      return val.toString();
-    }
-    return String(val);
-  };
-
-  if (options.output === "json") {
-    // Convert BigNumbers to strings for JSON
-    const jsonResult = JSON.parse(JSON.stringify(result, (key, value) => {
-      if (value && typeof value === "object" && "toString" in value) {
-        return value.toString();
-      }
-      return value;
-    }));
-    return JSON.stringify(jsonResult, null, 2);
-  }
-
-  if (options.output === "latex" && result.latex) {
-    return result.latex;
-  }
-
-  // Text format
-  let output = `\n${"=".repeat(80)}\n`;
-  output += `  Advanced Math - ${result.mode.toUpperCase()} Mode\n`;
-  output += `${"=".repeat(80)}\n\n`;
-
-  output += `Input: ${Array.isArray(result.input) ? result.input.join(", ") : result.input}\n\n`;
-
-  if (typeof result.output === "object" && !Array.isArray(result.output) && result.output !== null && !("toNumber" in result.output)) {
-    output += "Results:\n";
-    for (const [key, value] of Object.entries(result.output)) {
-      if (typeof value === "object" && value !== null && !("toNumber" in value)) {
-        output += `  ${key}:\n`;
-        for (const [k, v] of Object.entries(value as any)) {
-          output += `    ${k}: ${toString(v)}\n`;
-        }
-      } else {
-        output += `  ${key}: ${toString(value)}\n`;
-      }
-    }
-  } else {
-    output += `Result: ${result.formatted || toString(result.output)}\n`;
-  }
-
-  if (result.steps && result.steps.length > 0) {
-    output += "\nSteps:\n";
-    result.steps.forEach((step, i) => {
-      output += `  ${i + 1}. ${step}\n`;
-    });
-  }
-
-  if (result.latex) {
-    output += `\nLaTeX: ${result.latex}\n`;
-  }
-
-  output += `\n${"=".repeat(80)}\n`;
-
-  return output;
-}

package/skills/advanced-math/src/index.ts

@@ -1,133 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Advanced Math Skill
- * Performs advanced mathematical calculations, symbolic math, and numerical analysis.
- */
-
-import { writeFileSync } from "fs";
-import { join } from "path";
-import {
-  calculateStatistics,
-  evaluateExpression,
-  performMatrixOperation,
-} from "./calculators";
-import { parseMathCli } from "./cli";
-import { convertUnit } from "./conversion";
-import { calculateFinance } from "./finance";
-import { formatNumber, formatResult } from "./formatting";
-import { EXPORTS_DIR, SESSION_ID, ensureDir, log, mathConfig } from "./runtime";
-import { performSymbolicMath } from "./symbolic";
-import type { Result } from "./types";
-
-async function main() {
-  const { input, mode, precision, options, positionals } = parseMathCli();
-
-  try {
-    log(`Session ID: ${SESSION_ID}`);
-    log(`Mode: ${mode}`);
-
-    let result: Result;
-
-    switch (mode) {
-      case "calc": {
-        if (!input) throw new Error("Expression required for calc mode");
-        const output = evaluateExpression(input, precision);
-        const formatted = formatNumber(output, options.format, precision);
-        result = { input, mode, output, formatted };
-        break;
-      }
-
-      case "stats": {
-        if (!input) throw new Error("Data required for stats mode");
-        const data = input.split(",").map((value) => parseFloat(value.trim()));
-        if (data.some(isNaN)) throw new Error("Invalid data: must be comma-separated numbers");
-        const output = calculateStatistics(data, options.stats);
-        result = { input, mode, output };
-        break;
-      }
-
-      case "matrix": {
-        if (!input) throw new Error("Matrix required for matrix mode");
-        if (!options.matrix) throw new Error("Matrix operation required (--matrix)");
-
-        let matrices;
-        try {
-          matrices = positionals.map((positional) => JSON.parse(positional));
-        } catch {
-          throw new Error("Invalid matrix format. Use JSON arrays e.g. [[1,2],[3,4]]");
-        }
-        const output = performMatrixOperation(matrices, options.matrix);
-        const formatted = mathConfig.format(output, { precision });
-        result = { input: positionals, mode, output, formatted };
-        break;
-      }
-
-      case "convert": {
-        if (!input) throw new Error("Value required for convert mode");
-        if (!options.from || !options.to) throw new Error("--from and --to units required");
-
-        const value = parseFloat(input);
-        if (isNaN(value)) throw new Error("Invalid value for conversion");
-        const output = convertUnit(value, options.from, options.to);
-        const formatted = formatNumber(output, options.format, precision);
-        result = {
-          input: `${input} ${options.from}`,
-          mode,
-          output,
-          formatted: `${formatted} ${options.to}`,
-        };
-        break;
-      }
-
-      case "finance": {
-        if (!options.finance) throw new Error("Finance type required (--finance)");
-        const output = calculateFinance(options.finance, options);
-        const formatted = formatNumber(output, options.format, precision);
-        result = { input: options.finance, mode, output, formatted };
-        break;
-      }
-
-      case "symbolic": {
-        if (!input) throw new Error("Expression required for symbolic mode");
-        if (!options.operation) throw new Error("Operation required (--operation)");
-
-        const symbolicResult = await performSymbolicMath(
-          input,
-          options.operation,
-          options.var,
-          options.showSteps
-        );
-
-        result = {
-          input,
-          mode,
-          output: symbolicResult.result,
-          steps: symbolicResult.steps,
-          latex: symbolicResult.latex,
-        };
-        break;
-      }
-
-      default:
-        throw new Error(`Unknown mode: ${mode}`);
-    }
-
-    const outputText = formatResult(result, options);
-    console.log(outputText);
-
-    if (options.output === "json" || mode === "stats") {
-      const timestamp = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
-      const outputFile = join(EXPORTS_DIR, `export_${timestamp}_${mode}.json`);
-      ensureDir(EXPORTS_DIR);
-      writeFileSync(outputFile, JSON.stringify(result, null, 2));
-      log(`Results saved to: ${outputFile}`, "success");
-    }
-
-    log("Calculation completed successfully", "success");
-  } catch (error) {
-    log(`Error: ${error instanceof Error ? error.message : "Unknown error"}`, "error");
-    process.exit(1);
-  }
-}
-
-main();

package/skills/advanced-math/src/runtime.ts

@@ -1,49 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { randomUUID } from "crypto";
-import { join } from "path";
-import * as math from "mathjs";
-
-export const SKILL_NAME = "advanced-math";
-export const SESSION_ID = randomUUID().slice(0, 8);
-export const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
-export const EXPORTS_DIR = join(SKILLS_OUTPUT_DIR, "exports", SKILL_NAME);
-export const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
-export const SESSION_TIMESTAMP = new Date()
-  .toISOString()
-  .replace(/[:.]/g, "_")
-  .replace(/-/g, "_")
-  .slice(0, 19)
-  .toLowerCase();
-
-export const mathConfig = math.create(math.all, {
-  number: "BigNumber",
-  precision: 64,
-});
-
-export function ensureDir(dir: string) {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-export function log(message: string, level: "info" | "error" | "success" = "info") {
-  const timestamp = new Date().toISOString();
-  const logFile = join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
-
-  ensureDir(LOGS_DIR);
-
-  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-  appendFileSync(logFile, logEntry);
-
-  const prefixes = {
-    info: "ℹ️ ",
-    error: "❌ ",
-    success: "✅ ",
-  };
-
-  if (level === "error") {
-    console.error(`${prefixes[level]} ${message}`);
-  } else {
-    console.log(`${prefixes[level]} ${message}`);
-  }
-}

package/skills/advanced-math/src/symbolic.ts

@@ -1,110 +0,0 @@
-import { log } from "./runtime";
-import type { SymbolicOperation } from "./types";
-
-// ============================================================================
-// Symbolic Math Mode (Using AI)
-// ============================================================================
-export async function performSymbolicMath(
-  expression: string,
-  operation: SymbolicOperation,
-  variable: string = "x",
-  showSteps: boolean = false
-): Promise<{ result: string; steps?: string[]; latex?: string }> {
-  const apiKey = process.env.OPENAI_API_KEY;
-
-  if (!apiKey) {
-    throw new Error("OPENAI_API_KEY environment variable is required for symbolic math");
-  }
-
-  const prompt = buildSymbolicPrompt(expression, operation, variable, showSteps);
-
-  log(`Performing symbolic ${operation} on: ${expression}`);
-
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model: "gpt-4o-mini",
-      messages: [
-        {
-          role: "system",
-          content: "You are a mathematics expert. Provide accurate symbolic mathematics solutions. Always show your work clearly and provide LaTeX formatting when requested.",
-        },
-        {
-          role: "user",
-          content: prompt,
-        },
-      ],
-      temperature: 0.1,
-    }),
-  });
-
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
-  }
-
-  const data = await response.json();
-  const content = data.choices[0].message.content;
-
-  return parseSymbolicResponse(content, showSteps);
-}
-
-function buildSymbolicPrompt(expr: string, operation: SymbolicOperation, variable: string, showSteps: boolean): string {
-  const basePrompts: Record<SymbolicOperation, string> = {
-    derivative: `Calculate the derivative of the expression "${expr}" with respect to ${variable}.`,
-    integral: `Calculate the indefinite integral of the expression "${expr}" with respect to ${variable}.`,
-    simplify: `Simplify the expression "${expr}".`,
-    factor: `Factor the expression "${expr}".`,
-    expand: `Expand the expression "${expr}".`,
-    solve: `Solve the equation "${expr}" for ${variable}.`,
-  };
-
-  let prompt = basePrompts[operation];
-
-  if (showSteps) {
-    prompt += "\n\nPlease show step-by-step solution with explanations.";
-  }
-
-  prompt += "\n\nFormat your response as follows:";
-  prompt += "\nRESULT: [final answer]";
-
-  if (showSteps) {
-    prompt += "\nSTEPS:";
-    prompt += "\n1. [step 1]";
-    prompt += "\n2. [step 2]";
-    prompt += "\n...";
-  }
-
-  prompt += "\nLATEX: [result in LaTeX format]";
-
-  return prompt;
-}
-
-function parseSymbolicResponse(content: string, showSteps: boolean): { result: string; steps?: string[]; latex?: string } {
-  const resultMatch = content.match(/RESULT:\s*(.+?)(?=\n|$)/i);
-  const latexMatch = content.match(/LATEX:\s*(.+?)(?=\n|$)/i);
-
-  const result: any = {
-    result: resultMatch ? resultMatch[1].trim() : content,
-  };
-
-  if (showSteps) {
-    const stepsMatch = content.match(/STEPS:([\s\S]+?)(?=LATEX:|$)/i);
-    if (stepsMatch) {
-      result.steps = stepsMatch[1]
-        .split("\n")
-        .map(s => s.trim())
-        .filter(s => s && /^\d+\./.test(s));
-    }
-  }
-
-  if (latexMatch) {
-    result.latex = latexMatch[1].trim();
-  }
-
-  return result;
-}