mindforge-cc 9.0.0 → 10.0.1

package/.claude/commands/mindforge/init-org.md

@@ -1,135 +0,0 @@
----
-description: Set up MindForge at the organisation level — create standardised org-level
----
-
-# MindForge — Init Org Command
-# Usage: /mindforge:init-org [--org-name "Name"] [--update]
-
-## Purpose
-Set up MindForge at the organisation level — create standardised org-level
-context files that are shared across ALL projects in the organisation.
-
-Intended to be run ONCE by a platform engineer or engineering lead.
-Output is committed to a shared `mindforge-org-config` repository
-and distributed to projects as a git submodule or npm package.
-
-## Step 1 — Gather org information
-
-Ask (one question at a time):
-1. "What is your organisation name?"
-2. "Describe what your organisation builds in 1-2 sentences."
-3. "What is your primary tech stack? (describe in plain English)"
-4. "What is your default deployment target? (AWS / GCP / Azure / self-hosted / hybrid)"
-5. "What regulatory frameworks apply to your organisation?"
-   Options: GDPR / HIPAA / SOC 2 / PCI-DSS / ISO 27001 / None / Multiple
-6. "What is your source control platform?" (GitHub / GitLab / Bitbucket / Azure DevOps)
-7. "What is your issue tracker?" (Jira / GitHub Issues / Linear / Azure DevOps / None)
-8. "Who are your Tier 3 compliance approvers? (email addresses, comma-separated)"
-
-## Step 2 — Generate org-level context files
-
-Create (or update with `--update`) these files:
-
-### `.mindforge/org/ORG.md`
-Populated from answers with:
-- Organisation identity and mission
-- Default tech stack with version recommendations
-- Architecture defaults
-- Team conventions
-- Compliance requirements
-
-### `.mindforge/org/CONVENTIONS.md`
-Generate sensible defaults based on the tech stack detected.
-For TypeScript/Node.js stacks: strict TypeScript, ESLint, Conventional Commits
-For Python stacks: ruff, mypy, black formatting
-For Go: standard Go toolchain conventions
-Mark each section clearly: [DEFAULT] or [CUSTOMISE THIS]
-
-### `.mindforge/org/SECURITY.md`
-Generate based on declared compliance frameworks:
-- GDPR → include GDPR-specific policies
-- HIPAA → include PHI handling requirements
-- PCI-DSS → include card data handling policies
-- SOC 2 → include access control requirements
-Mark critical sections: [REVIEW WITH SECURITY TEAM]
-
-### `.mindforge/org/TOOLS.md`
-Generate approved library list based on tech stack.
-Include common forbidden libraries (moment.js, request, etc.)
-Mark: [ADD YOUR APPROVED LIBRARIES]
-
-### `.mindforge/org/integrations/INTEGRATIONS-CONFIG.md`
-Pre-populate based on declared platforms:
-- GitHub → fill GitHub config section
-- Jira → fill Jira config section
-Mark credential fields clearly: [SET VIA ENVIRONMENT VARIABLE]
-
-### `.mindforge/governance/GOVERNANCE-CONFIG.md`
-Pre-populate based on declared approvers and compliance frameworks.
-Higher compliance burden → lower Tier 2/3 thresholds.
-Stricter approval SLAs for HIPAA/PCI-DSS organisations.
-
-## Step 3 — Generate skills recommendation
-
-Based on the tech stack and compliance requirements, recommend skills to install:
-
-```
-Recommended skills for your tech stack:
-
-Core skills (already included — v0.6.0):
-  ✅ security-review, code-quality, api-design, testing-standards, documentation,
-     performance, accessibility, data-privacy, incident-response, database-patterns
-
-Additional skills recommended for your stack:
-  [tech-stack-specific recommendations from registry]
-
-For your compliance requirements:
-  [compliance-specific skill recommendations]
-
-Install all recommendations?
-  yes → npx mindforge-skills install [list]
-  no  → I'll show you the install commands for each
-```
-
-## Step 4 — Create distribution package
-
-Offer to create an org-skills npm package for distributing org-level config:
-
-```
-Create `@your-org/mindforge-config` npm package?
-This package will distribute your org-level MindForge configuration
-to all projects in your organisation via: npx @your-org/mindforge-config
-
-Files included:
-  .mindforge/org/ORG.md
-  .mindforge/org/CONVENTIONS.md
-  .mindforge/org/SECURITY.md
-  .mindforge/org/TOOLS.md
-  .mindforge/org/skills/MANIFEST.md
-  .mindforge/org/integrations/INTEGRATIONS-CONFIG.md (without credentials)
-  .mindforge/governance/GOVERNANCE-CONFIG.md (without credentials)
-```
-
-## Step 5 — Write AUDIT entry and report
-
-```json
-{ "event": "org_initialised", "org_name": "[name]", "compliance_frameworks": [...], "skills_recommended": [...] }
-```
-
-Report:
-```
-✅ MindForge organisation configuration complete.
-
-Files created:
-  .mindforge/org/ORG.md
-  .mindforge/org/CONVENTIONS.md
-  .mindforge/org/SECURITY.md
-  .mindforge/org/TOOLS.md
-  .mindforge/governance/GOVERNANCE-CONFIG.md
-
-Next steps:
-  1. Review each file — look for [CUSTOMISE THIS] markers
-  2. Fill in SECURITY.md with your security team
-  3. Commit to your org's mindforge-config repository
-  4. Share with all projects: npx @your-org/mindforge-config (if you created the package)
-```

package/.claude/commands/mindforge/init-project.md

@@ -1,170 +0,0 @@
----
-description: Initialise a new project under the MindForge framework.
----
-
-Initialise a new project under the MindForge framework.
-
-## Pre-check
-Read `.planning/PROJECT.md`. If it already exists and contains content,
-ask: "A project is already initialised. Do you want to reinitialise? (yes/no)"
-Stop if the user says no.
-
-## Pre-flight Environment Check
-Verify that `CLAUDE.md` exists at the root of the project and `.claude/commands/mindforge/` is populated. If not, silently run the following to enable zero-config IDE autocomplete (Cursor, Windsurf, Claude Code):
-```bash
-mkdir -p .claude/commands/mindforge
-cp -r .agent/mindforge/* .claude/commands/mindforge/ 2>/dev/null || true
-cp -r .agents/workflows/* .claude/commands/mindforge/ 2>/dev/null || true
-cp .agent/CLAUDE.md ./CLAUDE.md 2>/dev/null || true
-cp .agent/CLAUDE.md ./.cursorrules 2>/dev/null || true
-cp .agent/CLAUDE.md ./.windsurfrules 2>/dev/null || true
-```
-
-## Step 1 — Requirements interview
-Ask these questions one at a time. Wait for the full answer before asking the next.
-Do not batch them. Do not rush.
-
-1. "What is this project? Give me a 1-2 sentence description."
-2. "Who is the primary user? Describe them specifically."
-3. "What problem does this solve for them? What is the pain today?"
-4. "What tech stack do you want to use? (Say 'recommend one' if unsure.)"
-   — If they say recommend: ask 3 clarifying questions about team size,
-     deployment environment, and performance requirements. Then recommend
-     a specific stack with brief rationale for each choice.
-5. "What is explicitly NOT in scope for v1? Name at least 3 things."
-6. "What does a successful v1 look like? How will you know it worked?"
-7. "Are there any compliance requirements? (GDPR, HIPAA, SOC2, PCI-DSS, none)"
-
-## Step 2 — Create context files
-
-Write `.planning/PROJECT.md`:
-```markdown
-# [Project Name]
-[One-line description]
-
-## Problem statement
-[From answer 3]
-
-## Target user
-[From answer 2]
-
-## Tech stack
-| Layer      | Choice          | Rationale                      |
-|------------|-----------------|--------------------------------|
-| [layer]    | [technology]    | [why]                          |
-
-## v1 scope — IN
-[Bullet list of what is included]
-
-## v1 scope — OUT (explicitly excluded)
-[Bullet list from answer 5]
-
-## Success criteria
-[From answer 6]
-
-## Compliance
-[From answer 7]
-
-## Initialised
-[ISO 8601 timestamp]
-```
-
-Write `.planning/REQUIREMENTS.md`:
-```markdown
-# Requirements — [Project Name]
-
-## Functional requirements
-| ID    | Requirement              | Acceptance criterion           | Scope |
-|-------|--------------------------|--------------------------------|-------|
-| FR-01 |                          |                                | v1    |
-
-## Non-functional requirements
-| ID     | Category      | Requirement                    | Measure        |
-|--------|---------------|--------------------------------|----------------|
-| NFR-01 | Performance   |                                |                |
-| NFR-02 | Security      |                                |                |
-| NFR-03 | Availability  |                                |                |
-
-## Out of scope
-[Items explicitly excluded from v1]
-```
-
-Write `.planning/STATE.md`:
-```markdown
-# MindForge — Project State
-
-## Status
-Project initialised. No phases started.
-
-## Current phase
-None
-
-## Last completed task
-Project initialisation
-
-## Next action
-Run /mindforge:plan-phase 1 to begin planning Phase 1.
-
-## Decisions made
-- Project scope defined (see PROJECT.md)
-- Tech stack chosen (see PROJECT.md)
-
-## Active blockers
-None
-
-## Last updated
-[ISO 8601 timestamp]
-```
-
-Write `.planning/HANDOFF.json`:
-```json
-{
-  "schema_version": "1.0.0",
-  "project": "[project name]",
-  "phase": null,
-  "plan": null,
-  "plan_step": null,
-  "last_completed_task": {
-    "description": "Project initialisation",
-    "commit_sha": null,
-    "verified": true
-  },
-  "next_task": "Run /mindforge:plan-phase 1",
-  "in_progress": {
-    "file": null,
-    "intent": null,
-    "completed_steps": [],
-    "remaining_steps": []
-  },
-  "blockers": [],
-  "decisions_needed": [],
-  "context_refs": [
-    ".planning/PROJECT.md",
-    ".planning/STATE.md",
-    ".planning/REQUIREMENTS.md"
-  ],
-  "agent_notes": "Fresh project. Read PROJECT.md and REQUIREMENTS.md before planning.",
-  "session_summary": "Project initialised.",
-  "recent_files": [
-    ".planning/PROJECT.md",
-    ".planning/REQUIREMENTS.md",
-    ".planning/STATE.md",
-    ".planning/HANDOFF.json"
-  ],
-  "recent_commits": [],
-  "updated_at": "[ISO 8601 timestamp]",
-  "_warning": "Never store secrets, tokens, or passwords in this file. It is tracked in git."
-}
-```
-
-## Step 3 — Confirm and guide
-Tell the user:
-"✅ MindForge project initialised.
-
-Files created:
-  .planning/PROJECT.md
-  .planning/REQUIREMENTS.md
-  .planning/STATE.md
-  .planning/HANDOFF.json
-
-Next step: Run /mindforge:plan-phase 1 to plan your first phase."

package/.claude/commands/mindforge/install-skill.md

@@ -1,28 +0,0 @@
----
-description: Follow the full installation protocol from .mindforge/distribution/registry-client.md.
----
-
-Follow the full installation protocol from `.mindforge/distribution/registry-client.md`.
-
-Steps:
-1. Resolve package name from skill name.
-2. Check if already installed (skip if same version, offer upgrade if newer).
-3. Fetch from registry (npm or private if --registry specified).
-4. Validate the skill:
-   ```bash
-   node bin/mindforge-cli.js validate-skill ./SKILL.md
-   ```
-5. Run injection guard check (handled by validator).
-6. Install to tier directory:
-   ```bash
-   node bin/mindforge-cli.js install-skill [skill-name] --tier [1|2|3]
-   ```
-7. Register in MANIFEST.md:
-   ```bash
-   node bin/mindforge-cli.js register-skill [skill-name] [version] [tier]
-   ```
-8. Write AUDIT entry:
-   ```bash
-   node bin/mindforge-cli.js audit-skill [skill-name] [version] [tier]
-   ```
-9. Confirm: "Run /mindforge:skills validate to verify installation"

package/.claude/commands/mindforge/learn.md

@@ -1,147 +0,0 @@
----
-description: Convert any knowledge source into a reusable, validated, committed MindForge SKILL.md.
----
-
-# MindForge v2 — Learn Command
-# Usage: /mindforge:learn [url|path|--session|npm:package] [--name skill-name] [--tier project|org|core]
-# Version: v2.0.0-alpha.6
-
-## Purpose
-Convert any knowledge source into a reusable, validated, committed MindForge SKILL.md.
-Feed Claude your documentation and it writes down what it learned — for every future session.
-
-## The insight
-Every developer on your team already knows how Prisma works, how your internal API
-conventions are structured, how your CI pipeline behaves. That knowledge lives in their
-heads and in documentation. `/mindforge:learn` captures it permanently as skills that
-load automatically whenever relevant work begins.
-
-## Usage examples
-
-### Learn from external documentation
-```
-/mindforge:learn https://docs.prisma.io/concepts/components/prisma-schema
-/mindforge:learn https://stripe.com/docs/webhooks
-/mindforge:learn https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html
-```
-→ Fetches the page (with SSRF protection)
-→ Uses Gemini 2.5 Pro (1M context) for large docs, claude-sonnet-4-6 for smaller ones
-→ Extracts 10 patterns + 15-25 trigger keywords
-→ Writes SKILL.md + scores it + presents for approval
-
-### Learn from local documentation
-```
-/mindforge:learn ./docs/api-conventions.md
-/mindforge:learn ./docs/internal/
-/mindforge:learn ./CONTRIBUTING.md
-```
-→ Reads local files directly (no model call for reading, only for analysis)
-→ Perfect for: internal API docs, team conventions, onboarding guides
-
-### Learn from npm package docs
-```
-/mindforge:learn npm:zod
-/mindforge:learn context7:zod
-/mindforge:learn npm:drizzle-orm
-/mindforge:learn context7:drizzle-orm
-```
-→ Fetches README from npm registry or real-time docs from Context7
-→ Extracts patterns from the package documentation
-
-### Learn from current session
-```
-/mindforge:learn --session
-```
-→ Analyses SUMMARY files from the most recent phase
-→ Finds patterns that appeared across 2+ tasks
-→ Generates up to 3 skills from what was learned (focused: quality over quantity)
-→ Does NOT repeat patterns already in the knowledge base
-
-## Flags
-
-### --name [skill-name]
-Override the auto-generated skill name (kebab-case).
-Default: inferred from the URL domain/path or file name.
-Example: `/mindforge:learn ./docs/prisma-patterns.md --name prisma-advanced`
-
-### --tier [project|org|core]
-Where to install the skill (default: project).
-- project: only loads in this project (T3)
-- org: loads in all projects using this org config (T2)
-- core: loads everywhere (T1 — use sparingly)
-
-### --model [model-id]
-Override the model used for analysis.
-Default: RESEARCH_MODEL for large content (>50K chars), EXECUTOR_MODEL for small.
-
-## Output format
-
-```
-📚 Learning from: https://docs.prisma.io/...
-
-  🔍 Fetching content...            done (148K chars)
-  🧠 Extracting patterns (gemini-2.5-pro)...
-  Step 1/3 — Extracting patterns... done (10 patterns)
-  Step 2/3 — Generating triggers... done (22 triggers)
-  Step 3/3 — Writing SKILL.md...    done
-
-📊 Skill Quality Score: 84/100 (Good — can register + publish)
-  trigger_coverage   : 26/30   ✅
-  mandatory_actions  : 21/25   ✅
-  code_examples      : 17/20   ✅
-  self_check         : 12/15   ✅
-  injection_safe     : 10/10   ✅
-  no_placeholders    : 9/10    ✅
-  version_history    : 8/10    ⚠️
-
-Preview (top 3 patterns):
-  1. [CRITICAL] Always define explicit cascade behaviour
-     "Set onDelete on every @relation — never rely on database defaults"
-  2. [HIGH] Use compound indexes for cursor pagination
-     "Always index (createdAt, id) together for reliable cursor pagination"
-  3. [HIGH] Never use String for UUID fields in Prisma schema
-     "Use @id @default(uuid()) with the String type — Prisma handles this"
-
-Triggers (22): prisma schema, schema.prisma, @relation, prisma migrate,
-               @id @default, prisma.findMany, prisma generate, model definition...
-
-Skill file: .mindforge/skills/prisma-schema/SKILL.md
-
-[ y ] Register in project tier and commit
-[ n ] Discard
-[ e ] Edit SKILL.md before registering
-[ p ] Register AND publish to community marketplace (score ≥ 80 ✅)
-```
-
-## After registration
-
-```
-✅ Skill registered: prisma-schema (T3 Project)
-
-  Will auto-load when tasks contain:
-    "prisma schema", "schema.prisma", "@relation", "prisma migrate"...
-
-  Committed: feat(skills): learn prisma-schema from docs.prisma.io
-
-  Next: /mindforge:skills info prisma-schema
-```
-
-## Integration with auto-capture
-When `AUTO_CAPTURE_SKILLS=true` in MINDFORGE.md:
-`/mindforge:learn --session` is called automatically after each phase completion.
-The prompt is shown; if no patterns found, it exits silently (no noise).
-
-## AUDIT entry
-```json
-{
-  "event": "skill_learned",
-  "source_type": "url|local|session|npm",
-  "source": "[url or path]",
-  "skill_name": "prisma-schema",
-  "quality_score": 84,
-  "pattern_count": 10,
-  "trigger_count": 22,
-  "tier": "project",
-  "cost_usd": 0.31
-}
-```

package/.claude/commands/mindforge/learning.md

@@ -1,20 +0,0 @@
----
-description: Consult or initialize the project agentic learning memory - AGENTS_LEARNING.md
----
-
-# /mindforge:learning [init]
-
-Consult the project's persistent engineering memory to avoid past mistakes and follow established best practices.
-
-## Usage
-
-- `/mindforge:learning`: Displays the current learning status and path to the learning file.
-- `/mindforge:learning init`: Initializes a new `AGENTS_LEARNING.md` in the project root if it doesn't already exist.
-
-## Why use this?
-Before starting any significant implementation or refactor, you MUST consult the learning memory. It contains project-specific "Anti-Patterns" to avoid and "Best Practices" that have been proven in this specific system.
-
-## Example
-1. Run `/mindforge:learning` to find where the learning file is.
-2. Read the file to understand recent architectural shifts or discovered failure scenarios.
-3. If the project is new, run `/mindforge:learning init` to scaffold the memory.