ragtime-cli 0.2.18__py3-none-any.whl → 0.3.1__py3-none-any.whl

src/commands/handoff.md

@@ -1,176 +0,0 @@
----
-description: Save current context to branch memory for session continuity
-allowed-tools: Bash, Read, Write, mcp__ragtime__remember
----
-
-# Save Context for Handoff
-
-Capture the current session's context into the branch's `context.md` so the next session (or another developer) can pick up seamlessly.
-
-The context lives permanently in `.claude/memory/branches/{branch}/context.md` - no cleanup needed.
-
-<!-- ═══════════════════════════════════════════════════════════════════════════
-     CUSTOMIZABLE: Adjust the context template, add project-specific sections,
-     modify the commit message format, etc.
-     ═══════════════════════════════════════════════════════════════════════════ -->
-
-## Step 1: Gather Current State
-
-```bash
-BRANCH=$(git branch --show-current)
-ISSUE_NUM=$(echo "$BRANCH" | grep -oE '[0-9]+' | head -1)
-DEVNAME=$(gh api user --jq '.login' 2>/dev/null || git config user.name | tr ' ' '-' | tr '[:upper:]' '[:lower:]')
-TIMESTAMP=$(date +%Y-%m-%d)
-
-echo "Branch: $BRANCH"
-echo "Issue: #$ISSUE_NUM"
-echo "Developer: $DEVNAME"
-
-# Get recent commits on this branch
-echo ""
-echo "=== Recent Commits ==="
-git log main..HEAD --oneline 2>/dev/null || git log -10 --oneline
-
-# Get current changes
-echo ""
-echo "=== Uncommitted Changes ==="
-git status --short
-```
-
-## Step 2: Summarize Session Context
-
-Based on the conversation, create a summary that includes:
-
-1. **What This Branch Does** - High-level purpose
-2. **Current State** - What's been done, recent commits
-3. **What's Left To Do** - Remaining tasks, in priority order
-4. **Testing Status** - What's been tested, what hasn't
-5. **Known Issues / Lessons Learned** - Gotchas for the next session
-6. **Architecture Decisions** - Why things were done a certain way
-7. **Next Steps** - Specific instructions for resuming
-
-## Step 3: Write to Branch Context
-
-<!-- ═══════════════════════════════════════════════════════════════════════════
-     RAGTIME CORE - DO NOT MODIFY
-     The file path and frontmatter format must match ragtime's expectations.
-     ═══════════════════════════════════════════════════════════════════════════ -->
-
-Write to `.claude/memory/branches/{branch-slug}/context.md`:
-
-```markdown
----
-id: context
-namespace: branch-{branch}
-type: context
-status: active
-added: '{date}'
-author: {devname}
-issue: '#{issue_num}'
----
-
-## Branch: {branch}
-
-### What This Branch Does
-
-{summary}
-
----
-
-## CURRENT STATE (as of {date})
-
-{current state details}
-
----
-
-## WHAT'S LEFT TO DO
-
-{prioritized task list}
-
----
-
-## TESTING STATUS
-
-### Tested and Working:
-{list}
-
-### Not Yet Tested:
-{list}
-
----
-
-## KNOWN ISSUES / LESSONS LEARNED
-
-{numbered list}
-
----
-
-## ARCHITECTURE DECISIONS
-
-{bullet points}
-
----
-
-## NEXT STEPS FOR NEW SESSION
-
-{specific instructions}
-```
-
-<!-- ═══════════════════════════════════════════════════════════════════════════ -->
-
-<!-- CUSTOMIZABLE: Add project-specific sections to the context template -->
-
-## Step 4: Index the Context
-
-After writing the file, ensure it's indexed:
-
-```
-mcp__ragtime__remember:
-  content: "{summary of context for search}"
-  namespace: "branch-{branch}"
-  type: "context"
-  issue: "#{issue_num}"
-  source: "handoff"
-```
-
-## Step 5: Commit and Push
-
-```bash
-BRANCH=$(git branch --show-current)
-BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
-ISSUE_NUM=$(echo "$BRANCH" | grep -oE '[0-9]+' | head -1)
-
-# Block pushes to main/master
-if [ "$BRANCH" = "main" ] || [ "$BRANCH" = "master" ]; then
-  echo "❌ ERROR: Cannot push directly to $BRANCH"
-  exit 1
-fi
-
-git add ".claude/memory/branches/$BRANCH_SLUG/context.md"
-git commit -m "docs(context): update branch context for session continuity
-
-Relates to #$ISSUE_NUM
-
-Co-Authored-By: Claude <noreply@anthropic.com>"
-
-git push -u origin "$BRANCH"
-```
-
-## Step 6: Confirm Handoff Complete
-
-```
-✅ Handoff Complete
-
-- Context saved to: .claude/memory/branches/{branch}/context.md
-- Committed and pushed to remote
-- Ready for next session or another developer
-
-To resume: Start a new session and say "continue on this branch"
-```
-
-## Notes
-
-- The context.md file lives permanently with the branch - no cleanup needed
-- Each `/handoff` overwrites the previous context.md (it's always current state)
-- On `/start`, Claude reads the branch's context.md to resume
-- When syncing from teammate branches, their context.md comes along too

src/commands/import-docs.md

@@ -1,259 +0,0 @@
----
-description: Migrate existing docs into ragtime memory structure with AI-assisted classification
-allowed-arguments: path to docs folder (e.g., /import-docs docs/)
-allowed-tools: Bash, Read, Write, Edit, AskUserQuestion
----
-
-# Import Docs
-
-Analyze an existing docs folder and migrate content into the ragtime memory structure.
-
-**Usage:**
-- `/import-docs docs/` - Analyze docs folder and create memories
-- `/import-docs` - Interactive mode, asks for path
-
-## Overview
-
-This command helps teams that have existing documentation migrate into ragtime's structured memory system. It:
-
-1. Scans all markdown files using `ragtime audit --json`
-2. Analyzes each document's content to classify properly
-3. Determines what should become memories vs. stay as indexed docs
-4. Creates memories in `.ragtime/app/` or `.ragtime/team/` as appropriate
-
-## Step 1: Get the Docs Path
-
-**If `$ARGUMENTS` provided:**
-- Use it as the docs path
-
-**If no arguments:**
-- Ask: "What docs folder should I analyze? (e.g., docs/, documentation/)"
-
-## Step 2: Run Audit
-
-Run the ragtime audit command to get a structured view of all docs:
-
-```bash
-ragtime audit {docs_path} --json
-```
-
-Parse the JSON output to get the list of files and initial suggestions.
-
-## Step 3: Analyze Documents
-
-For each document (or batch), read the content and classify:
-
-### Classification Questions
-
-For each doc, determine:
-
-1. **Is this memory-worthy or just reference?**
-   - Memory-worthy: Contains decisions, patterns, architecture insights, conventions
-   - Reference: API docs, changelogs, auto-generated content, raw specs
-
-2. **What type of knowledge is it?**
-   - `architecture` - How systems/components work
-   - `decision` - Why we chose X over Y (look for "we decided", "because", trade-off discussion)
-   - `convention` - Team rules, coding standards, process docs
-   - `pattern` - Reusable solutions, "how to do X"
-   - `integration` - How external services connect
-   - `feature` - Feature documentation
-
-3. **What namespace?**
-   - `app` - Technical knowledge about this codebase
-   - `team` - Team conventions, process, standards
-
-4. **What component?** (infer from path and content)
-
-5. **Should this doc be split?**
-   - Large docs with multiple distinct sections may become multiple memories
-   - Each memory should be focused on ONE concept
-
-### Classification Hints
-
-Look for signals in the content:
-
-| Signal | Likely Type |
-|--------|-------------|
-| "We decided to..." | decision |
-| "Always do X when Y" | convention |
-| "The {system} works by..." | architecture |
-| "To implement X, follow these steps..." | pattern |
-| "Integrates with {service} via..." | integration |
-| ADR format, numbered decisions | decision |
-| API endpoints, request/response | architecture |
-| Setup instructions, onboarding | convention |
-
-## Step 4: Choose Migration Strategy
-
-Ask the user:
-
-```
-How should I handle the original docs?
-
-1. **Memories only** - Create memories in .ragtime/, leave original docs unchanged
-2. **Frontmatter only** - Add frontmatter to original docs for better indexing, no memories
-3. **Both** - Add frontmatter to originals AND create memories for key insights (recommended)
-```
-
-Based on their choice, adjust what the migration plan includes.
-
-## Step 5: Generate Migration Plan
-
-Create a migration plan based on the user's strategy choice:
-
-```
-## Migration Plan
-
-### Will Add Frontmatter (if strategy includes frontmatter)
-
-| File | Namespace | Type | Component |
-|------|-----------|------|-----------|
-| docs/auth/JWT_DESIGN.md | app | architecture | auth |
-| docs/CODING_STANDARDS.md | team | convention | - |
-| ... | | | |
-
-### Will Create Memories (if strategy includes memories)
-
-| File | Type | Namespace | Component | Notes |
-|------|------|-----------|-----------|-------|
-| docs/auth/JWT_DESIGN.md | architecture | app | auth | Split into 2 memories |
-| docs/CODING_STANDARDS.md | convention | team | - | Full doc |
-| ... | | | | |
-
-### Will Index Only (no memory, just frontmatter or skip)
-
-These stay as searchable docs but don't become memories:
-- docs/CHANGELOG.md (reference)
-- docs/api/endpoints.md (reference, auto-generated)
-- ...
-
-### Will Skip (Z files)
-
-- docs/archive/old-stuff.md (outdated)
-- ...
-```
-
-## Step 6: Get Approval
-
-Present the plan and ask:
-
-```
-I've analyzed {total} docs:
-- {X} will become memories in .ragtime/
-- {Y} will be indexed as reference docs
-- {Z} will be skipped
-
-Review the plan above. Should I:
-1. Proceed with all
-2. Let me adjust some classifications
-3. Show me a specific file's analysis
-4. Cancel
-```
-
-## Step 7: Execute Migration
-
-### If adding frontmatter to originals:
-
-For each doc that needs frontmatter, prepend:
-
-```yaml
----
-namespace: {app|team}
-type: {type}
-component: {if applicable}
----
-```
-
-This makes the original docs index better with `ragtime index`.
-
-### If creating memories:
-
-1. **Extract the key content** - Don't copy the whole doc verbatim unless it's focused. Extract the essential knowledge.
-
-2. **Write the memory file** to `.ragtime/app/{component}/{id}-{slug}.md` or `.ragtime/team/{id}-{slug}.md`:
-
-```yaml
----
-id: {8-char-uuid}
-namespace: {app|team}
-type: {type}
-component: {if applicable}
-confidence: medium
-confidence_reason: import-docs
-source: import-docs
-status: active
-added: {today}
-migrated_from: {original-file-path}
----
-
-{extracted content}
-```
-
-3. **For split documents**, create multiple focused memories with related IDs.
-
-## Step 8: Reindex
-
-After all memories are created:
-
-```bash
-ragtime reindex
-```
-
-## Step 9: Summary
-
-Summarize based on what was done:
-
-```
-## Migration Complete
-
-### Frontmatter Added (if applicable)
-Updated {X} docs with frontmatter for better indexing.
-
-### Memories Created (if applicable)
-Created {Y} memories:
-- {N} architecture in app/
-- {N} conventions in team/
-- {N} decisions in app/
-- ...
-
-Next steps:
-- Run 'ragtime index' to update the search index
-- Review memories with: ragtime memories --namespace app
-- Search with: ragtime search "your query"
-- Edit any misclassified content in .ragtime/ or docs/
-```
-
-## Tips
-
-- **Don't over-migrate**: Not every doc needs to be a memory. Reference docs are fine as indexed content.
-- **Preserve originals**: This creates memories FROM docs, doesn't delete originals.
-- **Review component inference**: The path-based component detection may need adjustment.
-- **Batch by folder**: For large doc sets, consider migrating one folder at a time.
-
-## Example Session
-
-```
-User: /import-docs docs/
-
-Claude: I'll analyze your docs folder...
-
-Running: ragtime audit docs/ --json
-
-Found 45 markdown files. Let me analyze each one...
-
-[Analyzes docs/auth/JWT_DESIGN.md]
-This is an architecture doc about JWT implementation. Key insights:
-- 15-minute access token expiry
-- Refresh token rotation strategy
-- Why we chose asymmetric keys
-
-I'll create 1 memory in app/auth/ for this.
-
-[Continues for other files...]
-
-## Migration Plan
-...
-
-Proceed? (yes/adjust/cancel)
-```

src/commands/pr-graduate.md

@@ -1,192 +0,0 @@
----
-description: Graduate branch knowledge to app after PR merge (fallback)
-allowed-tools: Bash, mcp__ragtime__search, mcp__ragtime__graduate, mcp__ragtime__update_status, mcp__ragtime__remember, AskUserQuestion
----
-
-# PR Graduate: Curate Branch Knowledge (Post-Merge)
-
-> **Preferred workflow:** Use `/create-pr` instead - it graduates memories *before*
-> creating the PR so knowledge is committed alongside code.
->
-> Use this command only if you already merged without graduating.
-
-After a PR is merged, review branch memories and decide what becomes permanent app knowledge.
-
-**This is a human-in-the-loop process** - you curate which memories graduate.
-
-<!-- ═══════════════════════════════════════════════════════════════════════════
-     CUSTOMIZABLE: Adjust the curation workflow, add project-specific
-     graduation criteria, modify the summary format, etc.
-     ═══════════════════════════════════════════════════════════════════════════ -->
-
-## Process Overview
-
-```
-For EACH branch memory:
-
-✅ Graduate → Copy to app namespace with high confidence
-📚 Keep     → Leave in branch (reference/history)
-❌ Abandon  → Mark as abandoned (noise, superseded)
-
-Branch memories are preserved - nothing is deleted.
-```
-
-## Step 1: Get the Branch
-
-```bash
-BRANCH=$(git branch --show-current)
-BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
-ISSUE_NUM=$(echo "$BRANCH" | grep -oE '[0-9]+' | head -1)
-
-echo "Branch: $BRANCH"
-echo "Issue: #$ISSUE_NUM"
-
-# Check if PR was merged
-gh pr list --head "$BRANCH" --state merged --json number,title
-```
-
-## Step 2: Gather Branch Memories
-
-<!-- ═══════════════════════════════════════════════════════════════════════════
-     RAGTIME CORE - DO NOT MODIFY
-     ═══════════════════════════════════════════════════════════════════════════ -->
-
-```
-mcp__ragtime__search:
-  query: "decisions patterns architecture"
-  namespace: "branch-{branch}"
-  limit: 50
-```
-
-<!-- ═══════════════════════════════════════════════════════════════════════════ -->
-
-## Step 3: Present Memories for Curation
-
-Display each memory with options:
-
-```
-───────────────────────────────────────────
-📋 BRANCH MEMORY CURATION
-───────────────────────────────────────────
-
-Branch: {branch}
-Total memories found: {count}
-
-For each memory, choose:
-  ✅ Graduate - Promote to app knowledge (high confidence)
-  📚 Keep - Leave in branch for reference
-  ❌ Abandon - Mark as noise/superseded
-
-───────────────────────────────────────────
-
-**Memory 1 of {count}:**
-
-"{memory content preview - first 200 chars}..."
-
-Type: {type} | Added: {date}
-
-What should happen to this memory?
-1. ✅ Graduate to app
-2. 📚 Keep in branch
-3. ❌ Mark as abandoned
-4. 👀 Show full content
-```
-
-## Step 4: Process Each Memory
-
-<!-- ═══════════════════════════════════════════════════════════════════════════
-     RAGTIME CORE - DO NOT MODIFY
-     ═══════════════════════════════════════════════════════════════════════════ -->
-
-### If ✅ Graduate:
-
-```
-mcp__ragtime__graduate:
-  memory_id: "{id}"
-  confidence: "high"
-```
-
-This creates a copy in `app/` namespace and marks the original as graduated.
-
-### If 📚 Keep:
-
-No action needed - memory stays in branch namespace for reference.
-
-### If ❌ Abandon:
-
-```
-mcp__ragtime__update_status:
-  memory_id: "{id}"
-  status: "abandoned"
-```
-
-<!-- ═══════════════════════════════════════════════════════════════════════════ -->
-
-## Step 5: Handle Context Document
-
-The branch's `context.md` is a full document, not individual memories:
-
-```
-The context.md contains the full development context.
-
-Options:
-1. **Extract key insights** - I'll identify valuable patterns to graduate
-2. **Keep as reference** - Leave it in branch history
-3. **Skip** - Context was just for session continuity
-```
-
-If extracting: Identify the most valuable insights and present for approval before graduating.
-
-## Step 6: Summary
-
-```
-───────────────────────────────────────────
-✅ PR GRADUATION COMPLETE
-───────────────────────────────────────────
-
-Branch: {branch}
-
-Memories processed: {total}
-  ✅ Graduated to app: {count}
-  📚 Kept in branch: {count}
-  ❌ Marked abandoned: {count}
-
-Graduated knowledge now searchable via:
-  /recall {topic} --namespace app
-```
-
-## Quick Mode
-
-For simpler PRs, offer quick mode:
-
-```
-Found {count} branch memories.
-
-Options:
-1. **Review each** - Curate one by one (recommended)
-2. **Quick mode** - I'll propose which to graduate
-3. **Graduate all** - Promote everything
-4. **Keep all** - Leave everything in branch
-```
-
-Quick mode generates a proposal:
-
-```
-## Quick Mode Proposal
-
-**Recommend Graduate:**
-- "Auth uses JWT with 15-min expiry" ← architecture insight
-- "Redis chosen for session storage" ← key decision
-
-**Recommend Keep:**
-- "Debugging: token refresh issue" ← development context
-
-Approve? (yes/edit/review-each)
-```
-
-## Notes
-
-- Branch memories stay forever (history) - only status changes
-- Graduated memories get `source: "pr-graduate"` and high confidence
-- Abandoned memories are excluded from default searches
-- Use `/recall --namespace branch-{name}` to see branch history