@damper/cli 0.6.6 → 0.6.7

package/dist/index.js

@@ -5,7 +5,7 @@ import { statusCommand } from './commands/status.js';
 import { cleanupCommand } from './commands/cleanup.js';
 import { setupCommand } from './commands/setup.js';
 import { releaseCommand } from './commands/release.js';
-const VERSION = '0.6.6';
+const VERSION = '0.6.7';
 function showHelp() {
     console.log(`
 ${pc.bold('@damper/cli')} - Agent orchestration for Damper tasks

package/dist/services/context-bootstrap.d.ts

@@ -9,6 +9,16 @@ export interface BootstrapResult {
     taskContextPath: string;
     claudeMdUpdated: boolean;
 }
+export interface SectionBlockIndex {
+    section: string;
+    blocks: Array<{
+        id: string;
+        heading: string | null;
+        level: number;
+        charCount: number;
+    }>;
+    totalChars: number;
+}
 /**
  * Fetch all relevant context from Damper and write local files
  */

package/dist/services/context-bootstrap.js

@@ -6,6 +6,24 @@ import { generateClaudeAppend } from '../templates/CLAUDE_APPEND.md.js';
 const TASK_CONTEXT_FILE = 'TASK_CONTEXT.md';
 const CLAUDE_MD_FILE = 'CLAUDE.md';
 const TASK_SECTION_MARKER = '## Current Task:';
+/**
+ * Fetch block indices for relevant sections.
+ * Only fetches the headings/structure - no content.
+ * The agent will use get_section_block_content to load what it needs.
+ */
+async function fetchBlockIndices(api, relevantSections) {
+    const indices = [];
+    for (const sectionName of relevantSections) {
+        try {
+            const blockIndex = await api.getSectionBlocks(sectionName);
+            indices.push(blockIndex);
+        }
+        catch {
+            console.log(pc.dim(`  Could not fetch blocks for: ${sectionName}`));
+        }
+    }
+    return indices;
+}
 /**
  * Fetch all relevant context from Damper and write local files
  */
@@ -15,26 +33,12 @@ export async function bootstrapContext(options) {
     const task = await api.getTask(taskId);
     console.log(pc.dim('Fetching project context...'));
     const context = await api.getProjectContext(taskId);
-    // Fetch full content of relevant sections
-    const sections = [];
+    // Fetch block indices (not content) for relevant sections
     const relevantSections = context.relevantSections || [];
+    let blockIndices = [];
     if (relevantSections.length > 0) {
-        console.log(pc.dim(`Fetching ${relevantSections.length} relevant context sections...`));
-        for (const sectionName of relevantSections) {
-            try {
-                const result = await api.getContextSection(sectionName);
-                // Handle both single section and glob pattern responses
-                if ('pattern' in result && result.sections) {
-                    sections.push(...result.sections);
-                }
-                else if ('section' in result && 'content' in result) {
-                    sections.push(result);
-                }
-            }
-            catch (err) {
-                console.log(pc.dim(`  Could not fetch section: ${sectionName}`));
-            }
-        }
+        console.log(pc.dim(`Fetching block indices for ${relevantSections.length} relevant sections...`));
+        blockIndices = await fetchBlockIndices(api, relevantSections);
     }
     // Fetch templates
     console.log(pc.dim('Fetching templates...'));
@@ -51,7 +55,7 @@ export async function bootstrapContext(options) {
     const taskContext = generateTaskContext({
         task,
         criticalRules: context.criticalRules || [],
-        sections,
+        blockIndices,
         templates,
         modules,
         damperInstructions: instructions.content,

package/dist/services/damper-api.d.ts

@@ -131,6 +131,27 @@ export declare class DamperApi {
         }>;
         isEmpty: boolean;
     }>;
+    getSectionBlocks(section: string): Promise<{
+        section: string;
+        blocks: Array<{
+            id: string;
+            heading: string | null;
+            level: number;
+            charCount: number;
+        }>;
+        totalChars: number;
+    }>;
+    getSectionBlockContent(section: string, blockIds: string[]): Promise<{
+        section: string;
+        blocks: Array<{
+            id: string;
+            heading: string | null;
+            level: number;
+            content: string;
+            charCount: number;
+        }>;
+        totalChars: number;
+    }>;
     listTemplates(): Promise<{
         templates: Array<{
             name: string;

package/dist/services/damper-api.js

@@ -69,6 +69,16 @@ export class DamperApi {
     async listContextSections() {
         return this.request('GET', '/api/agent/context');
     }
+    // Context Blocks
+    async getSectionBlocks(section) {
+        const encodedSection = encodeURIComponent(section);
+        return this.request('GET', `/api/agent/context/${encodedSection}/blocks`);
+    }
+    async getSectionBlockContent(section, blockIds) {
+        const encodedSection = encodeURIComponent(section);
+        const encodedBlockIds = blockIds.map(id => encodeURIComponent(id)).join(',');
+        return this.request('GET', `/api/agent/context/${encodedSection}/blocks/${encodedBlockIds}`);
+    }
     // Templates
     async listTemplates() {
         return this.request('GET', '/api/agent/templates');
@@ -95,7 +105,10 @@ This project uses Damper MCP for task tracking. **You MUST follow this workflow.
 
 ### At Session Start (MANDATORY)
 1. \`get_project_context\` - **READ THIS FIRST.** Contains architecture, conventions, and critical project info.
-2. \`get_context_section\` - Fetch full content for sections relevant to your task
+2. Load relevant architecture context using blocks (token-efficient):
+   - If TASK_CONTEXT.md has an "Available Architecture Context" section, use \`get_section_block_content(section, blockIds)\` to load only the blocks relevant to your task
+   - Otherwise, use \`get_section_blocks(section)\` to see what's available, then fetch specific blocks
+   - Only fall back to \`get_context_section\` if you need an entire section
 3. \`list_tasks\` - Check for existing tasks to work on
 4. If working on a task: \`start_task\` to lock it
 
@@ -104,6 +117,7 @@ This project uses Damper MCP for task tracking. **You MUST follow this workflow.
 - \`add_note\` for decisions: "Decision: chose X because Y"
 - \`update_subtask\` to mark subtask progress
 - **Follow patterns from project context** - Don't reinvent; use existing conventions
+- When you need architecture context mid-task, use \`get_section_block_content\` to load specific blocks rather than full sections
 
 ### Feedback & Changelog Integration
 - \`link_feedback_to_task\` - Link user feedback IDs to your task (helps track what customer requests led to the feature)

package/dist/templates/CLAUDE_APPEND.md.js

@@ -17,6 +17,12 @@ Read TASK_CONTEXT.md first, then create a plan for user approval. Do NOT write c
 **IMPORTANT**: Read TASK_CONTEXT.md for full task details and architecture context.
 If you feel you've lost context, re-read that file.
 ${planSection}
+**NEVER commit these files** (they are generated by the CLI and gitignored):
+- \`CLAUDE.md\` changes (this task section is temporary)
+- \`TASK_CONTEXT.md\`
+- \`.mcp.json\`
+- \`.claude/settings.local.json\`
+
 **Your responsibilities (via Damper MCP):**
 1. Use \`add_commit\` after each git commit
 2. Use \`add_note\` for important decisions

package/dist/templates/TASK_CONTEXT.md.d.ts

@@ -1,8 +1,9 @@
-import type { TaskDetail, ContextSection, Module } from '../services/damper-api.js';
+import type { TaskDetail, Module } from '../services/damper-api.js';
+import type { SectionBlockIndex } from '../services/context-bootstrap.js';
 interface TaskContextOptions {
     task: TaskDetail;
     criticalRules: string[];
-    sections: ContextSection[];
+    blockIndices: SectionBlockIndex[];
     templates: Array<{
         name: string;
         description?: string | null;

package/dist/templates/TASK_CONTEXT.md.js

@@ -1,5 +1,5 @@
 export function generateTaskContext(options) {
-    const { task, criticalRules, sections, templates, modules, damperInstructions } = options;
+    const { task, criticalRules, blockIndices, templates, modules, damperInstructions } = options;
     const typeIcon = task.type === 'bug' ? 'Bug' : task.type === 'feature' ? 'Feature' : task.type === 'improvement' ? 'Improvement' : 'Task';
     const lines = [];
     // Header
@@ -80,14 +80,21 @@ export function generateTaskContext(options) {
         }
         lines.push('');
     }
-    // Project Context Sections
-    if (sections.length > 0) {
-        lines.push('## Relevant Architecture');
+    // Project Context Block Index (load-on-demand)
+    if (blockIndices.length > 0) {
+        lines.push('## Available Architecture Context');
         lines.push('');
-        for (const section of sections) {
-            lines.push(`### ${section.section}`);
+        lines.push('**BEFORE starting work**, load the blocks relevant to your task using the MCP tool:');
+        lines.push('`get_section_block_content(section, blockIds)` — pass the section name and an array of block IDs from the list below.');
+        lines.push('Only load what you need to keep token usage low.');
+        lines.push('');
+        for (const index of blockIndices) {
+            lines.push(`### ${index.section} (${index.totalChars} chars)`);
             lines.push('');
-            lines.push(section.content);
+            for (const block of index.blocks) {
+                const heading = block.heading ? block.heading.replace(/^#+\s*/, '') : '(intro)';
+                lines.push(`- \`${block.id}\`: ${heading} (${block.charCount} chars)`);
+            }
             lines.push('');
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/cli",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {