ootk 5.1.1 → 6.0.0-rc.2

package/.claude/PROMPT.md

@@ -0,0 +1,13 @@
+Your role: Staff Engineer for Orbital Object Toolkit (ootk).
+
+Task: Refactor the SignalPath class to support multi-branch signal routing.
+
+Format:
+
+1. Summary of goals
+2. File-by-file change plan
+3. Any new abstractions or interfaces
+4. Risks and mitigations
+5. Ask for confirmation
+
+Wait for my approval before editing files.

package/.claude/hooks/post-tool-use.ts

@@ -0,0 +1,33 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+// Post Tool Use Tracker Hook for Claude Code (Node.js version)
+// Tracks tool usage for debugging and optimization
+
+// Read input from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk: string) => {
+  input += chunk;
+});
+process.stdin.on('end', () => {
+  // Parse tool name (basic extraction, works for most cases)
+  let toolName: string | null = null;
+  try {
+    const match = input.match(/"tool_name":"([^"]*)"/);
+    if (match) toolName = match[1];
+  } catch {
+    // Ignore parsing errors
+  }
+
+  // Log to file (optional - comment out if not needed)
+  const logDir = path.join('.claude', 'logs');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logLine = `${new Date().toISOString().replace('T', ' ').slice(0, 19)} - Tool: ${toolName}\n`;
+  fs.appendFileSync(path.join(logDir, 'tool-usage.log'), logLine);
+
+  // Pass through the input unchanged
+  process.stdout.write(input);
+});
+
+process.stdin.resume();

package/.claude/hooks/user-prompt-submit.ts

@@ -0,0 +1,138 @@
+/**
+ * Skill Activation Prompt Hook for Claude Code
+ * Automatically suggests relevant skills based on user prompts and file context
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+interface SkillRule {
+  autoActivate?: boolean;
+  triggerPatterns?: string[];
+  filePatterns?: string[];
+}
+
+interface SkillRules {
+  [skillName: string]: SkillRule;
+}
+
+interface InputData {
+  prompt: string;
+  openFiles?: string[];
+}
+
+// Read the skill rules configuration
+function loadSkillRules(): SkillRules {
+  const rulesPath = path.join(process.cwd(), '.claude', 'skill-rules.json');
+
+  if (!fs.existsSync(rulesPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(rulesPath, 'utf8')) as SkillRules;
+  } catch (error: any) {
+    console.error(`Error loading skill-rules.json: ${error.message}`);
+    return {};
+  }
+}
+
+// Check if any trigger patterns match the prompt
+function checkTriggerPatterns(prompt: string, patterns: string[]): boolean {
+  if (!patterns || patterns.length === 0) return false;
+
+  const lowerPrompt = prompt.toLowerCase();
+  return patterns.some(pattern => lowerPrompt.includes(pattern.toLowerCase()));
+}
+
+// Check if any file patterns match the open files
+function checkFilePatterns(openFiles: string[], patterns: string[]): boolean {
+  if (!patterns || patterns.length === 0) return false;
+
+  return openFiles.some(file =>
+    patterns.some(pattern => {
+      // Convert glob-like pattern to regex
+      const regexPattern = pattern
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.')
+        .replace(/\./g, '\\.');
+
+      const regex = new RegExp(regexPattern, 'i');
+      return regex.test(file);
+    })
+  );
+}
+
+interface SuggestedSkill {
+  name: string;
+  path: string;
+  reason: string;
+}
+
+// Main hook logic
+function main(): void {
+  try {
+    // Parse input from Claude Code
+    const inputStr = fs.readFileSync(0, 'utf8');
+    const input: InputData = JSON.parse(inputStr);
+    const { prompt, openFiles = [] } = input;
+
+    // Load skill rules
+    const skillRules = loadSkillRules();
+
+    // Check each skill for activation
+    const suggestedSkills: SuggestedSkill[] = [];
+
+    for (const [skillName, rules] of Object.entries(skillRules)) {
+      if (!rules.autoActivate) continue;
+
+      const triggerMatch = checkTriggerPatterns(prompt, rules.triggerPatterns || []);
+      const fileMatch = checkFilePatterns(openFiles, rules.filePatterns || []);
+
+      if (triggerMatch || fileMatch) {
+        const skillPath = path.join('.claude', 'skills', skillName, 'SKILL.md');
+
+        if (fs.existsSync(skillPath)) {
+          suggestedSkills.push({
+            name: skillName,
+            path: skillPath,
+            reason: triggerMatch ? 'keyword match' : 'file context'
+          });
+        }
+      }
+    }
+
+    // Output suggestions
+    if (suggestedSkills.length > 0) {
+      const suggestions = suggestedSkills
+        .map(skill => `- ${skill.name} (${skill.reason})`)
+        .join('\n');
+
+      const message = `\n**Suggested Skills:**\n${suggestions}\n\nWould you like me to use any of these skills?`;
+
+      console.log(
+        JSON.stringify({
+          prompt: prompt + message,
+          openFiles: openFiles
+        })
+      );
+    } else {
+      // No suggestions, return original prompt
+      console.log(JSON.stringify(input));
+    }
+  } catch (error: any) {
+    // On error, return original input
+    console.error(`Hook error: ${error.message}`);
+    try {
+      const inputStr = fs.readFileSync(0, 'utf8');
+      const input: InputData = JSON.parse(inputStr);
+      console.log(JSON.stringify(input));
+    } catch {
+      // If even reading input fails, output empty object
+      console.log(JSON.stringify({}));
+    }
+  }
+}
+
+main();
+

package/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mkdir:*)",
+      "Bash(dir:*)",
+      "Bash(tree /f /a f:irissrc -L 3 -I node_modules 2)",
+      "Bash(NUL)",
+      "Bash(npm test:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/.claude/skill-rules.json

@@ -0,0 +1,11 @@
+{
+  "ootk-dev": {
+    "triggerPatterns": [
+      "refactor"
+    ],
+    "filePatterns": [
+      "src/**/*.ts"
+    ],
+    "autoActivate": true
+  }
+}

package/.claude/skills/ootk-dev/SKILL.md

@@ -0,0 +1,16 @@
+# ootk Developer Guide
+
+## General Structure
+
+- Use ES6 module syntax (`import`/`export`).
+- Prefer named exports for interfaces, types, and constants.
+- Use PascalCase for class names and interfaces.
+- Use camelCase for variables, properties, and methods.
+- Private methods and properties should END with an underscore (e.g., `this.state_` and `this.update_()`).
+
+## Coding Style
+
+- Use explicit type annotations everywhere.
+- Use template literals for dynamic HTML and string formatting.
+- Use private/protected methods for internal logic.
+- Use comments to document interfaces, methods, and important logic.