beeops 0.1.0

package/skills/bo-self-improver/refs/agent-manager.md

@@ -0,0 +1,61 @@
+# エージェント管理 判定基準
+
+bo-self-improver がエージェントを作成・更新・統合・削除する際の判定基準。
+
+## 新規作成
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| メインコンテキストが溢れる | 大量のファイル読み込みが必要な調査 | 専門エージェントに切り出し |
+| 並行実行が有効 | レビューしながらテスト実行 | 独立エージェント化 |
+| 専門知識が深い | DB最適化、セキュリティ監査 | 専門エージェント化 |
+| 頻出する作業パターンに対応エージェントがない | 利用頻度分析で検出 | 新規作成 |
+
+## 統合・削除
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| agents_used に一度も登場しない | 利用頻度0 | 他エージェントへの統合を検討 |
+| 役割が80%以上重複する2エージェント | A と B がほぼ同じ作業 | 1つに統合 |
+| ギャップ分析で見逃し頻度が高い | 使うべき場面で使われていない | description / 発動タイミングを改善 |
+
+## エージェントとスキルの使い分け
+
+| 種類 | 用途 | 実行方式 |
+|------|------|----------|
+| エージェント（agents/） | 独立コンテキストでの専門作業 | Task tool でサブプロセス実行 |
+| スキル（skills/） | メインコンテキスト内での知識参照 | Skill tool で直接ロード |
+
+**判定**: 「独立コンテキストが必要か？」→ Yes = エージェント、No = スキル
+
+## フォーマット
+
+```markdown
+---
+name: { エージェント名 }
+description: { 1行の説明 }
+tools: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob']
+model: { sonnet or opus }
+---
+
+# {エージェント名}
+
+## 役割
+
+{このエージェントが何をするか}
+
+## 手順
+
+1. ...
+2. ...
+
+## ルール
+
+- ...
+```
+
+## 注意事項
+
+- エージェント名はケバブケース（例: `build-error-resolver`, `code-reviewer`）
+- `tools` は必要最小限に制限する（セキュリティ原則）
+- `model` は作業の複雑さに応じて選択（単純=sonnet, 複雑=opus）

package/skills/bo-self-improver/refs/command-manager.md

@@ -0,0 +1,46 @@
+# コマンド管理 判定基準
+
+bo-self-improver がコマンドを作成・更新・統合・削除する際の判定基準。
+
+## 新規作成
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| log の `patterns` に同手順が3回以上 | 「テスト→ビルド→デプロイ」が繰り返し | コマンド化 |
+| 「〜して」が2回以上登場 | 「テスト実行して」「ビルドチェックして」 | コマンド化を検討 |
+| ユーザーが手順を説明している | 「まずdiffを見て、次にテストして...」 | ワークフローコマンド化 |
+
+## 更新・統合・削除
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| 既存コマンドに足りない手順がある | /check に console.log チェックがない | 既存コマンドを更新 |
+| commands_used に一度も登場しない | 利用頻度0 | 統合・削除を検討 |
+| 80%以上重複する2コマンド | /check と /build が大部分同じ | 1つに統合 |
+
+## コマンドとスキルの使い分け
+
+| 種類 | 用途 | 例 |
+|------|------|----|
+| コマンド（commands/） | ユーザーが `/名前` で直接呼ぶ定型作業 | `/check`, `/commit`, `/review` |
+| スキル（skills/） | 状況に応じて自動発動する専門知識 | `gen-security-checklist`, `proj-ref-task` |
+
+**判定**: 「ユーザーが能動的に呼ぶか？」→ Yes = コマンド、No = スキル
+
+## フォーマット
+
+```markdown
+# コマンドの説明
+
+$ARGUMENTS を使って引数を受け取れる。
+
+## 手順
+
+1. ステップ1
+2. ステップ2
+   ...
+```
+
+## 注意事項
+
+- コマンド名はケバブケース（例: `organize-logs`, `create-pr`）

package/skills/bo-self-improver/refs/skill-manager.md

@@ -0,0 +1,59 @@
+# スキル管理 判定基準
+
+bo-self-improver がスキルを作成・更新・統合・削除する際の判定基準。
+
+## 新規作成
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| 同じ learning/pattern が log に2回以上 | 「sleep → availableFrom 置換」が複数回言及 | 新規スキル作成 |
+| 同じ error+solution が2回以上 | prisma enum 追加漏れが繰り返し | 既存スキルに追記 or 独立スキル作成 |
+| ユーザーが方針転換した | 「N日後は escalation の仕事」→ 設計原則 | 既存スキル（proj-ref-*）に追記 |
+| 新しいライブラリ・API の使い方が蓄積 | Inngest step API の注意点 | `stack-*` に追記 or 新規作成 |
+
+## 統合・削除
+
+| 信号 | 例 | アクション |
+|------|-----|-----------|
+| skills_used に一度も登場しない | 利用頻度0 | 類似スキルへの統合を検討。根拠を記録 |
+| 内容が80%以上重複する2スキル | dev-X と dev-Y がほぼ同じ | 1つに統合し、元を削除 |
+| 内容が実装と乖離 | 記載と実コードが不一致 | 実装に合わせて更新 or 削除 |
+| ギャップ分析で見逃し頻度が高い | 使うべき場面で使われていない | description / 発動条件を改善 |
+| 有効性分析でエラー防止に寄与していない | 使ったのにエラー発生 | チェックリスト項目を追加 |
+
+## 命名規則
+
+3レイヤールール:
+
+| プレフィックス | 対象 |
+|---------------|------|
+| `dev-` | 開発プラクティス・エラー解決・設計 |
+| `review-` | コードレビューチェックリスト |
+| `web-` | UI/UX デザイン・心理学・ツールキット |
+| `meta-` | メタ管理（自己改善・ログ・ルーティング） |
+| `sync-` | 同期（ドキュメント・ナレッジ） |
+| `stack-` | 特定ライブラリ/フレームワーク |
+| `proj-` | 現プロジェクト専用 |
+
+スキル名は `{prefix}-{カテゴリ}-{対象}` の形式（例: `dev-error-resolver`, `review-security`, `web-ui-toolkit`, `stack-inngest`, `proj-ref-task`）。
+
+## フォーマット
+
+```markdown
+---
+name: { スキル名 }
+description: { 1行の説明 }
+argument-hint: { 引数のヒント（任意） }
+---
+
+# {スキル名}
+
+## 内容
+
+{知識・チェックリスト・ガイドライン等}
+```
+
+## 注意事項
+
+- `dev-tool-skill-creator` のフォーマット（SKILL.md + frontmatter）に従う
+- README.md の更新も忘れずに行う

package/skills/bo-self-improver/scripts/analyze.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""Analyze log.jsonl for self-improvement structured reports.
+
+Performs cursor management, diff extraction, frequency tallying, agent gap detection,
+and effectiveness analysis in batch, outputting JSON for the LLM to make improvement decisions.
+
+Usage:
+    python3 analyze.py                    # Auto-detect log path
+    python3 analyze.py --log-base PATH    # Explicit log path
+    python3 analyze.py --update-cursor    # Update cursor after analysis
+"""
+
+import json
+import subprocess
+import sys
+from collections import Counter
+from datetime import date, datetime
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# Log path resolution (delegate to resolve-log-path.py)
+# ---------------------------------------------------------------------------
+
+def _find_resolve_script() -> Path | None:
+    """Find resolve-log-path.py via multiple strategies."""
+    import os
+
+    # Strategy 1: BO_CONTEXTS_DIR env var
+    ctx_dir = os.environ.get("BO_CONTEXTS_DIR")
+    if ctx_dir:
+        candidate = Path(ctx_dir).parent / "hooks" / "resolve-log-path.py"
+        if candidate.exists():
+            return candidate
+
+    # Strategy 2: Relative to this script (package layout)
+    candidate = Path(__file__).resolve().parent.parent.parent / "hooks" / "resolve-log-path.py"
+    if candidate.exists():
+        return candidate
+
+    # Strategy 3: require.resolve
+    try:
+        pkg_dir = subprocess.run(
+            ["node", "-e", "console.log(require.resolve('beeops/package.json').replace('/package.json',''))"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        candidate = Path(pkg_dir) / "hooks" / "resolve-log-path.py"
+        if candidate.exists():
+            return candidate
+    except Exception:
+        pass
+
+    return None
+
+
+def resolve_log_base() -> Path:
+    resolver = _find_resolve_script()
+    if resolver:
+        result = subprocess.run(
+            [sys.executable, str(resolver)],
+            capture_output=True, text=True, check=True
+        )
+        return Path(result.stdout.strip())
+    # Fallback
+    return Path.cwd() / ".claude" / "beeops" / "logs"
+
+
+# ---------------------------------------------------------------------------
+# Step 1: Status check & analysis mode determination
+# ---------------------------------------------------------------------------
+
+def check_status(log_base: Path) -> dict:
+    log_file = log_base / "log.jsonl"
+    cursor_file = log_base / "self-improve/.cursor"
+    last_full_file = log_base / "self-improve/.last-full"
+
+    if not log_file.exists():
+        return {"total": 0, "cursor": 0, "new_lines": 0, "mode": "no_log"}
+
+    total = sum(1 for _ in open(log_file, encoding="utf-8"))
+    cursor = int(cursor_file.read_text().strip()) if cursor_file.exists() else 0
+    new_lines = total - cursor
+
+    if new_lines <= 0:
+        return {"total": total, "cursor": cursor, "new_lines": 0, "mode": "no_new"}
+
+    last_full = last_full_file.read_text().strip() if last_full_file.exists() else "1970-01-01"
+    try:
+        last_full_date = datetime.strptime(last_full, "%Y-%m-%d").date()
+        days_since_full = (date.today() - last_full_date).days
+    except ValueError:
+        days_since_full = 999
+
+    mode = "diff"
+    if new_lines >= 50 or days_since_full >= 5:
+        mode = "diff+full"
+
+    return {
+        "total": total,
+        "cursor": cursor,
+        "new_lines": new_lines,
+        "mode": mode,
+        "last_full": last_full,
+        "days_since_full": days_since_full,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Diff entry extraction
+# ---------------------------------------------------------------------------
+
+def get_diff_entries(log_base: Path, cursor: int) -> list[dict]:
+    """Get new log entries after the cursor."""
+    log_file = log_base / "log.jsonl"
+    entries = []
+    with open(log_file, encoding="utf-8") as f:
+        for i, line in enumerate(f, 1):
+            if i <= cursor:
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Step 2: Frequency analysis
+# ---------------------------------------------------------------------------
+
+def list_resources() -> dict[str, list[str]]:
+    """Get existing resource lists from both global and project locations."""
+    result: dict[str, set[str]] = {"skills": set(), "agents": set(), "commands": set()}
+
+    for base in [Path.home() / ".claude", Path.cwd() / ".claude"]:
+        skills_dir = base / "skills"
+        if skills_dir.exists():
+            for d in skills_dir.iterdir():
+                if d.is_dir() and (d / "SKILL.md").exists():
+                    result["skills"].add(d.name)
+        agents_dir = base / "agents"
+        if agents_dir.exists():
+            for f in agents_dir.glob("*.md"):
+                if f.name != "README.md":
+                    result["agents"].add(f.stem)
+        commands_dir = base / "commands"
+        if commands_dir.exists():
+            for f in commands_dir.glob("*.md"):
+                if f.name != "README.md":
+                    result["commands"].add(f.stem)
+
+    return {k: sorted(v) for k, v in result.items()}
+
+
+def analyze_frequency(entries: list[dict], all_resources: dict) -> dict:
+    """Tally skills_used / agents_used / commands_used in diff logs."""
+    counts: dict[str, Counter] = {
+        "skills": Counter(),
+        "agents": Counter(),
+        "commands": Counter(),
+    }
+
+    for entry in entries:
+        for s in entry.get("skills_used", []):
+            counts["skills"][s] += 1
+        for a in entry.get("agents_used", []):
+            counts["agents"][a] += 1
+        for c in entry.get("commands_used", []):
+            counts["commands"][c] += 1
+
+    def classify(counter: Counter, all_names: list[str]) -> dict:
+        used = set(counter.keys())
+        return {
+            "high": sorted(n for n in used if counter[n] >= 3),
+            "low": sorted(n for n in used if 0 < counter[n] < 3),
+            "unused": sorted(n for n in all_names if n not in used),
+        }
+
+    return {
+        "counts": {k: dict(v.most_common()) for k, v in counts.items()},
+        "classification": {
+            k: classify(counts[k], all_resources[k]) for k in counts
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# Step 3: Agent gap analysis (rule-based)
+# ---------------------------------------------------------------------------
+
+AGENT_RULES = [
+    {
+        "agent": "code-reviewer",
+        "match": lambda e: (
+            "review" in e.get("category", "").lower()
+            or e.get("category", "").lower() in ("implementation", "bugfix")
+        ),
+    },
+    {
+        "agent": "build-error-resolver",
+        "match": lambda e: (
+            bool(e.get("errors"))
+            and any(
+                t in tag
+                for err in e.get("errors", [])
+                for tag in err.get("tags", [])
+                for t in ("build", "type", "prisma", "tsc")
+            )
+        ),
+    },
+    {
+        "agent": "database-reviewer",
+        "match": lambda e: any(
+            "prisma" in c.get("file", "") or "migration" in c.get("file", "")
+            for c in e.get("changes", [])
+        ),
+    },
+    {
+        "agent": "refactor-cleaner",
+        "match": lambda e: "refactor" in e.get("category", "").lower(),
+    },
+    {
+        "agent": "planner",
+        "match": lambda e: (
+            "Phase" in e.get("title", "")
+            or len(e.get("changes", [])) >= 8
+        ),
+    },
+    {
+        "agent": "security-reviewer",
+        "match": lambda e: any(
+            any(kw in c.get("file", "").lower() for kw in ("auth", "security", "rls"))
+            for c in e.get("changes", [])
+        ),
+    },
+]
+
+
+def analyze_agent_gaps(entries: list[dict]) -> dict:
+    """Detect agents that should have been used but weren't."""
+    gaps: Counter = Counter()
+    gap_examples: dict[str, list[str]] = {}
+
+    for entry in entries:
+        actual = set(entry.get("agents_used", []))
+        for rule in AGENT_RULES:
+            if rule["match"](entry) and rule["agent"] not in actual:
+                agent = rule["agent"]
+                gaps[agent] += 1
+                gap_examples.setdefault(agent, [])
+                if len(gap_examples[agent]) < 5:
+                    gap_examples[agent].append(entry.get("title", "?"))
+
+    return {
+        agent: {"missed": count, "examples": gap_examples.get(agent, [])}
+        for agent, count in gaps.most_common()
+    }
+
+
+# ---------------------------------------------------------------------------
+# Step 4: Effectiveness analysis
+# ---------------------------------------------------------------------------
+
+def analyze_effectiveness(entries: list[dict]) -> dict:
+    """Analyze correlation between skill usage and error occurrence."""
+    error_entries = [e for e in entries if e.get("errors")]
+    no_error_entries = [e for e in entries if not e.get("errors")]
+
+    error_tags: Counter = Counter()
+    for entry in error_entries:
+        for err in entry.get("errors", []):
+            for tag in err.get("tags", []):
+                error_tags[tag] += 1
+
+    skills_with_errors: Counter = Counter()
+    for entry in error_entries:
+        for skill in entry.get("skills_used", []):
+            skills_with_errors[skill] += 1
+
+    effective_skills: Counter = Counter()
+    for entry in no_error_entries:
+        for skill in entry.get("skills_used", []):
+            effective_skills[skill] += 1
+
+    return {
+        "total_entries": len(entries),
+        "error_entries": len(error_entries),
+        "repeated_error_tags": {t: c for t, c in error_tags.most_common() if c >= 2},
+        "skills_with_errors": dict(skills_with_errors),
+        "effective_skills": dict(effective_skills),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Cursor update
+# ---------------------------------------------------------------------------
+
+def update_cursor(log_base: Path, total: int, full_analysis: bool):
+    """Write analyzed line number to cursor file."""
+    (log_base / "self-improve").mkdir(parents=True, exist_ok=True)
+    cursor_file = log_base / "self-improve/.cursor"
+    cursor_file.write_text(str(total) + "\n")
+
+    if full_analysis:
+        last_full_file = log_base / "self-improve/.last-full"
+        last_full_file.write_text(date.today().isoformat() + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="log.jsonl self-improvement analysis")
+    parser.add_argument("--log-base", help="Explicit log directory path")
+    parser.add_argument("--update-cursor", action="store_true", help="Update cursor after analysis")
+    args = parser.parse_args()
+
+    log_base = Path(args.log_base) if args.log_base else resolve_log_base()
+    status = check_status(log_base)
+
+    if status["mode"] in ("no_log", "no_new"):
+        print(json.dumps({"status": status}, indent=2, ensure_ascii=False))
+        return
+
+    entries = get_diff_entries(log_base, status["cursor"])
+    all_resources = list_resources()
+
+    result = {
+        "status": status,
+        "frequency": analyze_frequency(entries, all_resources),
+        "all_resources": all_resources,
+        "agent_gaps": analyze_agent_gaps(entries),
+        "effectiveness": analyze_effectiveness(entries),
+        "entries": [
+            {
+                "title": e.get("title"),
+                "category": e.get("category"),
+                "has_errors": bool(e.get("errors")),
+                "skills_used": e.get("skills_used", []),
+                "agents_used": e.get("agents_used", []),
+                "learnings": e.get("learnings", []),
+                "patterns": e.get("patterns", []),
+            }
+            for e in entries
+        ],
+    }
+
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    if args.update_cursor:
+        update_cursor(log_base, status["total"], status["mode"] == "diff+full")
+        print(f"\n# Cursor updated: {status['total']}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/skills/bo-task-decomposer/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: bo-task-decomposer
+description: "Decompose complex tasks into detailed, actionable TODOs. Each TODO is specific enough to be executed from its description alone."
+version: "1.0.0"
+context: fork
+agent: general-purpose
+---
+
+# Task Decomposition
+
+You are a task decomposition assistant. Your goal is to break down complex tasks into detailed, specific TODOs that can be executed independently.
+
+## Core Principle
+
+Each TODO must be **executable from its description alone** — specific, achievable, and completable in a single focused work session.
+
+## Process
+
+### Step 1: Codebase Exploration
+
+Before creating a plan, explore the codebase to build a concrete understanding.
+
+Read and understand:
+- The current task or goal from the conversation context
+- Project context from CLAUDE.md (if present)
+- Relevant code, existing patterns, and affected files
+- Dependencies (libraries, APIs, internal modules)
+
+Build a concrete mental model before proceeding. Never decompose what you haven't explored.
+
+### Step 2: Identify Major Components
+
+Break the overall task into major components:
+- What are the different phases or areas of work?
+- What are the dependencies between components?
+- In what order should they be addressed?
+
+### Step 3: Clarify Unknowns
+
+Before creating detailed TODOs, interview the user to identify and resolve unknowns.
+
+<rules>
+- Use the AskUserQuestion tool for all clarifications
+- Don't ask obvious questions — dig into the hard parts the user might have overlooked
+- Number of questions: 2-4 per round
+- Each question should include 2-4 concrete options with brief pros/cons
+- Continue interviewing until all unknowns affecting the decomposition are resolved
+</rules>
+
+<question_focus>
+- **Scope**: Should X be included in this TODO or split into a separate one?
+- **Approach**: Modify existing code or create new?
+- **Ordering**: Must X complete before Y, or can they run in parallel?
+- **Granularity**: Single TODO or split into subtasks?
+- **Completion criteria**: What does "done" mean for this area of work?
+- **Risk**: Should we add an investigation/spike TODO for uncertain areas?
+</question_focus>
+
+### Step 4: Create Detailed TODOs
+
+For each component, create TODOs using TaskCreate with the following quality criteria:
+
+**Specific**: Clear verbs, exact file paths, concrete function/class names, expected inputs/outputs
+**Achievable**: No external blockers, all necessary information included
+**Small**: Single responsibility, independently verifiable
+
+### Step 5: Write Rich Descriptions
+
+Each TODO description must include:
+
+```
+**What**: [Specific action to perform]
+**Where**: [Exact file paths, function/class names, line ranges]
+**How**: [Implementation approach referencing existing patterns in the codebase]
+**Why**: [Purpose and how it fits into the larger task]
+**Verify**: [Specific verification steps — test commands, expected output, or manual checks]
+```
+
+### Step 6: Set Dependencies
+
+Use TaskUpdate to set `blockedBy` relationships between tasks with ordering requirements. Mark tasks that can run in parallel as independent.
+
+### Step 7: Self-Review
+
+After creating all TODOs, perform a self-review:
+
+1. Check for missing steps or gaps in coverage
+2. Verify correct ordering and dependency relationships
+3. Ensure no TODO is ambiguous or under-specified
+4. Identify risk areas that need spike/exploration tasks
+5. Check for over-decomposition (unnecessary granularity)
+
+If issues are found, update the TODOs accordingly.
+
+### Step 8: Finalize and Return
+
+After the review:
+
+1. Confirm all TODOs are consistent with applied fixes
+2. Return a concise summary to the main context
+
+## Output
+
+Return a concise summary to the main context:
+
+```markdown
+## Task Decomposition Summary
+
+### Original Task
+[Brief description]
+
+### Decomposed TODOs
+1. [TODO 1 title] — [one-line summary]
+2. [TODO 2 title] — [one-line summary]
+...
+
+### Dependencies
+- [TODO X] → [TODO Y] (X must complete before Y)
+
+### Scope
+- Total: N TODOs
+- Parallel execution opportunities: [list of independent groups]
+```
+
+## Important Notes
+
+- **Reference actual code** — Use real file paths, function names, and existing patterns
+- **All TODOs must be verifiable** — Include specific test commands or verification steps
+- **Don't over-decompose** — If something is obviously a single step, keep it as one
+- **Interview proactively** — Don't guess when uncertain