@adhdev/daemon-core 0.9.82-rc.13 → 0.9.82-rc.131

package/src/mesh/worktree-bootstrap-config.ts

@@ -0,0 +1,234 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve as pathResolve } from 'path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as yaml from 'js-yaml';
+import {
+    isMeshConfigRecord,
+    normalizeMeshCommandConfig,
+    type MeshRefineValidationCommandPlan,
+    type RepoMeshRefineValidationCommandConfig,
+} from './refine-config.js';
+
+export type WorktreeBootstrapStatus = 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+
+export interface RepoMeshWorktreeBootstrapConfig {
+    version: 1;
+    enabled?: boolean;
+    runOnClone?: boolean;
+    required?: boolean;
+    commands?: RepoMeshRefineValidationCommandConfig[];
+    staleInputs?: string[];
+}
+
+export interface WorktreeBootstrapState {
+    status: WorktreeBootstrapStatus;
+    required: boolean;
+    configSource?: string;
+    configSourceType?: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    startedAt?: string;
+    completedAt?: string;
+    lastCommand?: string;
+    exitCode?: number | null;
+    error?: string;
+    commandsRun?: Array<Record<string, unknown>>;
+    staleInputs?: string[];
+}
+
+export interface WorktreeBootstrapConfigLoadResult {
+    config?: RepoMeshWorktreeBootstrapConfig;
+    source: string;
+    sourceType: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+}
+
+export const MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
+    '.adhdev/worktree_bootstrap.json',
+    '.adhdev/worktree_bootstrap.yaml',
+    '.adhdev/worktree_bootstrap.yml',
+    '.adhdev/worktree-bootstrap.json',
+    '.adhdev/worktree-bootstrap.yaml',
+    '.adhdev/worktree-bootstrap.yml',
+];
+
+export const MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: 'ADHDev Repo Mesh Worktree Bootstrap Config',
+    type: 'object',
+    additionalProperties: false,
+    required: ['version'],
+    properties: {
+        version: { const: 1 },
+        enabled: { type: 'boolean', default: true },
+        runOnClone: { type: 'boolean', default: true },
+        required: { type: 'boolean', default: true },
+        staleInputs: { type: 'array', maxItems: 16, items: { type: 'string', minLength: 1 } },
+        commands: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 4,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['command'],
+                properties: {
+                    command: { type: 'string', minLength: 1 },
+                    args: { type: 'array', items: { type: 'string' } },
+                    category: { enum: ['typecheck', 'test', 'lint', 'build', 'custom'] },
+                    cwd: { type: 'string' },
+                    timeoutMs: { type: 'number', minimum: 1000, maximum: 600000 },
+                    outputLimitBytes: { type: 'number', minimum: 1024, maximum: 1048576 },
+                    env: { type: 'object', additionalProperties: { type: 'string' } },
+                },
+            },
+        },
+    },
+} as const;
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_OUTPUT_LIMIT_BYTES = 128 * 1024;
+const OUTPUT_SUMMARY_CHARS = 2_000;
+
+function parseConfigText(path: string, text: string): unknown {
+    if (/\.json$/i.test(path)) return JSON.parse(text);
+    return yaml.load(text);
+}
+
+function truncateOutput(value: unknown): string {
+    const text = typeof value === 'string' ? value : value == null ? '' : String(value);
+    if (text.length <= OUTPUT_SUMMARY_CHARS) return text;
+    return `${text.slice(0, OUTPUT_SUMMARY_CHARS)}\n[truncated ${text.length - OUTPUT_SUMMARY_CHARS} chars]`;
+}
+
+export function validateMeshWorktreeBootstrapConfig(config: unknown, source = 'inline'): {
+    valid: boolean;
+    errors: string[];
+    commands: MeshRefineValidationCommandPlan[];
+    rejectedCommands: Array<Record<string, unknown>>;
+} {
+    const errors: string[] = [];
+    const commands: MeshRefineValidationCommandPlan[] = [];
+    const rejectedCommands: Array<Record<string, unknown>> = [];
+    if (!isMeshConfigRecord(config)) return { valid: false, errors: ['config must be an object'], commands, rejectedCommands };
+    if (config.version !== 1) errors.push('version must be 1');
+    if (config.enabled !== undefined && typeof config.enabled !== 'boolean') errors.push('enabled must be a boolean when provided');
+    if (config.runOnClone !== undefined && typeof config.runOnClone !== 'boolean') errors.push('runOnClone must be a boolean when provided');
+    if (config.required !== undefined && typeof config.required !== 'boolean') errors.push('required must be a boolean when provided');
+    if (config.staleInputs !== undefined && (!Array.isArray(config.staleInputs) || !config.staleInputs.every(input => typeof input === 'string' && input.trim()))) {
+        errors.push('staleInputs must be an array of non-empty strings when provided');
+    }
+    if (config.commands !== undefined && !Array.isArray(config.commands)) errors.push('commands must be an array');
+    if (Array.isArray(config.commands)) {
+        config.commands.forEach((entry, index) => {
+            const normalized = normalizeMeshCommandConfig(entry, `${source}:commands[${index}]`);
+            if (normalized.command) commands.push(normalized.command);
+            if (normalized.rejected) rejectedCommands.push(normalized.rejected);
+        });
+    }
+    if (config.enabled !== false && config.runOnClone !== false && commands.length === 0) errors.push('commands must contain at least one command when bootstrap is enabled');
+    if (rejectedCommands.length) errors.push('one or more bootstrap commands are invalid');
+    return { valid: errors.length === 0, errors, commands, rejectedCommands };
+}
+
+export function loadMeshWorktreeBootstrapConfig(mesh: any, workspace: string): WorktreeBootstrapConfigLoadResult {
+    const inline = mesh?.worktreeBootstrapConfig || mesh?.policy?.worktreeBootstrapConfig || mesh?.policy?.worktreeBootstrap;
+    if (inline !== undefined) {
+        const validation = validateMeshWorktreeBootstrapConfig(inline, 'mesh.policy.worktreeBootstrapConfig');
+        if (!validation.valid) return { source: 'mesh.policy.worktreeBootstrapConfig', sourceType: 'invalid', error: String(validation.rejectedCommands[0]?.reason || validation.errors.join('; ')) };
+        return { config: inline as RepoMeshWorktreeBootstrapConfig, source: 'mesh.policy.worktreeBootstrapConfig', sourceType: 'mesh_policy' };
+    }
+    for (const relative of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
+        const configPath = join(workspace, relative);
+        if (!existsSync(configPath)) continue;
+        try {
+            const parsed = parseConfigText(configPath, readFileSync(configPath, 'utf-8'));
+            const validation = validateMeshWorktreeBootstrapConfig(parsed, relative);
+            if (!validation.valid) return { source: relative, sourceType: 'invalid', path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join('; ')) };
+            return { config: parsed as RepoMeshWorktreeBootstrapConfig, source: relative, sourceType: 'repo_file', path: configPath };
+        } catch (error: any) {
+            return { source: relative, sourceType: 'invalid', path: configPath, error: error?.message || String(error) };
+        }
+    }
+    return { source: 'unavailable', sourceType: 'unavailable', error: `No worktree bootstrap config found. Checked: ${MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS.join(', ')}` };
+}
+
+export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Promise<WorktreeBootstrapState> {
+    const loaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+    if (!loaded.config) {
+        return { status: 'not_configured', required: false, configSource: loaded.source, configSourceType: loaded.sourceType, error: loaded.error };
+    }
+    const required = loaded.config.required !== false;
+    if (loaded.config.enabled === false || loaded.config.runOnClone === false) {
+        return { status: 'disabled', required, configSource: loaded.path || loaded.source, configSourceType: loaded.sourceType };
+    }
+    const validation = validateMeshWorktreeBootstrapConfig(loaded.config, loaded.source);
+    if (!validation.valid) {
+        return { status: 'failed', required, configSource: loaded.path || loaded.source, configSourceType: 'invalid', error: String(validation.rejectedCommands[0]?.reason || validation.errors.join('; ')), commandsRun: [] };
+    }
+
+    const execFileAsync = promisify(execFile);
+    const state: WorktreeBootstrapState = {
+        status: 'running',
+        required,
+        configSource: loaded.path || loaded.source,
+        configSourceType: loaded.sourceType,
+        startedAt: new Date().toISOString(),
+        commandsRun: [],
+        staleInputs: loaded.config.staleInputs,
+    };
+    for (const command of validation.commands) {
+        const cwd = command.cwd ? pathResolve(workspace, command.cwd) : workspace;
+        const startedAt = Date.now();
+        state.lastCommand = command.displayCommand;
+        try {
+            const result = await execFileAsync(command.command, command.args, {
+                cwd,
+                encoding: 'utf8',
+                timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS,
+                maxBuffer: command.outputLimitBytes || DEFAULT_OUTPUT_LIMIT_BYTES,
+                env: { ...process.env, CI: process.env.CI || '1', ...(command.env || {}) },
+                windowsHide: true,
+            });
+            state.commandsRun?.push({
+                command: command.command,
+                args: command.args,
+                displayCommand: command.displayCommand,
+                category: command.category,
+                source: command.source,
+                cwd,
+                passed: true,
+                durationMs: Date.now() - startedAt,
+                exitCode: 0,
+                stdout: truncateOutput(result.stdout),
+                stderr: truncateOutput(result.stderr),
+            });
+        } catch (error: any) {
+            const exitCode = typeof error?.code === 'number' ? error.code : null;
+            state.status = 'failed';
+            state.exitCode = exitCode;
+            state.error = error?.message || String(error);
+            state.completedAt = new Date().toISOString();
+            state.commandsRun?.push({
+                command: command.command,
+                args: command.args,
+                displayCommand: command.displayCommand,
+                category: command.category,
+                source: command.source,
+                cwd,
+                passed: false,
+                durationMs: Date.now() - startedAt,
+                exitCode,
+                signal: typeof error?.signal === 'string' ? error.signal : null,
+                timedOut: error?.killed === true || /timed out/i.test(String(error?.message || '')),
+                stdout: truncateOutput(error?.stdout),
+                stderr: truncateOutput(error?.stderr || error?.message),
+            });
+            return state;
+        }
+    }
+    state.status = 'ready';
+    state.exitCode = 0;
+    state.completedAt = new Date().toISOString();
+    return state;
+}

package/src/providers/approval-utils.ts

@@ -24,6 +24,13 @@ function normalizeApprovalLabel(value: string): string {
         .trim();
 }
 
+function isNegativeApprovalLabel(value: string): boolean {
+    const label = normalizeApprovalLabel(value);
+    return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label)
+        || /\bwithout\b/.test(label)
+        || /\bdo not\b/.test(label);
+}
+
 export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
     const customHints = Array.isArray(provider?.approvalPositiveHints)
         ? provider.approvalPositiveHints
@@ -39,24 +46,24 @@ export function pickApprovalButton(
 ): { index: number; label: string } {
     const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
     if (labels.length === 0) {
-        return { index: 0, label: 'Approve' };
+        return { index: -1, label: '' };
     }
 
     const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
     const hints = getApprovalPositiveHints(provider);
 
     for (const hint of hints) {
-        const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+        const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
         if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
 
-        const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+        const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
         if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
 
-        const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+        const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
         if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
     }
 
-    return { index: 0, label: labels[0] };
+    return { index: -1, label: '' };
 }
 
 export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string {

package/src/providers/chat-message-normalization.ts

@@ -1,9 +1,11 @@
 import type { ChatMessage } from '../types.js';
 import { flattenContent } from './contracts.js';
 
+export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4_000;
+
 export function extractFinalSummaryFromMessages(
   messages: ChatMessage[] | null | undefined,
-  maxChars: number = 500,
+  maxChars: number = DEFAULT_FINAL_SUMMARY_MAX_CHARS,
 ): string {
   if (!Array.isArray(messages) || messages.length === 0) return '';
 
@@ -18,17 +20,10 @@ export function extractFinalSummaryFromMessages(
     }
   }
 
-  // Fallback: last user-facing message of any role
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (!msg) continue;
-    const classification = classifyChatMessageVisibility(msg);
-    if (classification.isUserFacing) {
-      const text = flattenContent(msg.content).trim();
-      if (text) return text.slice(0, maxChars);
-    }
-  }
-
+  // Completion summaries must describe the assistant/model result. If no
+  // user-facing assistant/model message exists yet (for example, only the
+  // dispatched user prompt is visible), return empty instead of echoing the
+  // prompt as a misleading finalSummary.
   return '';
 }