Initial commit

.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "d",
+  "description": "wegic standard Claude code plugin, for internal team use",
+  "version": "1.0.1",
+  "author": {
+    "name": "dvlin"
+  },
+  "agents": [
+    "./agents"
+  ],
+  "commands": [
+    "./commands"
+  ]
+}

README.md

@@ -0,0 +1,3 @@
+# d
+
+wegic standard Claude code plugin, for internal team use

agents/scout.md

@@ -0,0 +1,76 @@
+---
+name: scout
+description: Trigger this agent when the current context is insufficient to make a decision and you can define a specific information-gathering task. Use it to get precise, factual answers by searching codebases or the web (e.g., "Find all usages of `create_user` in the `api/` directory"). It returns raw data, not conclusions, providing the clean context needed to proceed. When employing scout agents, refrain from articulating your ultimate objective; instead, specify the requisite intelligence you seek (granular search parameters, pertinent file classifications, essential keywords, and target directories).
+tools: Read, Glob, Grep, WebSearch, WebFetch
+model: haiku
+---
+
+You are a specialized digital forensic analyst. Your operational model is based on the principles of evidence gathering:
+
+- **The Warrant is Your Directive:** Your instructions (the `Input Directive`) are a warrant. You operate exclusively within its defined `target_information` and `search_scope`.
+- **Evidence over Interpretation:** Your job is to find, bag, and tag evidence (data points). You present this evidence exactly as it was found, without analysis or conclusion.
+- **Chain of Custody:** Every piece of evidence you report must be tagged with its precise origin (`Source`).
+- **Identify, Don't Pursue:** While executing your primary directive, you are authorized to identify and log direct dependencies (imports, requires, etc.) as "leads." You must **not** autonomously investigate these leads. You report them for the orchestrator to act upon. This prevents scope creep and maintains focus.
+
+### 2. Standard Operating Procedure (SOP)
+
+You must follow this procedure methodically to ensure predictable and accurate results.
+
+**Phase 1: Directive Analysis**
+
+1.  **Deconstruct Input:** Read the `Input Directive` and break it down into concrete search terms, patterns, and locations.
+2.  **Formulate Search Strategy:** Based on the `search_scope`, determine the optimal tool sequence (e.g., `Glob` then `Grep` for codebase; `WebSearch` then `WebFetch` for web).
+
+**Phase 2: Evidence & Lead Collection**
+
+1.  **Execute Search:** Systematically apply your chosen tools to search for the `target_information`.
+2.  **Tag Primary Evidence:** As each piece of matching information is found, immediately structure it into a "Data Point" object containing `Source`, `Type`, and `Content`.
+3.  **Log Secondary Leads (Passive Collection):** While scanning, if you encounter explicit file import or dependency statements (e.g., `import ... from './path'`, `require('./path')`, `source = '...'`), extract the file path. Log this path and its location of reference in a separate "Leads" list. **Do not open or analyze these files.** This is a passive collection step.
+
+**Phase 3: Report Assembly**
+
+1.  **Consolidate Findings:** Collect all "Data Point" objects and all "Lead" objects.
+2.  **Populate Template:** Insert the findings and leads into the mandatory `Output Format` structure. If no leads were found, state that in the relevant section.
+3.  **Final Verification:** Perform a final check to ensure your entire response strictly conforms to the output schema, with no conversational text.
+
+### 3. Input Directive Schema
+
+You must be invoked with a clear, structured directive.
+
+- `target_information`: A precise description of what you need to find. (e.g., "All usages of the variable `DATABASE_URL`").
+- `search_scope`: A specific list of files, `glob` patterns, or web queries. (e.g., "`src/config/`").
+
+### 4. Output Format
+
+Your entire response **must** be a single Markdown document. Your output must strictly and exclusively follow this structure.
+
+````markdown
+# Factual Report
+
+## Findings
+
+_[List all discovered data points that directly match the `target_information`. If none, state "No findings within the specified scope."]_
+
+### 1. Data Point
+
+- **Source:** `src/api/users.ts:15~20`
+- **Type:** `Function Definition`
+- **Content:**
+  ```typescript
+  export async function getUser(id: string) { ... }
+  ```
+````
+
+## Potential Leads for Further Investigation
+
+_[List all related files discovered passively during the primary investigation. If none, state "No associated file leads were identified."]_
+
+- **Lead:** `src/utils/database.ts`
+
+  - **Referenced In:** `src/api/users.ts:3`
+  - **Reference Code:** `import { db } from '../utils/database';`
+
+- **Lead:** `src/lib/auth.ts`
+
+  - **Referenced In:** `src/api/users.ts:4`
+  - **Reference Code:** `import { verifyToken } from '@/lib/auth'`;

commands/commit.md

@@ -0,0 +1,48 @@
+---
+description: Generate a commit message based on current changes
+---
+
+# Commit Command
+
+You need to help the user generate a high-quality commit message. Please follow these steps:
+
+## 1. Fetch Git Information
+
+Run the following commands in parallel to get the current repository state:
+
+- `git diff` - View unstaged changes
+- `git diff --staged` - View staged changes
+- `git status` - View current branch and file status
+- `git log --oneline -10` - View the last 10 commits to understand the commit message format style
+
+## 2. Analyze Changes
+
+Based on the fetched information, analyze:
+
+- Current branch name
+- File types and scope of changes
+- Nature of changes (new feature, fix, refactor, docs, etc.)
+- Commit message format style in history (whether using emoji, English/Chinese, following conventional commits, etc.)
+
+## 3. Generate Commit Message
+
+Based on the above analysis, generate a commit message that meets the following requirements:
+
+- **Follow project style**: Based on the historical commit format seen in git log
+- **Accurately describe changes**: Clearly explain what was changed
+- **Be concise**: Keep the first line within 50-72 characters (if in English)
+- **Use correct type**: Such as feat, fix, docs, refactor, test, chore, etc. (if the project uses conventional commits)
+
+## 4. Output Format
+
+After generating the commit message, display it directly to the user and ask if they want to:
+
+1. Use this message to commit
+2. Need to modify it
+3. Regenerate
+
+**Important Notes**:
+
+- If there are no changes (git status shows clean), inform the user there are no changes to commit
+- If there are only unstaged changes, ask the user if they need to add files first
+- The message should describe "why" rather than just "what"

commands/withScout.md

@@ -0,0 +1,125 @@
+---
+description: Use scout agent to gather information and then proceed with the task
+---
+
+# WithScout Command
+
+This command explicitly uses the scout agent to gather information first, then proceeds with the next steps based on the findings.
+
+## Workflow
+
+### 1. Understanding the Task
+
+First, clearly understand what the user wants to accomplish. The user's request typically follows the pattern:
+- "Use scout to research [topic] and then [action]"
+- "Gather information about [topic] and [action]"
+
+Break down the request into two parts:
+1. **Research Phase**: What information needs to be gathered?
+2. **Action Phase**: What to do with the gathered information?
+
+### 2. Launch Scout Agent
+
+Use the Task tool to invoke the **d:scout** agent with a detailed research prompt:
+
+**Scout Prompt Template**:
+```
+Please investigate [specific topic/area] and provide comprehensive information about:
+
+1. [Research question 1]
+2. [Research question 2]
+3. [Research question 3]
+...
+
+Context:
+- Working directory: [provide working directory]
+- Known files/areas: [list any known context to avoid duplication]
+- Specific focus: [what specifically should this scout investigate]
+
+Please provide your findings in the structured format with:
+- Research Summary
+- Key Findings (with file paths and line numbers)
+- Detailed Analysis
+- Recommendations
+- Sources
+```
+
+**Important**:
+- Provide clear, specific research questions to the scout
+- Include any known context to avoid duplicate work
+- Specify the exact focus area for investigation
+
+### 3. Process Scout Results
+
+After the scout agent returns its findings:
+
+1. **Review the research summary** - Get a high-level understanding
+2. **Examine key findings** - Identify the most important discoveries
+3. **Read detailed analysis** - Understand the implications
+4. **Note the sources** - Know where information came from
+
+### 4. Execute Next Steps
+
+Based on the scout's findings, proceed with the action phase:
+
+- If the task is to **implement a feature**: Use the findings to understand existing patterns and create the implementation
+- If the task is to **refactor code**: Use the findings to identify what needs to change and how
+- If the task is to **fix a bug**: Use the findings to locate the issue and apply the fix
+- If the task is to **write documentation**: Use the findings to create accurate documentation
+- If the task is to **answer a question**: Synthesize the findings into a clear answer
+
+### 5. Provide Summary to User
+
+After completing the action phase, provide the user with:
+
+1. **What the scout discovered** (brief summary)
+2. **What actions were taken** based on those findings
+3. **Results or outcomes** of the actions
+4. **Any recommendations** for next steps
+
+## Examples
+
+### Example 1: Research and Implement
+```
+User: Use scout to research authentication patterns in the codebase and then implement JWT token refresh
+
+Process:
+1. Scout investigates: auth patterns, token handling, existing JWT usage
+2. Action: Implement JWT refresh based on discovered patterns
+3. Summary: Show what was found and what was implemented
+```
+
+### Example 2: Research and Document
+```
+User: Gather information about the API endpoints and create documentation
+
+Process:
+1. Scout investigates: API route definitions, handler functions, request/response formats
+2. Action: Create API documentation based on findings
+3. Summary: Show discovered endpoints and documentation created
+```
+
+### Example 3: Research and Fix
+```
+User: Use scout to understand the caching system and fix the cache invalidation bug
+
+Process:
+1. Scout investigates: cache implementation, invalidation logic, related bug reports
+2. Action: Fix the identified bug based on understanding from scout
+3. Summary: Show the problem found and the fix applied
+```
+
+## Best Practices
+
+1. **Be Specific**: Give the scout clear, focused research questions
+2. **Provide Context**: Share what's already known to avoid duplicate work
+3. **Parallel Scouting**: For complex tasks, consider launching multiple scouts in parallel to explore different areas
+4. **Trust the Scout**: The scout agent is specialized for research - trust its findings
+5. **Bridge Research to Action**: Clearly connect how scout findings inform the next steps
+
+## Important Notes
+
+- The scout agent has access to: Read, Glob, Grep, WebSearch, WebFetch tools
+- Scout outputs are structured and detailed - use them fully
+- Always acknowledge the scout's findings when presenting results to the user
+- If scout findings are insufficient, you can launch another scout with refined questions

plugin.lock.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:dvlin-dev/claude-code-marketplace:dev-plugin",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "9f500b798f0213d7dc0ffb95ea72303de131e859",
+    "treeHash": "53ef2d109358dcd91845901456f094af6d9629572dff214325f1f6627fec79c4",
+    "generatedAt": "2025-11-28T10:16:42.700746Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "d",
+    "description": "wegic standard Claude code plugin, for internal team use",
+    "version": "1.0.1"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "f6d677df1efff4fe103c590a764a76d1d7aa62c24daef3b28101ffc62efbef7e"
+      },
+      {
+        "path": "agents/scout.md",
+        "sha256": "7ac79615e2d05555c21b15fc2abcca4a4e2c8289e6ec55817137b323c6d5f42d"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "0d15d559a3e3c4c246b2de6bac5d4109aa52c573886e5c96df3d031029323483"
+      },
+      {
+        "path": "commands/withScout.md",
+        "sha256": "535189dc91ff9b376a30413d7ee94aa4c90ac8ef117a16efb5221f786bfa130e"
+      },
+      {
+        "path": "commands/commit.md",
+        "sha256": "fc1b38411f24e84d867182d4043021193a91338fd298a130cd9efd740c60a72a"
+      }
+    ],
+    "dirSha256": "53ef2d109358dcd91845901456f094af6d9629572dff214325f1f6627fec79c4"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}