@goodandready/dsh-goal 0.2.12 → 0.2.14

package/lib/addon-store.js

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Lightweight JSON persistence for dsh-goal addon metadata:
+ * milestones, checklists, snapshots, and token budget metrics.
+ */
+export class AddonStore {
+  constructor(storagePath, logger = console) {
+    this.storagePath = storagePath || null;
+    this.logger = logger;
+    this.goals = new Map(); // goalId -> { milestones, snapshots, budget, issue }
+    this.saveTimer = null;
+    this.loadFromDisk();
+  }
+
+  setStoragePath(storagePath) {
+    this.storagePath = storagePath || null;
+    this.loadFromDisk();
+  }
+
+  getGoalData(goalId) {
+    if (!goalId) return null;
+    if (!this.goals.has(goalId)) {
+      this.goals.set(goalId, {
+        milestones: [],
+        snapshots: [],
+        budget: { maxTokenBudget: 0, warnedAt: null, blockedAt: null },
+        issue: null,
+      });
+    }
+    return this.goals.get(goalId);
+  }
+
+  getMilestones(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.milestones : [];
+  }
+
+  setMilestones(goalId, milestones) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    data.milestones = Array.isArray(milestones) ? milestones : [];
+    this.scheduleSave();
+  }
+
+  getSnapshots(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.snapshots : [];
+  }
+
+  addSnapshot(goalId, snapshot) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    if (!Array.isArray(data.snapshots)) data.snapshots = [];
+    data.snapshots.push(snapshot);
+    this.scheduleSave();
+  }
+
+  getBudget(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.budget : null;
+  }
+
+  setBudget(goalId, budget) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    data.budget = { ...(data.budget || {}), ...budget };
+    this.scheduleSave();
+  }
+
+  loadFromDisk() {
+    if (!this.storagePath) return;
+    try {
+      if (fs.existsSync(this.storagePath)) {
+        const raw = fs.readFileSync(this.storagePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.goals) {
+          for (const [gid, val] of Object.entries(parsed.goals)) {
+            this.goals.set(gid, {
+              milestones: Array.isArray(val.milestones) ? val.milestones : [],
+              snapshots: Array.isArray(val.snapshots) ? val.snapshots : [],
+              budget: val.budget || { maxTokenBudget: 0, warnedAt: null, blockedAt: null },
+              issue: val.issue || null,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Failed to load addon state from disk:', err?.message || err);
+    }
+  }
+
+  scheduleSave(immediate = false) {
+    if (!this.storagePath) return;
+    if (immediate) {
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
+      this.writeToDiskSync();
+      return;
+    }
+    if (!this.saveTimer) {
+      this.saveTimer = setTimeout(() => {
+        this.saveTimer = null;
+        this.writeToDiskSync();
+      }, 200);
+      if (typeof this.saveTimer.unref === 'function') {
+        this.saveTimer.unref();
+      }
+    }
+  }
+
+  writeToDiskSync() {
+    if (!this.storagePath) return;
+    try {
+      const goalsObj = {};
+      for (const [gid, val] of this.goals.entries()) {
+        goalsObj[gid] = val;
+      }
+      const payload = {
+        version: 3,
+        goals: goalsObj,
+        updatedAt: Date.now(),
+      };
+      const dir = path.dirname(this.storagePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      const tmp = `${this.storagePath}.tmp.${Date.now()}`;
+      fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+      fs.renameSync(tmp, this.storagePath);
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Failed to write addon state to disk:', err?.message || err);
+    }
+  }
+
+  /**
+   * Migrate legacy state from dsh-goal-state.json to addon format and core GoalService
+   */
+  migrateLegacyState(legacyPath, coreGoals, agent) {
+    if (!legacyPath || !fs.existsSync(legacyPath)) return false;
+    try {
+      const raw = fs.readFileSync(legacyPath, 'utf8');
+      const data = JSON.parse(raw);
+      if (!data || typeof data !== 'object' || data._migratedToAddon) return false;
+
+      let migratedAny = false;
+      const candidates = [];
+      if (data.sessions && typeof data.sessions === 'object') {
+        for (const [sid, goal] of Object.entries(data.sessions)) {
+          if (goal?.title && goal?.hasActiveGoal) {
+            candidates.push({ sessionId: sid, goal });
+          }
+        }
+      } else if (data.title && data.hasActiveGoal) {
+        candidates.push({ sessionId: 'default', goal: data });
+      }
+
+      for (const item of candidates) {
+        const legacyGoal = item.goal;
+        const goalId = legacyGoal.id || `legacy-${Date.now()}`;
+
+        // Import milestones into addon store
+        if (Array.isArray(legacyGoal.milestones) && legacyGoal.milestones.length > 0) {
+          this.setMilestones(goalId, legacyGoal.milestones.map((m, idx) => ({
+            id: m.id || `m-${idx + 1}`,
+            title: m.title || `Milestone ${idx + 1}`,
+            completed: m.status === 'completed',
+            completedAt: m.completedAt || null,
+            notes: m.notes || '',
+            dependsOn: Array.isArray(m.dependsOn) ? m.dependsOn : [],
+            checklist: Array.isArray(m.checklist) ? m.checklist : [],
+          })));
+        }
+
+        // If coreGoals is available and agent session is active, bridge to core
+        if (coreGoals && agent && typeof coreGoals.create === 'function') {
+          try {
+            const current = coreGoals.get ? coreGoals.get(agent) : null;
+            if (!current) {
+              coreGoals.create(agent, {
+                objective: legacyGoal.title,
+                maxGoalRounds: legacyGoal.maxIterations || 25,
+              });
+            }
+          } catch (e) {
+            this.logger.warn?.('[AddonStore] Migration: could not create goal in core:', e.message);
+          }
+        }
+        migratedAny = true;
+      }
+
+      data._migratedToAddon = true;
+      data._migratedAt = Date.now();
+      fs.writeFileSync(legacyPath, JSON.stringify(data, null, 2), 'utf8');
+      this.scheduleSave(true);
+      return migratedAny;
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Legacy migration failed:', err.message);
+      return false;
+    }
+  }
+
+  flushSync() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.writeToDiskSync();
+  }
+}

package/lib/engine-reports.js

@@ -1,4 +1,8 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
 import { execFileSync } from 'node:child_process';
+import { generateRetrospectiveData } from './engine-retrospective.js';
 
 /**
  * Safely get current short git commit hash
@@ -19,48 +23,119 @@ export function getGitCurrentCommit(cwd) {
 }
 
 /**
- * Generate Markdown report for goal results
- * @param {Object} state
+ * Format elapsed time in human readable format
+ * @param {number} seconds
  * @returns {string}
  */
-export function exportReportMarkdown(state) {
-  if (!state) return '';
-  const title = state.title || 'Goal Report';
-  const status = state.state === 'COMPLETED' ? 'COMPLETED' : state.state;
-  const elapsed = state.formattedElapsed || '0s';
-  const iter = `${state.iterationsCount || 0}/${state.maxIterations || 25}`;
-  const totalTokens = state.tokensUsage?.totalTokens || 0;
-  const promptTokens = state.tokensUsage?.promptTokens || 0;
-  const compTokens = state.tokensUsage?.completionTokens || 0;
-  const gitCommit = state.gitStartCommit ? ` | **Git Start:** \`${state.gitStartCommit}\`` : '';
+export function formatElapsedSeconds(seconds) {
+  const s = Math.max(0, Math.floor(seconds || 0));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const remSec = s % 60;
+  if (m < 60) return `${m}m ${remSec}s`;
+  const h = Math.floor(m / 60);
+  const remMin = m % 60;
+  return `${h}h ${remMin}m`;
+}
+
+/**
+ * Generate Markdown report for goal completion or archival
+ * @param {object} goal - core goal view or state
+ * @param {object} [addonData] - { milestones, snapshots, tokensUsage }
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export function exportReportMarkdown(goal, addonData = {}, cwd = process.cwd()) {
+  if (!goal) return '';
+  const title = goal.objective || goal.title || 'Goal Report';
+  const phase = goal.phase || goal.state || 'COMPLETED';
+  const rounds = goal.roundsStarted || goal.iterationsCount || 0;
+  const maxRounds = goal.maxGoalRounds || goal.maxIterations || 25;
+
+  const elapsed = goal.formattedElapsed || formatElapsedSeconds(Math.max(0, Math.round(((goal.updatedAt || goal.completedAt || Date.now()) - (goal.createdAt || goal.startedAt || Date.now())) / 1000)));
+
+  const totalTokens = addonData?.tokensUsage?.totalTokens || goal?.tokensUsage?.totalTokens || 0;
+  const promptTokens = addonData?.tokensUsage?.promptTokens || goal?.tokensUsage?.promptTokens || 0;
+  const compTokens = addonData?.tokensUsage?.completionTokens || goal?.tokensUsage?.completionTokens || 0;
+  const gitCommit = goal.gitStartCommit ? ` | **Git Start:** \`${goal.gitStartCommit}\`` : '';
 
   let md = `# 🎯 Goal Report: ${title}\n\n`;
-  md += `**Status:** \`${status}\` | **Duration:** \`${elapsed}\` | **Iterations:** \`${iter}\`${gitCommit}\n`;
+  md += `**Status:** \`${phase}\` | **Duration:** \`${elapsed}\` | **Iterations:** \`${rounds}/${maxRounds}\`${gitCommit}\n`;
   if (totalTokens > 0) {
     md += `**Tokens:** \`${totalTokens.toLocaleString('en-US')}\` (Prompt: \`${promptTokens.toLocaleString('en-US')}\`, Completion: \`${compTokens.toLocaleString('en-US')}\`)\n`;
   }
   md += '\n';
 
-  if (state.description) {
-    md += `### Description\n${state.description}\n\n`;
+  if (goal.description) {
+    md += `### Description\n${goal.description}\n\n`;
   }
 
-  if (state.resultSummary) {
-    md += `### Summary & Deliverables\n${state.resultSummary}\n\n`;
+  if (goal.resultSummary) {
+    md += `### Summary & Deliverables\n${goal.resultSummary}\n\n`;
   }
 
-  const milestones = state.milestones || [];
+  // Milestones & Checklists
+  const milestones = addonData?.milestones || goal?.milestones || [];
   if (milestones.length > 0) {
-    md += `### Milestones\n| # | Status | Title | Notes |\n|---|---|---|---|\n`;
+    md += `### Milestones & Checklists\n`;
+    md += `| # | Status | Title | Notes | Checklists |\n`;
+    md += `|---|---|---|---|---|\n`;
     milestones.forEach((m, idx) => {
-      const mark = m.status === 'completed' ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
+      const isDone = m.status === 'completed' || m.completed === true;
+      const isInProg = m.status === 'in_progress';
+      const mark = isDone ? '✅ Done' : isInProg ? '🔄 In Progress' : '⏳ Pending';
       const cleanTitle = (m.title || '').replace(/\|/g, '\\|');
-      const cleanNotes = (m.notes || '').replace(/\|/g, '\\|');
-      md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes || '—'} |\n`;
+      const cleanNotes = (m.notes || '—').replace(/\|/g, '\\|');
+      let clSummary = '—';
+      if (Array.isArray(m.checklist) && m.checklist.length > 0) {
+        const doneCount = m.checklist.filter(c => c.done).length;
+        clSummary = `${doneCount}/${m.checklist.length}`;
+      }
+      md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes} | ${clSummary} |\n`;
     });
     md += '\n';
   }
 
+  // Snapshots
+  const snapshots = addonData?.snapshots || [];
+  if (snapshots.length > 0) {
+    md += `### Git Checkpoints & Snapshots\n`;
+    md += `| Milestone | Commit | Tag | Timestamp |\n`;
+    md += `|---|---|---|---|\n`;
+    snapshots.forEach((s) => {
+      const dt = new Date(s.timestamp || Date.now()).toISOString();
+      md += `| \`${s.milestoneId}\` | \`${s.commit}\` | \`${s.tag || '—'}\` | ${dt} |\n`;
+    });
+    md += '\n';
+  }
+
+  // Retrospective
+  try {
+    const retro = generateRetrospectiveData({
+      ...goal,
+      milestones,
+      tokensUsage: { totalTokens, promptTokens, completionTokens },
+      startedAt: goal.createdAt || goal.startedAt || Date.now(),
+      completedAt: goal.updatedAt || goal.completedAt || Date.now(),
+    }, cwd);
+    if (retro) {
+      md += `### Retrospective & Execution Analytics\n`;
+      if (retro.estimatedCostUsd) {
+        md += `- **Estimated Cost:** ~\$${retro.estimatedCostUsd} USD\n`;
+      }
+      if (retro.filesChangedCount !== undefined) {
+        md += `- **Files Changed:** ${retro.filesChangedCount}\n`;
+      }
+      if (retro.recommendations?.length > 0) {
+        md += `\n**Recommendations:**\n`;
+        retro.recommendations.forEach(r => { md += `- ${r}\n`; });
+      }
+      md += '\n';
+    }
+  } catch (err) {
+    // Retrospective non-fatal
+  }
+
   md += `*Generated by DSH Goal Engine at ${new Date().toISOString()}*\n`;
   return md;
 }
@@ -72,10 +147,10 @@ export function exportReportMarkdown(state) {
  */
 export function exportReportGitHubPR(state) {
   if (!state) return '';
-  const title = state.title || 'Goal Report';
-  const status = state.state === 'COMPLETED' ? 'COMPLETED' : state.state;
+  const title = state.objective || state.title || 'Goal Report';
+  const status = state.phase || state.state || 'COMPLETED';
   const elapsed = state.formattedElapsed || '0s';
-  const iter = `${state.iterationsCount || 0}/${state.maxIterations || 25}`;
+  const iter = `${state.roundsStarted || state.iterationsCount || 0}/${state.maxGoalRounds || state.maxIterations || 25}`;
   const totalTokens = state.tokensUsage?.totalTokens || 0;
   const promptTokens = state.tokensUsage?.promptTokens || 0;
   const compTokens = state.tokensUsage?.completionTokens || 0;
@@ -97,11 +172,11 @@ export function exportReportGitHubPR(state) {
 
   const milestones = state.milestones || [];
   if (milestones.length > 0) {
-    const completedCount = milestones.filter((m) => m.status === 'completed').length;
+    const completedCount = milestones.filter((m) => m.status === 'completed' || m.completed === true).length;
     md += `<details>\n<summary><b>📋 Milestones Breakdown (${completedCount}/${milestones.length} Completed)</b></summary>\n\n`;
     md += `| # | Status | Milestone | Notes |\n|---|---|---|---|\n`;
     milestones.forEach((m, idx) => {
-      const mark = m.status === 'completed' ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
+      const mark = (m.status === 'completed' || m.completed === true) ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
       const cleanTitle = (m.title || '').replace(/\|/g, '\\|');
       const cleanNotes = (m.notes || '').replace(/\|/g, '\\|');
       md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes || '—'} |\n`;
@@ -113,9 +188,6 @@ export function exportReportGitHubPR(state) {
   return md;
 }
 
-import fs from 'node:fs';
-import path from 'node:path';
-
 /**
  * Safely create a git milestone checkpoint
  * @param {object} milestone
@@ -133,7 +205,6 @@ export function createMilestoneCheckpoint(milestone, sessionId = 'default', cwd)
       cwd: cwd || undefined,
     }).trim();
 
-    // If there are changes, auto-commit checkpoint
     if (status) {
       execFileSync('git', ['add', '-A'], {
         stdio: ['ignore', 'ignore', 'ignore'],
@@ -191,7 +262,7 @@ export function rollbackToCheckpoint(commitHash, cwd) {
  * @returns {{ relativePath: string, fullPath: string, content: string }|null}
  */
 export function saveGoalArtifact(state, cwd) {
-  if (!state || !state.title) return null;
+  if (!state || (!state.title && !state.objective)) return null;
   try {
     const root = cwd || process.cwd();
     const targetDir = path.join(root, '.dsh', 'goals');
@@ -200,7 +271,7 @@ export function saveGoalArtifact(state, cwd) {
     }
 
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const safeTitle = (state.title || 'goal')
+    const safeTitle = (state.objective || state.title || 'goal')
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, '-')
       .replace(/^-+|-+$/g, '')
@@ -218,3 +289,11 @@ export function saveGoalArtifact(state, cwd) {
     return null;
   }
 }
+
+/**
+ * Save goal report to disk
+ */
+export function saveGoalReportFile(goal, addonData = {}, baseDir = null) {
+  const root = baseDir || process.cwd();
+  return saveGoalArtifact(goal, root)?.fullPath || null;
+}

package/lib/git-snapshot-manager.js

@@ -0,0 +1,99 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+
+/**
+ * Git snapshot and checkpoint manager for goal milestones
+ */
+export class GitSnapshotManager {
+  constructor(addonStore, { logger = console } = {}) {
+    this.store = addonStore;
+    this.logger = logger;
+  }
+
+  isGitRepository(workspaceRoot) {
+    if (!workspaceRoot || typeof workspaceRoot !== 'string') return false;
+    try {
+      if (!fs.existsSync(workspaceRoot)) return false;
+      execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+        cwd: workspaceRoot,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 2000,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  createSnapshot(goalId, milestoneId, workspaceRoot, message = '') {
+    if (!goalId || !milestoneId || !this.isGitRepository(workspaceRoot)) {
+      return null;
+    }
+
+    try {
+      const commit = execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 2000,
+      }).trim();
+
+      const safeGoalId = String(goalId).replace(/[^a-zA-Z0-9_-]/g, '_');
+      const safeMilestoneId = String(milestoneId).replace(/[^a-zA-Z0-9_-]/g, '_');
+      const tagName = `dsh-goal-snapshot/${safeGoalId}/${safeMilestoneId}-${commit}`;
+
+      try {
+        execFileSync('git', ['tag', '-f', tagName, 'HEAD'], {
+          cwd: workspaceRoot,
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 2000,
+        });
+      } catch (tagErr) {
+        // Tag creation non-fatal
+      }
+
+      const snapshot = {
+        goalId,
+        milestoneId,
+        commit,
+        tag: tagName,
+        timestamp: Date.now(),
+        message: message || `Milestone ${milestoneId} checkpoint`,
+      };
+
+      if (this.store) {
+        this.store.addSnapshot(goalId, snapshot);
+      }
+      this.logger.info?.(`[GitSnapshotManager] Created snapshot for milestone "${milestoneId}" at commit ${commit}`);
+      return snapshot;
+    } catch (err) {
+      this.logger.warn?.(`[GitSnapshotManager] Failed to create git snapshot: ${err.message}`);
+      return null;
+    }
+  }
+
+  rollback(goalId, milestoneId, workspaceRoot) {
+    if (!this.isGitRepository(workspaceRoot)) {
+      throw new Error(`Workspace "${workspaceRoot}" is not a valid git repository`);
+    }
+
+    const snapshots = this.store ? this.store.getSnapshots(goalId) : [];
+    const target = snapshots.find(s => s.milestoneId === milestoneId);
+    if (!target || !target.commit) {
+      throw new Error(`Snapshot for milestone "${milestoneId}" not found in goal "${goalId}"`);
+    }
+
+    try {
+      execFileSync('git', ['checkout', target.commit], {
+        cwd: workspaceRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 5000,
+      });
+      this.logger.info?.(`[GitSnapshotManager] Rolled back workspace to commit ${target.commit}`);
+      return { success: true, commit: target.commit, milestoneId };
+    } catch (err) {
+      throw new Error(`Git rollback to commit ${target.commit} failed: ${err.message}`);
+    }
+  }
+}