@hasna/skills 0.1.23 → 0.1.24

package/skills/folder-tree/src/index.ts

@@ -0,0 +1,568 @@
+#!/usr/bin/env bun
+
+import * as fs from "fs";
+import * as path from "path";
+import { parseArgs } from "util";
+import ignore from "ignore";
+import { randomUUID } from "crypto";
+
+// Constants
+const SKILL_NAME = "folder-tree";
+const SESSION_ID = randomUUID().slice(0, 8);
+const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || path.join(process.cwd(), ".skills");
+const LOGS_DIR = path.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 (!fs.existsSync(dir)) {
+    fs.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 = path.join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
+  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+  fs.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 TreeNode {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  size?: number;
+  modified?: string;
+  permissions?: string;
+  children?: TreeNode[];
+}
+
+interface TreeOptions {
+  format: "tree" | "json" | "markdown" | "csv";
+  output: string;
+  flat: boolean;
+  include: string[];
+  exclude: string[];
+  useGitignore: boolean;
+  hidden: boolean;
+  dirsOnly: boolean;
+  filesOnly: boolean;
+  depth: number;
+  maxFiles: number;
+  showSize: boolean;
+  showDate: boolean;
+  showPermissions: boolean;
+  showStats: boolean;
+  fullPath: boolean;
+  sort: "name" | "size" | "date" | "type";
+  reverse: boolean;
+  dirsFirst: boolean;
+}
+
+interface Stats {
+  directories: number;
+  files: number;
+  totalSize: number;
+  extensions: Record<string, number>;
+}
+
+// Parse command line arguments
+const { values, positionals } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    format: { type: "string", default: "tree" },
+    output: { type: "string", short: "o" },
+    flat: { type: "boolean", default: false },
+    include: { type: "string" },
+    exclude: { type: "string" },
+    gitignore: { type: "boolean", default: true },
+    hidden: { type: "boolean", default: false },
+    "dirs-only": { type: "boolean", default: false },
+    "files-only": { type: "boolean", default: false },
+    depth: { type: "string" },
+    "max-files": { type: "string", default: "1000" },
+    size: { type: "boolean", default: false },
+    date: { type: "boolean", default: false },
+    permissions: { type: "boolean", default: false },
+    stats: { type: "boolean", default: false },
+    "full-path": { type: "boolean", default: false },
+    sort: { type: "string", default: "name" },
+    reverse: { type: "boolean", default: false },
+    "dirs-first": { type: "boolean", default: true },
+    help: { type: "boolean", short: "h" },
+  },
+  allowPositionals: true,
+});
+
+// Show help
+if (values.help) {
+  console.log(`
+Folder Tree - Generate directory structure visualization
+
+Usage:
+  skills run folder-tree -- <directory> [options]
+
+Format Options:
+  --format <type>       Output: tree, json, markdown, csv (default: tree)
+  -o, --output <path>   Output file path (default: stdout)
+  --flat                Flat list instead of tree (JSON/CSV)
+
+Filter Options:
+  --include <pattern>   Include glob pattern (comma-separated)
+  --exclude <pattern>   Exclude glob pattern (comma-separated)
+  --gitignore           Respect .gitignore (default: true)
+  --hidden              Include hidden files
+  --dirs-only           Show directories only
+  --files-only          Show files only
+
+Depth Options:
+  --depth <n>           Maximum depth (default: unlimited)
+  --max-files <n>       Maximum files to show (default: 1000)
+
+Display Options:
+  --size                Show file sizes
+  --date                Show modification dates
+  --permissions         Show file permissions
+  --stats               Show summary statistics
+  --full-path           Show full paths
+
+Sorting Options:
+  --sort <by>           Sort: name, size, date, type (default: name)
+  --reverse             Reverse sort order
+  --dirs-first          Directories before files (default: true)
+
+Examples:
+  skills run folder-tree -- ./my-project
+  skills run folder-tree -- ./src --format json -o structure.json
+  skills run folder-tree -- . --format markdown --depth 3
+  skills run folder-tree -- . --format csv --size --date
+`);
+  process.exit(0);
+}
+
+// Get input directory
+const inputDir = positionals[0] || ".";
+
+if (!fs.existsSync(inputDir)) {
+  log(`Error: Directory not found: ${inputDir}`, "error");
+  process.exit(1);
+}
+
+if (!fs.statSync(inputDir).isDirectory()) {
+  log(`Error: Not a directory: ${inputDir}`, "error");
+  process.exit(1);
+}
+
+// Build options
+const options: TreeOptions = {
+  format: values.format as TreeOptions["format"],
+  output: (values.output as string) || "",
+  flat: values.flat as boolean,
+  include: values.include ? (values.include as string).split(",").map((p: string) => p.trim()) : [],
+  exclude: values.exclude ? (values.exclude as string).split(",").map((p: string) => p.trim()) : [],
+  useGitignore: values.gitignore as boolean,
+  hidden: values.hidden as boolean,
+  dirsOnly: values["dirs-only"] as boolean,
+  filesOnly: values["files-only"] as boolean,
+  depth: values.depth ? parseInt(values.depth as string) : Infinity,
+  maxFiles: parseInt(values["max-files"] as string) || 1000,
+  showSize: values.size as boolean,
+  showDate: values.date as boolean,
+  showPermissions: values.permissions as boolean,
+  showStats: values.stats as boolean,
+  fullPath: values["full-path"] as boolean,
+  sort: values.sort as TreeOptions["sort"],
+  reverse: values.reverse as boolean,
+  dirsFirst: values["dirs-first"] as boolean,
+};
+
+// Load gitignore
+let gitignoreFilter: ReturnType<typeof ignore> | null = null;
+if (options.useGitignore) {
+  const gitignorePath = path.join(inputDir, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    gitignoreFilter = ignore().add(gitignoreContent);
+  }
+}
+
+// Statistics
+const stats: Stats = {
+  directories: 0,
+  files: 0,
+  totalSize: 0,
+  extensions: {},
+};
+
+let fileCount = 0;
+
+// Check if file matches patterns
+function matchesPattern(name: string, patterns: string[]): boolean {
+  if (patterns.length === 0) return true;
+  return patterns.some((pattern) => {
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+      return regex.test(name);
+    }
+    return name === pattern || name.endsWith(pattern);
+  });
+}
+
+// Check if path should be excluded
+function shouldExclude(relativePath: string, name: string): boolean {
+  // Hidden files
+  if (!options.hidden && name.startsWith(".")) {
+    return true;
+  }
+
+  // Gitignore
+  if (gitignoreFilter && gitignoreFilter.ignores(relativePath)) {
+    return true;
+  }
+
+  // Exclude patterns
+  if (options.exclude.length > 0 && matchesPattern(name, options.exclude)) {
+    return true;
+  }
+
+  return false;
+}
+
+// Check if file should be included
+function shouldInclude(name: string, isDir: boolean): boolean {
+  if (options.dirsOnly && !isDir) return false;
+  if (options.filesOnly && isDir) return false;
+  if (options.include.length > 0 && !isDir && !matchesPattern(name, options.include)) {
+    return false;
+  }
+  return true;
+}
+
+// Get file info
+function getFileInfo(filePath: string): { size: number; modified: string; permissions: string } {
+  const stat = fs.statSync(filePath);
+  return {
+    size: stat.size,
+    modified: stat.mtime.toISOString().split("T")[0],
+    permissions: (stat.mode & 0o777).toString(8),
+  };
+}
+
+// Format file size
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+// Sort nodes
+function sortNodes(nodes: TreeNode[]): TreeNode[] {
+  const sorted = [...nodes].sort((a, b) => {
+    // Dirs first
+    if (options.dirsFirst) {
+      if (a.type === "directory" && b.type === "file") return -1;
+      if (a.type === "file" && b.type === "directory") return 1;
+    }
+
+    // Sort by criteria
+    let comparison = 0;
+    switch (options.sort) {
+      case "size":
+        comparison = (a.size || 0) - (b.size || 0);
+        break;
+      case "date":
+        comparison = (a.modified || "").localeCompare(b.modified || "");
+        break;
+      case "type":
+        const extA = path.extname(a.name);
+        const extB = path.extname(b.name);
+        comparison = extA.localeCompare(extB);
+        break;
+      case "name":
+      default:
+        comparison = a.name.localeCompare(b.name);
+    }
+
+    return options.reverse ? -comparison : comparison;
+  });
+
+  return sorted;
+}
+
+// Build tree
+function buildTree(dirPath: string, relativePath: string = "", currentDepth: number = 0): TreeNode | null {
+  if (currentDepth > options.depth) return null;
+  if (fileCount >= options.maxFiles) return null;
+
+  const name = path.basename(dirPath) || dirPath;
+  const stat = fs.statSync(dirPath);
+  const isDir = stat.isDirectory();
+
+  // Check exclusions
+  if (relativePath && shouldExclude(relativePath, name)) {
+    return null;
+  }
+
+  // Check inclusions
+  if (!shouldInclude(name, isDir)) {
+    return null;
+  }
+
+  const node: TreeNode = {
+    name,
+    path: options.fullPath ? dirPath : relativePath || name,
+    type: isDir ? "directory" : "file",
+  };
+
+  if (options.showSize || options.sort === "size" || options.showStats) {
+    node.size = stat.size;
+  }
+  if (options.showDate || options.sort === "date") {
+    node.modified = stat.mtime.toISOString().split("T")[0];
+  }
+  if (options.showPermissions) {
+    node.permissions = (stat.mode & 0o777).toString(8);
+  }
+
+  if (isDir) {
+    stats.directories++;
+    const children: TreeNode[] = [];
+
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        const entryRelative = relativePath ? `${relativePath}/${entry}` : entry;
+        const childNode = buildTree(entryPath, entryRelative, currentDepth + 1);
+        if (childNode) {
+          children.push(childNode);
+        }
+      }
+    } catch (error) {
+      // Permission denied or other error
+    }
+
+    node.children = sortNodes(children);
+
+    // Calculate directory size
+    if (options.showSize || options.showStats) {
+      node.size = children.reduce((sum, child) => sum + (child.size || 0), 0);
+    }
+  } else {
+    stats.files++;
+    fileCount++;
+    stats.totalSize += stat.size;
+
+    const ext = path.extname(name) || "(no extension)";
+    stats.extensions[ext] = (stats.extensions[ext] || 0) + 1;
+  }
+
+  return node;
+}
+
+// Flatten tree
+function flattenTree(node: TreeNode, result: TreeNode[] = []): TreeNode[] {
+  if (node.type === "file" || !node.children) {
+    result.push({ ...node, children: undefined });
+  } else {
+    if (!options.filesOnly) {
+      result.push({ ...node, children: undefined });
+    }
+    for (const child of node.children) {
+      flattenTree(child, result);
+    }
+  }
+  return result;
+}
+
+// Format as ASCII tree
+function formatTree(node: TreeNode, prefix: string = "", isLast: boolean = true, isRoot: boolean = true): string {
+  let output = "";
+
+  if (isRoot) {
+    output += node.name + "/\n";
+  } else {
+    const connector = isLast ? "└── " : "├── ";
+    let line = prefix + connector + node.name;
+
+    if (node.type === "directory") {
+      line += "/";
+    }
+
+    // Add metadata
+    const meta: string[] = [];
+    if (options.showSize && node.size !== undefined) {
+      meta.push(formatSize(node.size));
+    }
+    if (options.showDate && node.modified) {
+      meta.push(node.modified);
+    }
+    if (options.showPermissions && node.permissions) {
+      meta.push(node.permissions);
+    }
+    if (meta.length > 0) {
+      line += "  (" + meta.join(", ") + ")";
+    }
+
+    output += line + "\n";
+  }
+
+  if (node.children) {
+    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : "│   ");
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      const childIsLast = i === node.children.length - 1;
+      output += formatTree(child, newPrefix, childIsLast, false);
+    }
+  }
+
+  return output;
+}
+
+// Format as JSON
+function formatJson(node: TreeNode): string {
+  if (options.flat) {
+    const flattened = flattenTree(node);
+    return JSON.stringify(flattened, null, 2);
+  }
+  return JSON.stringify(node, null, 2);
+}
+
+// Format as Markdown
+function formatMarkdown(node: TreeNode, depth: number = 0): string {
+  let output = "";
+
+  if (depth === 0) {
+    output += `# Directory Structure\n\n`;
+    output += `## ${node.name}/\n\n`;
+  }
+
+  if (node.children) {
+    for (const child of node.children) {
+      const indent = "  ".repeat(depth);
+      if (child.type === "directory") {
+        output += `${indent}- **${child.name}/**\n`;
+        output += formatMarkdown(child, depth + 1);
+      } else {
+        let line = `${indent}- \`${child.name}\``;
+        if (options.showSize && child.size !== undefined) {
+          line += ` (${formatSize(child.size)})`;
+        }
+        output += line + "\n";
+      }
+    }
+  }
+
+  return output;
+}
+
+// Format as CSV
+function formatCsv(node: TreeNode): string {
+  const headers = ["path", "type"];
+  if (options.showSize) headers.push("size");
+  if (options.showDate) headers.push("modified");
+  if (options.showPermissions) headers.push("permissions");
+
+  const flattened = flattenTree(node);
+  const rows = flattened.map((n) => {
+    const row = [n.path, n.type];
+    if (options.showSize) row.push(String(n.size || 0));
+    if (options.showDate) row.push(n.modified || "");
+    if (options.showPermissions) row.push(n.permissions || "");
+    return row.map((v) => `"${v}"`).join(",");
+  });
+
+  return [headers.join(","), ...rows].join("\n");
+}
+
+// Format statistics
+function formatStats(): string {
+  const sortedExts = Object.entries(stats.extensions)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([ext, count]) => `${ext} (${count})`)
+    .join(", ");
+
+  return `
+Statistics:
+  Directories: ${stats.directories}
+  Files: ${stats.files}
+  Total Size: ${formatSize(stats.totalSize)}
+  Extensions: ${sortedExts}
+`;
+}
+
+// Main execution
+async function main(): Promise<void> {
+  log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`, "debug");
+  log(`Scanning: ${path.resolve(inputDir)}`, "debug");
+  log(`Format: ${options.format}`, "debug");
+
+  // Build tree
+  const tree = buildTree(path.resolve(inputDir));
+
+  if (!tree) {
+    log("Error: Could not build tree", "error");
+    process.exit(1);
+  }
+
+  // Format output
+  let output: string;
+  switch (options.format) {
+    case "json":
+      output = formatJson(tree);
+      break;
+    case "markdown":
+      output = formatMarkdown(tree);
+      break;
+    case "csv":
+      output = formatCsv(tree);
+      break;
+    case "tree":
+    default:
+      output = formatTree(tree);
+  }
+
+  // Add statistics
+  if (options.showStats && options.format === "tree") {
+    output += formatStats();
+  }
+
+  // Write output
+  if (options.output) {
+    const outputDir = path.dirname(options.output);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(options.output, output);
+    log(`Output written to: ${options.output}`, "success");
+  } else {
+    console.log(output);
+  }
+
+  // Summary
+  if (options.output || options.showStats) {
+    log(`Directories: ${stats.directories}`, "info");
+    log(`Files: ${stats.files}`, "info");
+    log(`Total Size: ${formatSize(stats.totalSize)}`, "info");
+    if (fileCount >= options.maxFiles) {
+      log(`Note: Output truncated at ${options.maxFiles} files`, "warn");
+    }
+  }
+}
+
+main().catch((error) => {
+  log(`Error: ${error.message}`, "error");
+  process.exit(1);
+});

package/skills/forecast-scenario-lab/CLAUDE.md

@@ -0,0 +1,19 @@
+# forecast-scenario-lab
+
+Forecast Scenario Lab skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+forecast-scenario-lab run
+```
+
+## Data Directory
+
+~/.skill/forecast-scenario-lab/

package/skills/forecast-scenario-lab/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "forecast-scenario-lab",
+  "version": "0.1.0",
+  "description": "Forecast Scenario Lab skill",
+  "type": "module",
+  "bin": {
+    "forecast-scenario-lab": "./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"
+  ]
+}