beeops 0.1.4 → 0.1.5

package/skills/bo-self-improver/SKILL.md

@@ -1,145 +0,0 @@
----
-name: bo-self-improver
-description: Analyze accumulated log JSONL to automatically improve skills, commands, and agents. Runs automatically on session exit.
-argument-hint: ["scan" or date]
----
-
-# bo-self-improver: Self-Improvement
-
-Analyze accumulated log JSONL to improve skills, commands, and agents.
-
-## Scan Targets
-
-Resources exist in two layers: global and project. **Scan both.**
-
-| Target | Global (`~/.claude/`) | Project (`.claude/`) |
-|--------|--------------------------|--------------------------|
-| Skills | `~/.claude/skills/` | `.claude/skills/` |
-| Commands | `~/.claude/commands/` | `.claude/commands/` |
-| Agents | `~/.claude/agents/` | `.claude/agents/` |
-
-## Procedure
-
-### 1. Run Analysis Script (Automates Steps 1-4)
-
-```bash
-python3 .claude/skills/bo-self-improver/scripts/analyze.py
-```
-
-The script performs all of the following in batch and outputs JSON:
-- Log path resolution (via `resolve-log-path.py`)
-- Cursor management + analysis mode determination
-- Diff log extraction
-- Resource usage frequency tallying (skills_used / agents_used / commands_used)
-- Rule-based agent gap detection
-- Error-skill correlation analysis (effectiveness)
-
-**Output JSON structure:**
-
-```json
-{
-  "status": { "total", "cursor", "new_lines", "mode" },
-  "frequency": {
-    "counts": { "skills": {}, "agents": {}, "commands": {} },
-    "classification": { "skills": { "high", "low", "unused" }, ... }
-  },
-  "all_resources": { "skills": [], "agents": [], "commands": [] },
-  "agent_gaps": { "agent_name": { "missed": N, "examples": [...] } },
-  "effectiveness": {
-    "total_entries", "error_entries",
-    "repeated_error_tags", "skills_with_errors", "effective_skills"
-  },
-  "entries": [{ "title", "category", "has_errors", "learnings", "patterns" }]
-}
-```
-
-- `status.mode == "no_new"` → "No new logs" — exit
-- `status.mode == "diff+full"` → In addition to diff analysis, also read `$LOG_BASE/self-improve/*.md` for long-term trends
-
-### 2. Skill Gap Analysis (LLM Judgment)
-
-The script only detects rule-based agent gaps. **Skill gaps must be judged by the LLM.**
-
-```
-Procedure:
-1. Review entries in the output JSON
-2. From each entry's category + learnings, infer "which skill should have been used"
-3. Compare with actual skills_used
-4. Tally the gaps
-```
-
-### 3. Reduction Evaluation (LLM Judgment)
-
-Steps 1-2 produce "add/update" candidates, but **evaluate reductions first**. Prioritize reduction over addition.
-
-| Check Item | Criteria | Action |
-|---|---|---|
-| Unused resources | 0 usage in frequency + similar resource exists | Merge or delete |
-| Highly duplicated | Two skills with 80%+ content overlap | Merge into one |
-| Bloated content | 15+ checklist items, or SKILL.md > 200 lines | Remove items / split to references |
-| Out-of-date content | Content doesn't match current code | Update to match or delete section |
-| Verbose description | Description > 2 lines, or repeats common knowledge | Simplify |
-
-**Required output**: Must explicitly state one of:
-- Reduction candidates found → List specific resource names and reduction details
-- No reduction targets → State rationale in one line (e.g., "All skills used within past 2 weeks, no duplicates")
-
-### 4. Execute Resource Improvements (LLM Judgment)
-
-Based on Steps 1-3, improve resources following the reference documents below.
-**Execute reductions (Step 3) before additions/updates.**
-
-| Target | Reference Document | Content |
-|--------|-------------------|---------|
-| Skills | `refs/skill-manager.md` | Creation/merge/deletion criteria, naming rules |
-| Commands | `refs/command-manager.md` | Creation/update/merge/deletion criteria, format |
-| Agents | `refs/agent-manager.md` | Creation/merge/deletion criteria, format |
-
-After executing improvements, record to `log.jsonl` via bo-log-writer. Include creation/update details in the `resources_created` field.
-
-### 5. Update Cursor
-
-```bash
-python3 .claude/skills/bo-self-improver/scripts/analyze.py --update-cursor
-```
-
-### 6. Persist Analysis Results & Record to Log
-
-1. **Persist analysis results**: Save to `$LOG_BASE/self-improve/{YYYY-MM-DD}.md`
-
-```markdown
-# {YYYY-MM-DD} self-improve analysis results
-
-## Analysis Scope
-- Log lines: {cursor+1} to {total} ({new_lines} lines)
-- Mode: diff analysis / diff+full analysis
-
-## Frequency
-| Resource Type | Name | Usage Count | Classification |
-|---|---|---|---|
-
-## Gaps
-| Resource Type | Name | Missed Count | Representative Miss Pattern |
-|---|---|---|---|
-
-## Reduction Evaluation
-| Target Resource | Decision | Rationale |
-|---|---|---|
-
-*Even if no reduction targets, state the rationale*
-
-## Effectiveness
-| Pattern | Details |
-|---|---|
-
-## Improvement Actions Taken
-- ...
-```
-
-2. **Log recording**: Record improvement actions to `log.jsonl` via bo-log-writer skill format.
-
-## Rules
-
-- Execute all creation, update, deletion, merge, and split actions automatically, leaving a log
-- Never delete log JSONL (permanent storage)
-- Do not end with "text edits only". Always execute frequency analysis and duplication analysis, recording results

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

@@ -1,61 +0,0 @@
-# エージェント管理 判定基準
-
-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

@@ -1,46 +0,0 @@
-# コマンド管理 判定基準
-
-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

@@ -1,59 +0,0 @@
-# スキル管理 判定基準
-
-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

@@ -1,359 +0,0 @@
-#!/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()