@hasna/skills 0.0.2

package/skills/skill-schedule/src/skill-install.ts

@@ -0,0 +1,205 @@
+/**
+ * Skill Installation Handler
+ *
+ * Add this code to your skill's index.ts to enable:
+ *   skill-[name] install claude
+ *   skill-[name] install codex
+ *   skill-[name] uninstall claude
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+interface SkillMeta {
+  name: string;
+  description: string;
+  version: string;
+  commands: string; // Help text or command list
+  requiredEnvVars?: string[];
+}
+
+export async function handleInstallCommand(meta: SkillMeta, args: string[]): Promise<boolean> {
+  const command = args[0];
+  const assistant = args[1];
+
+  if (command !== 'install' && command !== 'uninstall') {
+    return false; // Not an install command
+  }
+
+  if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+    console.error('❌ Error: Please specify an assistant');
+    console.error('');
+    console.error('Usage:');
+    console.error(`  ${meta.name} install [claude|codex|windsurf|cursor]`);
+    console.error(`  ${meta.name} uninstall [claude|codex|windsurf|cursor]`);
+    console.error('');
+    console.error('Examples:');
+    console.error(`  ${meta.name} install claude`);
+    console.error(`  ${meta.name} install codex`);
+    process.exit(1);
+  }
+
+  if (command === 'install') {
+    await installSkill(meta, assistant);
+  } else {
+    await uninstallSkill(meta, assistant);
+  }
+
+  return true;
+}
+
+async function installSkill(meta: SkillMeta, assistant: string): Promise<void> {
+  console.log(`📦 Installing ${meta.name} for ${assistant}...`);
+  console.log('');
+
+  const assistantPaths: Record<string, string> = {
+    claude: '.claude/skills',
+    codex: '.codex/skills',
+    windsurf: '.windsurf/skills',
+    cursor: '.cursor/skills',
+  };
+
+  const skillDir = join(homedir(), assistantPaths[assistant], meta.name);
+  mkdirSync(skillDir, { recursive: true });
+  console.log(`✓ Created: ${skillDir}`);
+
+  // Generate SKILL.md
+  const skillMd = generateSkillMd(meta);
+  writeFileSync(join(skillDir, 'SKILL.md'), skillMd);
+  console.log(`✓ Created: SKILL.md`);
+
+  // Generate README.md
+  const readme = generateReadme(meta);
+  writeFileSync(join(skillDir, 'README.md'), readme);
+  console.log(`✓ Created: README.md`);
+
+  // Create log file
+  const logFile = join(skillDir, `${meta.name}.log`);
+  if (!existsSync(logFile)) {
+    writeFileSync(logFile, `# ${meta.name} execution log\n# Created: ${new Date().toISOString()}\n\n`);
+    console.log(`✓ Created: ${meta.name}.log`);
+  }
+
+  console.log('');
+  console.log(`✅ ${meta.name} installed successfully!`);
+  console.log('');
+  console.log('Location:', skillDir);
+  console.log('');
+  console.log('Files created:');
+  console.log('  - SKILL.md (documentation)');
+  console.log('  - README.md (quick reference)');
+  console.log(`  - ${meta.name}.log (execution logs)`);
+}
+
+async function uninstallSkill(meta: SkillMeta, assistant: string): Promise<void> {
+  console.log(`🗑️  Uninstalling ${meta.name} from ${assistant}...`);
+  console.log('');
+
+  const assistantPaths: Record<string, string> = {
+    claude: '.claude/skills',
+    codex: '.codex/skills',
+    windsurf: '.windsurf/skills',
+    cursor: '.cursor/skills',
+  };
+
+  const skillDir = join(homedir(), assistantPaths[assistant], meta.name);
+
+  if (existsSync(skillDir)) {
+    console.log(`⚠️  Directory preserved: ${skillDir}`);
+    console.log('   (contains logs and configuration)');
+    console.log('   Delete manually if needed:');
+    console.log(`   rm -rf ${skillDir}`);
+  } else {
+    console.log(`✓ ${meta.name} is not installed for ${assistant}`);
+  }
+}
+
+function generateSkillMd(meta: SkillMeta): string {
+  // Extract skill type from name (e.g., "skill-audio" -> "audio")
+  const skillType = meta.name.replace('skill-', '');
+
+  // Create gerund form for description trigger (e.g., "audio" -> "generating audio")
+  const gerundForms: Record<string, string> = {
+    audio: 'generating audio',
+    image: 'generating images',
+    video: 'generating videos',
+    browse: 'browsing websites',
+    codefix: 'fixing code',
+    convert: 'converting files',
+    deploy: 'deploying applications',
+    emoji: 'generating emojis',
+    extract: 'extracting data',
+    transcript: 'transcribing audio',
+    transform: 'transforming data',
+    write: 'writing content',
+  };
+
+  const gerund = gerundForms[skillType] || `using ${skillType}`;
+
+  // Enhanced description with usage triggers
+  const enhancedDesc = `${meta.description}. Use when ${gerund} or when the user mentions ${skillType}.`;
+
+  const envSection = meta.requiredEnvVars?.length ? `
+
+## Environment Variables
+
+${meta.requiredEnvVars.map(v => `- \`${v}\``).join('\n')}
+
+Add to your \`~/.zshrc\` or \`~/.bashrc\`:
+\`\`\`bash
+${meta.requiredEnvVars.map(v => `export ${v}=your_key_here`).join('\n')}
+\`\`\`
+` : '';
+
+  return `---
+name: ${meta.name}
+description: ${enhancedDesc}
+---
+
+# ${meta.name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+${meta.description}
+
+## Quick Start
+
+\`\`\`bash
+${meta.commands}
+\`\`\`
+
+## Version
+
+${meta.version}${envSection}
+
+## Installation
+
+Installed at: \`~/.claude/skills/${meta.name}/\`
+
+## Logs
+
+Execution logs: \`~/.claude/skills/${meta.name}/${meta.name}.log\`
+
+## Support
+
+For issues, see the project repository.
+`;
+}
+
+function generateReadme(meta: SkillMeta): string {
+  return `# ${meta.name}
+
+${meta.description}
+
+**Version:** ${meta.version}
+
+## Documentation
+
+See [SKILL.md](./SKILL.md) for complete documentation.
+
+## Quick Reference
+
+\`\`\`bash
+${meta.name} --help
+\`\`\`
+`;
+}

package/skills/skill-scholarship-tracker/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-scholarship-tracker
+
+Scholarship Tracker skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-scholarship-tracker run
+```
+
+## Data Directory
+
+~/.skill/skill-scholarship-tracker/

package/skills/skill-scholarship-tracker/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-scholarship-tracker",
+  "version": "0.1.0",
+  "description": "Scholarship Tracker skill",
+  "type": "module",
+  "bin": {
+    "skill-scholarship-tracker": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": ["bin", "src", "tsconfig.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-scholarship-tracker.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-scholarship-tracker/src/index.ts

@@ -0,0 +1,298 @@
+#!/usr/bin/env bun
+/**
+ * skill-scholarship-tracker
+ * Matches students to scholarships and tracks tasks using OpenAI.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "fs";
+import { join, dirname, resolve } from "path";
+
+type OutputFormat = "markdown" | "json";
+
+type ScholarshipTemplate = Record<string, unknown>;
+
+interface SkillOptions {
+  profile: string;
+  student?: string;
+  term?: string;
+  focus?: string;
+  format: OutputFormat;
+  model: string;
+  output?: string;
+  template?: ScholarshipTemplate;
+}
+
+interface OpenAIChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string | null;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SKILL_SLUG = "scholarship-tracker";
+
+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}.txt`);
+
+  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" ? "❌" : "ℹ️";
+    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) || "scholarship-tracker";
+}
+
+function parseJsonTemplate(content: string): ScholarshipTemplate | undefined {
+  try {
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null) {
+      return data as ScholarshipTemplate;
+    }
+  } catch (_error) {
+    // treat as text if parsing fails
+  }
+  return undefined;
+}
+
+function showHelp(): void {
+  console.log(`
+skill-scholarship-tracker - Match students to scholarships and track tasks using AI
+
+Usage:
+  skills run scholarship-tracker -- <profile-file> [options]
+  skills run scholarship-tracker -- --text "<student-profile>" [options]
+
+Options:
+  -h, --help               Show this help message
+  --text <profile>         Inline student profile
+  --student <name>         Student name/identifier
+  --term <period>          Target term (default: upcoming)
+  --focus <area>           Focus area (default: general)
+  --format <type>          Output format: markdown | json (default: markdown)
+  --model <model>          OpenAI model (default: gpt-4o-mini)
+  --output <path>          Custom output file path
+
+Output includes:
+  - Summary
+  - Scholarship opportunities
+  - Eligibility notes
+  - Application tasks
+  - Documentation checklist
+  - Reminders
+
+Examples:
+  skills run scholarship-tracker -- ./student-profile.json --focus "STEM"
+  skills run scholarship-tracker -- --text "Senior, 3.8 GPA, CS major" --term "Fall 2025"
+
+Requirements:
+  OPENAI_API_KEY environment variable must be set.
+`);
+}
+
+function parseOptions(): SkillOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+      text: { type: "string" },
+      student: { type: "string" },
+      term: { type: "string" },
+      focus: { type: "string" },
+      format: { type: "string", default: "markdown" },
+      model: { type: "string", default: "gpt-4o-mini" },
+      output: { type: "string" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  let profile = values.text || "";
+  let template: ScholarshipTemplate | undefined;
+
+  if (!profile && positionals[0]) {
+    const filePath = resolve(positionals[0]);
+    const content = readFileSync(filePath, "utf-8");
+    template = parseJsonTemplate(content);
+    profile = template ? "" : content;
+  }
+
+  if (!profile.trim() && !template) {
+    throw new Error("Provide student profile via file path, JSON template, or --text.");
+  }
+
+  const format: OutputFormat =
+    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
+
+  return {
+    profile,
+    student: values.student,
+    term: values.term,
+    focus: values.focus,
+    format,
+    model: values.model,
+    output: values.output,
+    template,
+  };
+}
+
+function buildPrompt(options: SkillOptions) {
+  const system = `You are a scholarship coach. Recommend relevant opportunities, note eligibility, and build application task trackers. Encourage verification and note sources. Do not guarantee awards or fabricate funding.`;
+
+  const instructions =
+    options.format === "json"
+      ? "Respond in JSON with keys: summary, opportunities, eligibility_notes, tasks, documentation, reminders. Include deadlines (ISO when possible) and required effort estimates."
+      : "Respond in Markdown with sections for Summary, Opportunities, Eligibility Notes, Tasks, Documentation, and Reminders. Include deadlines and verification tips.";
+
+  const payload = {
+    student: options.student || "student",
+    term: options.term || "upcoming",
+    focus: options.focus || "general",
+    profile_excerpt: options.profile.substring(0, 6000),
+    structured_template: options.template,
+  };
+
+  const user = `${instructions}\n\nScholarship context:\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.4,
+    max_tokens: options.format === "json" ? 2100 : 1900,
+  };
+
+  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.focus || "general", options.term || "upcoming"];
+  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 {
+    const options = parseOptions();
+    logger.info("Parsed scholarship profile and options.");
+
+    const { system, user } = buildPrompt(options);
+    logger.info("Constructed scholarship tracking prompt.");
+
+    const content = await callOpenAI(options, system, user);
+    logger.success("Received scholarship tracker from OpenAI.");
+
+    const exportPath = buildExportPath(skillExportsDir, sessionStamp, options);
+    await writeExport(exportPath, content);
+    logger.success(`Saved scholarship tracker to ${exportPath}`);
+
+    console.log("\nPreview:");
+    preview(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/skills/skill-scholarship-tracker/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "bin/**/*"]
+}

package/skills/skill-scientific-figure-check/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-scientific-figure-check
+
+Scientific Figure Check skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-scientific-figure-check run
+```
+
+## Data Directory
+
+~/.skill/skill-scientific-figure-check/

package/skills/skill-scientific-figure-check/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-scientific-figure-check",
+  "version": "0.1.0",
+  "description": "Scientific Figure Check skill",
+  "type": "module",
+  "bin": {
+    "skill-scientific-figure-check": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": ["bin", "src", "tsconfig.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-scientific-figure-check.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-scientific-figure-check/src/index.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+import { parseArgs } from "util";
+import { existsSync, statSync } from "fs";
+import sizeOf from "image-size";
+
+const { values, positionals } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    help: { type: "boolean" },
+  },
+  allowPositionals: true,
+});
+
+if (values.help || positionals.length === 0) {
+  console.log(`
+Scientific Figure Check
+Usage: skills run scientific-figure-check -- <file>
+
+Description:
+  Analyzes image files to check if they meet common journal submission standards.
+`);
+  process.exit(0);
+}
+
+const filePath = positionals[0];
+
+if (!existsSync(filePath)) {
+  console.error(`Error: File not found: ${filePath}`);
+  process.exit(1);
+}
+
+try {
+  const stats = statSync(filePath);
+  const dimensions = sizeOf(filePath);
+  
+  const fileSizeMB = stats.size / (1024 * 1024);
+  const width = dimensions.width || 0;
+  const height = dimensions.height || 0;
+  const type = dimensions.type || "unknown";
+
+  // Heuristics for "Print Quality" (assuming 300 DPI target)
+  // If we don't know physical size, we can only guess based on pixel count.
+  // A 3-inch wide figure at 300 DPI needs 900 pixels.
+  const minWidth = 900; 
+  const minHeight = 900;
+
+  console.log(`
+Figure Analysis Report
+----------------------
+File:   ${filePath}
+Type:   ${type.toUpperCase()}
+Size:   ${fileSizeMB.toFixed(2)} MB
+Pixels: ${width} x ${height}
+
+Checks:
+`);
+
+  // Check Format
+  const validFormats = ["png", "jpg", "jpeg", "tiff", "eps", "pdf"];
+  if (validFormats.includes(type.toLowerCase())) {
+    console.log(`[PASS] Format (${type}) is generally accepted.`);
+  } else {
+    console.log(`[WARN] Format (${type}) might not be accepted. Prefer TIFF, EPS, or high-res PDF/PNG.`);
+  }
+
+  // Check Resolution (Heuristic)
+  if (width >= minWidth && height >= minHeight) {
+    console.log(`[PASS] Dimensions are likely sufficient for print (>3 inches at 300 DPI).`);
+  } else {
+    console.log(`[WARN] Dimensions are small (${width}x${height}). Ensure this provides 300 DPI at print size.`);
+  }
+
+  // Check File Size
+  if (fileSizeMB > 10) {
+    console.log(`[WARN] File size is large (${fileSizeMB.toFixed(2)} MB). Check journal limits.`);
+  } else {
+    console.log(`[PASS] File size is reasonable.`);
+  }
+
+} catch (error) {
+  console.error("Error analyzing image:", error);
+  process.exit(1);
+}