@goodandready/dsh-goal 0.1.0

package/lib/goal-engine.js

@@ -0,0 +1,353 @@
+/**
+ * Изолированное ядро управления состоянием цели (Goal Engine).
+ * Не имеет внешних зависимостей, 100% тестируемо через node --test.
+ */
+
+export const GoalState = {
+  IDLE: 'IDLE',
+  PLANNING: 'PLANNING',
+  RUNNING: 'RUNNING',
+  PAUSED: 'PAUSED',
+  COMPLETED: 'COMPLETED',
+  FAILED: 'FAILED',
+  CANCELLED: 'CANCELLED',
+};
+
+export const MilestoneStatus = {
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+};
+
+/**
+ * Форматирование времени в лаконичную строку (например: "2s", "45s", "1m 15s", "2h 5m")
+ * @param {number} totalSeconds
+ * @returns {string}
+ */
+export function formatElapsed(totalSeconds) {
+  const sec = Math.max(0, Math.floor(totalSeconds));
+  if (sec < 60) return `${sec}s`;
+  const mins = Math.floor(sec / 60);
+  const remainingSec = sec % 60;
+  if (mins < 60) {
+    return remainingSec > 0 ? `${mins}m ${remainingSec}s` : `${mins}m`;
+  }
+  const hours = Math.floor(mins / 60);
+  const remainingMins = mins % 60;
+  return remainingMins > 0 ? `${hours}h ${remainingMins}m` : `${hours}h`;
+}
+
+export class GoalEngine {
+  constructor(options = {}) {
+    this.defaultMaxIterations = options.defaultMaxIterations ?? 25;
+    this.currentGoal = null;
+    this.listeners = new Set();
+  }
+
+  /**
+   * Подписка на изменение состояния
+   * @param {Function} callback
+   * @returns {Function} unsubscribe
+   */
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+
+  emit() {
+    const snapshot = this.getSnapshot();
+    for (const listener of this.listeners) {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error('[GoalEngine] Listener error:', err);
+      }
+    }
+  }
+
+  /**
+   * Запуск новой цели
+   */
+  startGoal(title, options = {}) {
+    if (!title || typeof title !== 'string' || !title.trim()) {
+      throw new Error('Goal title cannot be empty');
+    }
+
+    const cleanTitle = title.trim();
+    const now = Date.now();
+
+    this.currentGoal = {
+      id: `goal-${now}-${Math.random().toString(36).substring(2, 7)}`,
+      title: cleanTitle,
+      description: options.description?.trim() || '',
+      state: GoalState.RUNNING,
+      startedAt: now,
+      pausedAt: null,
+      totalPausedDurationMs: 0,
+      completedAt: null,
+      iterationsCount: 0,
+      maxIterations: options.maxIterations ?? this.defaultMaxIterations,
+      milestones: [],
+      logs: [
+        {
+          timestamp: now,
+          type: 'info',
+          message: `Goal initiated: "${cleanTitle}"`,
+        },
+      ],
+      resultSummary: '',
+    };
+
+    if (Array.isArray(options.milestones) && options.milestones.length > 0) {
+      this.addMilestones(options.milestones, false);
+    }
+
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Приостановка автономного цикла цели
+   */
+  pause(reason = 'User requested pause') {
+    if (!this.currentGoal || this.currentGoal.state !== GoalState.RUNNING) {
+      return this.getSnapshot();
+    }
+
+    this.currentGoal.state = GoalState.PAUSED;
+    this.currentGoal.pausedAt = Date.now();
+    this.currentGoal.logs.push({
+      timestamp: Date.now(),
+      type: 'warning',
+      message: `Paused: ${reason}`,
+    });
+
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Возобновление выполнения цели
+   */
+  resume() {
+    if (!this.currentGoal || this.currentGoal.state !== GoalState.PAUSED) {
+      return this.getSnapshot();
+    }
+
+    const now = Date.now();
+    if (this.currentGoal.pausedAt) {
+      this.currentGoal.totalPausedDurationMs += now - this.currentGoal.pausedAt;
+      this.currentGoal.pausedAt = null;
+    }
+
+    this.currentGoal.state = GoalState.RUNNING;
+    this.currentGoal.logs.push({
+      timestamp: now,
+      type: 'info',
+      message: 'Goal resumed',
+    });
+
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Отмена цели
+   */
+  cancel(reason = 'Cancelled by user') {
+    if (!this.currentGoal) return null;
+
+    this.currentGoal.state = GoalState.CANCELLED;
+    this.currentGoal.completedAt = Date.now();
+    this.currentGoal.logs.push({
+      timestamp: Date.now(),
+      type: 'warning',
+      message: `Cancelled: ${reason}`,
+    });
+
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Очистка / сброс цели в IDLE
+   */
+  clear() {
+    this.currentGoal = null;
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Успешное завершение цели
+   */
+  completeGoal(summary = '') {
+    if (!this.currentGoal) return null;
+
+    const now = Date.now();
+    this.currentGoal.state = GoalState.COMPLETED;
+    this.currentGoal.completedAt = now;
+    this.currentGoal.resultSummary = summary;
+    this.currentGoal.logs.push({
+      timestamp: now,
+      type: 'info',
+      message: `Goal completed successfully: ${summary || 'All objectives met.'}`,
+    });
+
+    // Завершаем все активные milestones
+    for (const m of this.currentGoal.milestones) {
+      if (m.status === MilestoneStatus.IN_PROGRESS || m.status === MilestoneStatus.PENDING) {
+        m.status = MilestoneStatus.COMPLETED;
+      }
+    }
+
+    this.emit();
+    return this.getSnapshot();
+  }
+
+  /**
+   * Добавление вех (milestones)
+   */
+  addMilestones(milestonesList, shouldEmit = true) {
+    if (!this.currentGoal || !Array.isArray(milestonesList)) return;
+
+    for (const item of milestonesList) {
+      const itemTitle = typeof item === 'string' ? item : item.title;
+      if (!itemTitle || !itemTitle.trim()) continue;
+
+      const mId = (typeof item === 'object' && item.id) ? item.id : `m-${this.currentGoal.milestones.length + 1}`;
+      this.currentGoal.milestones.push({
+        id: String(mId),
+        title: itemTitle.trim(),
+        status: (typeof item === 'object' && item.status) ? item.status : MilestoneStatus.PENDING,
+        notes: (typeof item === 'object' && item.notes) ? item.notes : '',
+      });
+    }
+
+    if (shouldEmit) this.emit();
+  }
+
+  /**
+   * Обновление конкретной вехи
+   */
+  updateMilestone(id, status, notes = '') {
+    if (!this.currentGoal) return false;
+
+    const target = this.currentGoal.milestones.find((m) => m.id === String(id));
+    if (!target) return false;
+
+    if (status && Object.values(MilestoneStatus).includes(status)) {
+      target.status = status;
+    }
+    if (notes) {
+      target.notes = notes;
+    }
+
+    this.currentGoal.logs.push({
+      timestamp: Date.now(),
+      type: 'milestone',
+      message: `Milestone [${target.title}] status -> ${target.status}`,
+    });
+
+    this.emit();
+    return true;
+  }
+
+  /**
+   * Увеличение счётчика итераций turn
+   */
+  incrementIteration() {
+    if (!this.currentGoal || this.currentGoal.state !== GoalState.RUNNING) {
+      return false;
+    }
+
+    this.currentGoal.iterationsCount += 1;
+
+    if (this.currentGoal.iterationsCount >= this.currentGoal.maxIterations) {
+      this.currentGoal.state = GoalState.FAILED;
+      this.currentGoal.logs.push({
+        timestamp: Date.now(),
+        type: 'error',
+        message: `Safety limit reached: maximum ${this.currentGoal.maxIterations} iterations exceeded.`,
+      });
+      this.emit();
+      return false;
+    }
+
+    this.emit();
+    return true;
+  }
+
+  /**
+   * Подсчёт времени в секундах
+   */
+  getElapsedSeconds() {
+    if (!this.currentGoal) return 0;
+    const { startedAt, pausedAt, totalPausedDurationMs, completedAt } = this.currentGoal;
+    const endTime = completedAt || (pausedAt || Date.now());
+    const elapsedMs = Math.max(0, endTime - startedAt - totalPausedDurationMs);
+    return Math.floor(elapsedMs / 1000);
+  }
+
+  /**
+   * Снимок состояния для передачи клиенту / API
+   */
+  getSnapshot() {
+    if (!this.currentGoal) {
+      return {
+        hasActiveGoal: false,
+        state: GoalState.IDLE,
+        title: '',
+        elapsedSeconds: 0,
+        formattedElapsed: '0s',
+        milestones: [],
+        progressPercent: 0,
+        iterationsCount: 0,
+        maxIterations: this.defaultMaxIterations,
+      };
+    }
+
+    const elapsed = this.getElapsedSeconds();
+    const milestones = this.currentGoal.milestones;
+    const completedCount = milestones.filter((m) => m.status === MilestoneStatus.COMPLETED).length;
+    const progressPercent = milestones.length > 0 ? Math.round((completedCount / milestones.length) * 100) : 0;
+
+    return {
+      hasActiveGoal: true,
+      id: this.currentGoal.id,
+      state: this.currentGoal.state,
+      title: this.currentGoal.title,
+      description: this.currentGoal.description,
+      elapsedSeconds: elapsed,
+      formattedElapsed: formatElapsed(elapsed),
+      iterationsCount: this.currentGoal.iterationsCount,
+      maxIterations: this.currentGoal.maxIterations,
+      milestones,
+      progressPercent,
+      logs: this.currentGoal.logs,
+      resultSummary: this.currentGoal.resultSummary,
+    };
+  }
+
+  /**
+   * Формирование системного контекста для инжекта модели
+   */
+  getStatePromptInjection() {
+    if (!this.currentGoal || this.currentGoal.state !== GoalState.RUNNING) {
+      return '';
+    }
+
+    const snapshot = this.getSnapshot();
+    const milestonesText = snapshot.milestones.length > 0
+      ? snapshot.milestones.map((m, i) => `  ${i + 1}. [${m.status.toUpperCase()}] ${m.title}${m.notes ? ` (${m.notes})` : ''}`).join('\n')
+      : '  (No specific milestones decomposed yet; use goal_set_milestones to break down)';
+
+    return `\n\n[DSH GOAL MODE ACTIVE]
+Current Target Goal: "${snapshot.title}"
+Elapsed Time: ${snapshot.formattedElapsed} | Turn Iteration: ${snapshot.iterationsCount}/${snapshot.maxIterations}
+Milestones Progress (${snapshot.progressPercent}%):
+${milestonesText}
+Instructions: Keep focused strictly on achieving this goal. When sub-tasks finish, update milestones via goal_update_progress. When the target is completely accomplished, call goal_finish.`;
+  }
+}

package/lib/index.js

@@ -0,0 +1,223 @@
+import { GoalEngine, GoalState, MilestoneStatus } from './goal-engine.js';
+
+export const name = '@goodandready/dsh-goal';
+export const inject = ['webServer', 'settings'];
+
+const NS = 'dsh-goal';
+
+export function apply(ctx, config = {}) {
+  const engine = new GoalEngine({
+    defaultMaxIterations: config?.maxIterations ?? 25,
+  });
+
+  let currentSettings = {
+    maxIterations: config?.maxIterations ?? 25,
+    autoDrive: config?.autoDrive ?? true,
+    enableSound: config?.enableSound ?? true,
+  };
+
+  // 1. Регистрация настроек плагина
+  ctx.inject(['settings'], (sctx) => {
+    try {
+      const scope = sctx.settings?.register?.(NS, null, { base: currentSettings });
+      if (scope) {
+        currentSettings = { ...currentSettings, ...(scope.get?.() ?? {}) };
+      }
+    } catch (err) {
+      console.warn('[dsh-goal] Settings register skipped:', err.message);
+    }
+  });
+
+  // 2. Регистрация инструментов для модели (tools)
+  ctx.inject(['tools'], (tctx) => {
+    if (!tctx.tools?.register) return;
+
+    // Инструмент 1: Декомпозиция цели на вехи
+    tctx.tools.register({
+      name: 'goal_set_milestones',
+      description: 'Break down the current active goal into a sequence of concrete milestones/sub-tasks.',
+      parameters: {
+        type: 'object',
+        properties: {
+          milestones: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'List of milestone titles to accomplish.',
+          },
+        },
+        required: ['milestones'],
+      },
+      handler: async ({ milestones }) => {
+        const snap = engine.getSnapshot();
+        if (!snap.hasActiveGoal) {
+          return { error: 'No active goal currently set. Start a goal first.' };
+        }
+        engine.addMilestones(milestones);
+        return {
+          success: true,
+          milestones: engine.getSnapshot().milestones,
+        };
+      },
+    });
+
+    // Инструмент 2: Обновление статуса вехи
+    tctx.tools.register({
+      name: 'goal_update_progress',
+      description: 'Update the status of a specific goal milestone and optionally log progress notes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          milestone_id: {
+            type: 'string',
+            description: 'The ID of the milestone (e.g. "m-1", "m-2").',
+          },
+          status: {
+            type: 'string',
+            enum: ['pending', 'in_progress', 'completed', 'failed'],
+            description: 'New status for this milestone.',
+          },
+          notes: {
+            type: 'string',
+            description: 'Brief summary of what was accomplished or why it failed.',
+          },
+        },
+        required: ['milestone_id', 'status'],
+      },
+      handler: async ({ milestone_id, status, notes }) => {
+        const ok = engine.updateMilestone(milestone_id, status, notes);
+        if (!ok) {
+          return { error: `Milestone ${milestone_id} not found or no active goal.` };
+        }
+        return {
+          success: true,
+          snapshot: engine.getSnapshot(),
+        };
+      },
+    });
+
+    // Инструмент 3: Успешное завершение цели
+    tctx.tools.register({
+      name: 'goal_finish',
+      description: 'Conclude the active goal successfully with a final summary and achievements.',
+      parameters: {
+        type: 'object',
+        properties: {
+          summary: {
+            type: 'string',
+            description: 'Final summary of the goal outcome and deliverables.',
+          },
+        },
+        required: ['summary'],
+      },
+      handler: async ({ summary }) => {
+        const snap = engine.completeGoal(summary);
+        return {
+          success: true,
+          completed: true,
+          summary,
+        };
+      },
+    });
+  });
+
+  // 3. Регистрация HTTP REST API маршрутов
+  ctx.effect(() => {
+    if (!ctx.webServer?.register) return () => {};
+
+    const unreg = ctx.webServer.register({
+      kind: 'prefix',
+      path: '/dsh-goal',
+      handler: (req, res) => {
+        const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+        const pathname = url.pathname;
+
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+
+        // GET /dsh-goal/state
+        if (req.method === 'GET' && (pathname === '/dsh-goal/state' || pathname === '/dsh-goal/state/')) {
+          res.statusCode = 200;
+          return res.end(JSON.stringify(engine.getSnapshot()));
+        }
+
+        // POST /dsh-goal/action
+        if (req.method === 'POST' && (pathname === '/dsh-goal/action' || pathname === '/dsh-goal/action/')) {
+          let body = '';
+          req.on('data', (chunk) => { body += chunk; });
+          req.on('end', () => {
+            try {
+              const data = JSON.parse(body || '{}');
+              const { action, title, description, reason, milestoneId, status, notes } = data;
+
+              let result = null;
+              switch (action) {
+                case 'start':
+                  result = engine.startGoal(title || 'Новая цель', { description });
+                  break;
+                case 'pause':
+                  result = engine.pause(reason);
+                  break;
+                case 'resume':
+                  result = engine.resume();
+                  break;
+                case 'cancel':
+                  result = engine.cancel(reason);
+                  break;
+                case 'clear':
+                  result = engine.clear();
+                  break;
+                case 'update_milestone':
+                  engine.updateMilestone(milestoneId, status, notes);
+                  result = engine.getSnapshot();
+                  break;
+                default:
+                  res.statusCode = 400;
+                  return res.end(JSON.stringify({ error: `Unknown action: ${action}` }));
+              }
+
+              res.statusCode = 200;
+              return res.end(JSON.stringify({ ok: true, state: result || engine.getSnapshot() }));
+            } catch (parseErr) {
+              res.statusCode = 400;
+              return res.end(JSON.stringify({ error: parseErr.message }));
+            }
+          });
+          return;
+        }
+
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: 'Endpoint not found' }));
+      },
+    });
+
+    return () => {
+      if (typeof unreg === 'function') unreg();
+    };
+  }, 'dsh-goal: HTTP WebServer Routes');
+
+  // 4. Подписка на события сессии (автономный цикл)
+  ctx.effect(() => {
+    // Подписка на завершение turn
+    const onTurnEnd = () => {
+      const snap = engine.getSnapshot();
+      if (snap.hasActiveGoal && snap.state === GoalState.RUNNING) {
+        engine.incrementIteration();
+      }
+    };
+
+    // Подписка на запрос подтверждения (approval/asked) -> автоматическая пауза
+    const onApprovalAsked = () => {
+      const snap = engine.getSnapshot();
+      if (snap.hasActiveGoal && snap.state === GoalState.RUNNING) {
+        engine.pause('Ожидание подтверждения действия оператором');
+      }
+    };
+
+    ctx.on?.('turn/end', onTurnEnd);
+    ctx.on?.('approval/asked', onApprovalAsked);
+
+    return () => {
+      ctx.off?.('turn/end', onTurnEnd);
+      ctx.off?.('approval/asked', onApprovalAsked);
+    };
+  }, 'dsh-goal: Session & Turn Coordinator');
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@goodandready/dsh-goal",
+  "version": "0.1.0",
+  "description": "Goal mode & autonomous execution plugin for DeepSeek Harness with sticky top banner",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/",
+    "docs/",
+    "cordis.patch.yml",
+    "README.md",
+    "README.ru.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "goal-mode",
+    "autonomous-agent",
+    "cordis"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GooDAnDReaDY/dsh-goal.git"
+  },
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-goal",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-goal/issues"
+  },
+  "author": "goodandready",
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6"
+  }
+}