@mndrk/agx 1.4.60 → 1.4.62

package/lib/cli/runCli.js

@@ -72,6 +72,7 @@ const { handleSkillCommand } = require('./skills');
 const { runOnboarding, showConfigStatus, runConfigMenu } = require('./onboarding');
 const { runInteractiveMenu } = require('./interactiveMenu');
 const cloudArtifacts = require('./cloudArtifacts');
+const { sendWebhookEvent } = require('../notifications/webhooks');
 const fallbackExtractSection = (markdown, heading) => {
   if (!markdown) return '';
   const pattern = new RegExp(`^##\\s+${heading}\\s*$`, 'im');
@@ -100,6 +101,8 @@ const {
 } = require('./util');
 const { createCloudRunner } = require('./cloud');
 const daemon = require('./daemon');
+const { loadTemplate, renderTemplateContent } = require('../templates');
+const { slugify } = require('../storage/paths');
 const {
   DAEMON_PID_FILE,
   DAEMON_LOG_FILE,
@@ -1045,6 +1048,44 @@ async function checkOnboarding() {
       localArtifacts && lastRun ? `(Local run id: ${lastRun.run_id}, stage: ${lastRun.stage})` : '',
     ].filter(Boolean).join('\n'));
 
+    const stageName = completionResult?.newStage
+      || completionResult?.task?.stage
+      || task?.stage
+      || null;
+    const statusRaw = completionResult?.task?.status ?? task?.status ?? null;
+    const eventPayload = {
+      taskId,
+      taskSlug: task?.slug || null,
+      projectSlug: task?.project_slug || task?.project?.slug || null,
+      stage: stageName,
+      stageLocal,
+      status: statusRaw,
+      decision: decisionPayload.decision,
+      summary: decisionPayload.summary || null,
+      final_result: decisionPayload.final_result || null,
+      run_id: lastRun?.run_id || null,
+      duration_ms: Date.now() - taskStart,
+    };
+    const emitWebhook = async (eventName) => {
+      try {
+        await sendWebhookEvent(eventName, eventPayload);
+      } catch (err) {
+        const message = err?.message || String(err);
+        logger.log('error', `[daemon] webhook ${eventName} failed: ${message}\n`);
+      }
+    };
+
+    await emitWebhook('task.stage_complete');
+    if (decisionPayload.decision === 'failed') {
+      await emitWebhook('task.failed');
+    } else if (decisionPayload.decision === 'blocked') {
+      await emitWebhook('task.blocked');
+    }
+    const normalizedStatus = typeof statusRaw === 'string' ? statusRaw.trim().toLowerCase() : '';
+    if (normalizedStatus === 'completed' || (decisionPayload.decision === 'done' && String(stageName || '').toLowerCase() === 'done')) {
+      await emitWebhook('task.completed');
+    }
+
     {
       const detailRaw = String(decisionPayload.summary || decisionPayload.explanation || '').trim();
       const detail = detailRaw ? detailRaw.replace(/\s+/g, ' ').slice(0, 320) : '';
@@ -1185,29 +1226,29 @@ async function checkOnboarding() {
   // ============================================================
 
   // Provider aliases for convenience
-const PROVIDER_ALIASES = {
-  'c': 'claude', 'cl': 'claude', 'claude': 'claude',
-  'x': 'codex', 'codex': 'codex',
-  'g': 'gemini', 'gem': 'gemini', 'gemini': 'gemini',
-  'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
-};
-
-function collectFlagValues(args, flag) {
-  const values = [];
-  const consumedIndices = new Set();
-  for (let i = 0; i < args.length; i += 1) {
-    if (args[i] === flag) {
-      consumedIndices.add(i);
-      const next = args[i + 1];
-      if (typeof next === 'string' && next.length) {
-        values.push(next);
-        consumedIndices.add(i + 1);
+  const PROVIDER_ALIASES = {
+    'c': 'claude', 'cl': 'claude', 'claude': 'claude',
+    'x': 'codex', 'codex': 'codex',
+    'g': 'gemini', 'gem': 'gemini', 'gemini': 'gemini',
+    'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
+  };
+
+  function collectFlagValues(args, flag) {
+    const values = [];
+    const consumedIndices = new Set();
+    for (let i = 0; i < args.length; i += 1) {
+      if (args[i] === flag) {
+        consumedIndices.add(i);
+        const next = args[i + 1];
+        if (typeof next === 'string' && next.length) {
+          values.push(next);
+          consumedIndices.add(i + 1);
+        }
+        i += 1;
       }
-      i += 1;
     }
+    return { values, consumedIndices };
   }
-  return { values, consumedIndices };
-}
 
   // ============================================================
   // LOCAL-FIRST CLI COMMANDS
@@ -1223,6 +1264,12 @@ function collectFlagValues(args, flag) {
     if (handled) return true;
   }
 
+  {
+    const { maybeHandleTemplateCommand } = require('../commands/templates');
+    const handled = await maybeHandleTemplateCommand({ cmd, args, ctx: { c } });
+    if (handled) return true;
+  }
+
   // Local-first command handlers live in lib/commands/local.js.
 
   // ============================================================
@@ -1250,6 +1297,7 @@ function collectFlagValues(args, flag) {
         process.exit(1);
       }
     }
+    const providerArgProvided = provider !== null;
 
     // Parse --model / -m
     let model = null;
@@ -1257,6 +1305,7 @@ function collectFlagValues(args, flag) {
     if (modelIdx !== -1 && args[modelIdx + 1]) {
       model = args[modelIdx + 1];
     }
+    const modelArgProvided = model !== null;
     let projectSlug = null;
     const projectIdx = args.findIndex(a => a === '--project');
     if (projectIdx !== -1 && args[projectIdx + 1]) {
@@ -1288,15 +1337,40 @@ function collectFlagValues(args, flag) {
       const resolvedType = normalizeTicketType(args[ticketTypeIdx + 1]);
       ticketType = resolvedType === 'spike' ? 'spike' : 'task';
     }
+    let templateName = null;
+    const templateIdx = args.findIndex(a => a === '--template');
+    if (templateIdx !== -1 && args[templateIdx + 1]) {
+      templateName = args[templateIdx + 1];
+    }
 
     // Default provider from config
     if (!provider) {
       const config = loadConfig();
       provider = config?.defaultProvider || 'claude';
     }
+    if (template) {
+      if (!providerArgProvided && template.provider) {
+        provider = template.provider;
+      }
+      if (!modelArgProvided && template.model) {
+        model = template.model;
+      }
+    }
 
     // Extract goal text (filter out flags)
-    const flagsToRemove = ['--json', '--run', '-r', '--provider', '-P', '--model', '-m', '--project', '--type', '--ticket-type'];
+    const flagsToRemove = [
+      '--json',
+      '--run',
+      '-r',
+      '--provider',
+      '-P',
+      '--model',
+      '-m',
+      '--project',
+      '--type',
+      '--ticket-type',
+      '--template',
+    ];
     const goalParts = [];
     for (let i = 1; i < args.length; i++) {
       if (dependsOnSkipIndices.has(i)) {
@@ -1307,11 +1381,12 @@ function collectFlagValues(args, flag) {
         if (args[i] === '--model' || args[i] === '-m') i++;
         if (args[i] === '--project') i++;
         if (args[i] === '--type' || args[i] === '--ticket-type') i++;
+        if (args[i] === '--template') i++;
         continue;
       }
       goalParts.push(args[i]);
     }
-    const goalText = goalParts.join(' ');
+    const goalText = goalParts.join(' ').trim();
 
     if (!goalText) {
       if (jsonMode) {
@@ -1322,6 +1397,21 @@ function collectFlagValues(args, flag) {
       process.exit(1);
     }
 
+    let template = null;
+    if (templateName) {
+      try {
+        template = await loadTemplate(templateName);
+      } catch (err) {
+        const message = err?.message || `Template "${templateName}" not found`;
+        if (jsonMode) {
+          console.log(JSON.stringify({ error: message }));
+        } else {
+          console.log(`${c.red}✗${c.reset} ${message}`);
+        }
+        process.exit(1);
+      }
+    }
+
     try {
       let projectId = null;
       if (projectSlug) {
@@ -1348,8 +1438,25 @@ function collectFlagValues(args, flag) {
       if (projectId) frontmatter.push(`project_id: ${projectId}`);
       if (model) frontmatter.push(`model: ${model}`);
       if (ticketType) frontmatter.push(`type: ${ticketType}`);
-
-      const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${goalText}\n`;
+      if (template) frontmatter.push(`template: ${template.slug}`);
+
+      let bodyContent = `# ${goalText}\n`;
+      if (template) {
+        const rendered = renderTemplateContent(template.content, {
+          title: goalText,
+          goal: goalText,
+          slug: slugify(goalText, { maxLength: 64 }),
+          project: projectSlug || '',
+          template: template.slug,
+        });
+        if (rendered && rendered.trim()) {
+          bodyContent = rendered;
+        }
+      }
+      if (!bodyContent.endsWith('\n')) {
+        bodyContent += '\n';
+      }
+      const content = `---\n${frontmatter.join('\n')}\n---\n\n${bodyContent}`;
 
       const payload = { content };
       if (dependsOnValues.length) {
@@ -2330,7 +2437,7 @@ function collectFlagValues(args, flag) {
         if (config?.token) {
           esOptions.headers = { Authorization: `Bearer ${config.token}` };
         }
-        const streamUrl = `${config.apiUrl}/api/logs/stream?taskId=${encodeURIComponent(taskId)}`;
+        const streamUrl = `${config.apiUrl}/api/tasks/${encodeURIComponent(taskId)}/logs/stream`;
         const es = new EventSource(streamUrl, esOptions);
 
         es.onmessage = (event) => {

package/lib/commands/templates.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { listTemplates, createTemplate, getTemplatesDir } = require('../templates');
+
+function getFlagValue(args, flag) {
+    const idx = args.findIndex(a => a === flag);
+    if (idx === -1) return null;
+    return args[idx + 1] || null;
+}
+
+async function maybeHandleTemplateCommand({ cmd, args, ctx }) {
+    if (cmd !== 'templates') {
+        return false;
+    }
+    const { c } = ctx || {};
+    const subcommand = args[1];
+
+    switch (subcommand) {
+        case 'list':
+        case 'ls': {
+            const templates = await listTemplates();
+            if (args.includes('--json')) {
+                console.log(JSON.stringify({ templates }));
+                process.exit(0);
+            }
+            console.log(`${c?.bold || ''}Templates (${templates.length})${c?.reset || ''}`);
+            console.log(`Directory: ${getTemplatesDir()}`);
+            if (!templates.length) {
+                console.log('  No templates found. Use `agx templates create <name>` to add one.');
+                process.exit(0);
+            }
+            console.log('');
+            for (const template of templates) {
+                const info = [];
+                if (template.description) info.push(template.description);
+                if (template.provider) info.push(`provider=${template.provider}`);
+                if (template.model) info.push(`model=${template.model}`);
+                const displayName = template.name === template.slug
+                    ? template.slug
+                    : `${template.name} (${template.slug})`;
+                console.log(`  ${displayName}${info.length ? `  (${info.join(', ')})` : ''}`);
+            }
+            process.exit(0);
+        }
+        case 'create': {
+            const name = args[2];
+            if (!name) {
+                console.log('Usage: agx templates create <name> [--description "desc"] [--provider claude] [--model claude-sonnet-4-5] [--content-file ./template.md]');
+                process.exit(1);
+            }
+
+            const description = getFlagValue(args, '--description');
+            const provider = getFlagValue(args, '--provider');
+            const model = getFlagValue(args, '--model');
+            const contentInline = getFlagValue(args, '--content');
+            const contentFile = getFlagValue(args, '--content-file');
+            let content = contentInline;
+            if (!content && contentFile) {
+                try {
+                    content = await fs.promises.readFile(path.resolve(contentFile), 'utf8');
+                } catch (err) {
+                    console.log(`${c?.red || ''}Error:${c?.reset || ''} Could not read content file: ${err.message}`);
+                    process.exit(1);
+                }
+            }
+
+            const created = await createTemplate({ name, description, provider, model, content });
+            console.log(`${c?.green || ''}✓${c?.reset || ''} Template created: ${created.slug}`);
+            console.log(`  Path: ${created.file}`);
+            process.exit(0);
+        }
+        default:
+            console.log(`Template Commands:
+  agx templates list   List available templates
+  agx templates create <name>  Scaffold a new template file (options: --description, --provider, --model, --content-file)
+`);
+            process.exit(0);
+    }
+}
+
+module.exports = { maybeHandleTemplateCommand };

package/lib/notifications/webhooks.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { loadConfig } = require('../cli/configStore');
+
+const SUPPORTED_EVENTS = Object.freeze([
+  'task.created',
+  'task.stage_complete',
+  'task.completed',
+  'task.failed',
+  'task.blocked',
+]);
+
+const WILDCARD_EVENT = '*';
+
+function normalizeEventName(value) {
+  if (!value && value !== 0) return '';
+  const candidate = String(value || '').trim().toLowerCase();
+  if (!candidate) return '';
+  if (candidate === WILDCARD_EVENT) return WILDCARD_EVENT;
+  if (candidate.endsWith('.*')) {
+    return candidate;
+  }
+  return SUPPORTED_EVENTS.includes(candidate) ? candidate : '';
+}
+
+function normalizeEventsInput(value) {
+  if (value === undefined || value === null) {
+    return [WILDCARD_EVENT];
+  }
+  const parts = [];
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const normalized = normalizeEventName(item);
+      if (normalized) parts.push(normalized);
+    }
+  } else if (typeof value === 'string') {
+    for (const item of value.split(',')) {
+      const normalized = normalizeEventName(item);
+      if (normalized) parts.push(normalized);
+    }
+  }
+  if (parts.length === 0) {
+    return [WILDCARD_EVENT];
+  }
+  return Array.from(new Set(parts));
+}
+
+function normalizeWebhookEntry(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const url = typeof entry.url === 'string' ? entry.url.trim() : '';
+  if (!url) return null;
+  const events = normalizeEventsInput(entry.events);
+  if (!events.length) return null;
+  return { url, events };
+}
+
+function parseWebhookEntries(config) {
+  const source = config ?? loadConfig();
+  if (!source || !Array.isArray(source.webhooks)) return [];
+  return source.webhooks
+    .map(normalizeWebhookEntry)
+    .filter((entry) => entry !== null);
+}
+
+function eventMatches(entry, eventName) {
+  if (!entry || !eventName) return false;
+  const normalized = String(eventName).trim().toLowerCase();
+  if (!normalized) return false;
+  if (!Array.isArray(entry.events)) return false;
+  if (entry.events.includes(WILDCARD_EVENT)) return true;
+  if (entry.events.includes(normalized)) return true;
+  return entry.events.some((event) => event.endsWith('.*') && normalized.startsWith(event.slice(0, -1)));
+}
+
+async function sendWebhookEvent(eventName, payload = null, options = {}) {
+  const normalizedEvent = normalizeEventName(eventName);
+  if (!normalizedEvent) return [];
+
+  const entries = Array.isArray(options.webhooks)
+    ? options.webhooks
+    : parseWebhookEntries(options.config);
+
+  if (!entries.length) return [];
+
+  const matches = entries.filter((entry) => eventMatches(entry, normalizedEvent));
+  if (!matches.length) return [];
+
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== 'function') return matches;
+
+  const timestamp = options.timestamp || new Date().toISOString();
+  const body = JSON.stringify({ event: normalizedEvent, timestamp, payload });
+  const logger = options.logger || console;
+
+  const results = await Promise.allSettled(
+    matches.map((match) => fetchFn(match.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-AGX-Event': normalizedEvent,
+      },
+      body,
+    }))
+  );
+
+  results.forEach((result, index) => {
+    if (result.status === 'rejected') {
+      if (logger && typeof logger.error === 'function') {
+        logger.error(`Webhook failed (${matches[index].url}): ${String(result.reason)}`);
+      }
+    }
+  });
+
+  return matches;
+}
+
+module.exports = {
+  SUPPORTED_EVENTS,
+  normalizeWebhookEntry,
+  parseWebhookEntries,
+  eventMatches,
+  sendWebhookEvent,
+};

package/lib/templates.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('yaml');
+const { CONFIG_DIR } = require('./config/paths');
+const { slugify } = require('./storage/paths');
+
+const TEMPLATES_DIR = path.join(CONFIG_DIR, 'templates');
+const TEMPLATE_EXTENSIONS = ['.yaml', '.yml'];
+
+function getTemplatesDir() {
+    return TEMPLATES_DIR;
+}
+
+async function ensureTemplatesDir() {
+    await fs.promises.mkdir(TEMPLATES_DIR, { recursive: true });
+}
+
+function normalizeTemplateSlug(name) {
+    if (!name || typeof name !== 'string') {
+        throw new Error('Template name is required');
+    }
+    const slug = slugify(name, { maxLength: 64 });
+    if (!slug) {
+        throw new Error('Template name must contain letters or numbers');
+    }
+    return slug;
+}
+
+function templateFilePath(slug) {
+    return path.join(TEMPLATES_DIR, `${slug}.yaml`);
+}
+
+async function readTemplateFile(filePath) {
+    const raw = await fs.promises.readFile(filePath, 'utf8');
+    const parsed = yaml.parse(raw) || {};
+    return parsed;
+}
+
+function normalizeTemplateObject(slug, raw) {
+    return {
+        slug,
+        name: raw.name || slug,
+        description: raw.description || '',
+        provider: raw.provider || null,
+        model: raw.model || null,
+        content: typeof raw.content === 'string' ? raw.content : '',
+        file: templateFilePath(slug),
+    };
+}
+
+async function createTemplate({ name, description = '', provider = '', model = '', content = '' }) {
+    const slug = normalizeTemplateSlug(name);
+    await ensureTemplatesDir();
+    const filePath = templateFilePath(slug);
+    if (fs.existsSync(filePath)) {
+        throw new Error(`Template "${slug}" already exists`);
+    }
+
+    const displayName = typeof name === 'string' && name.trim()
+        ? name.trim()
+        : slug;
+    const payload = {
+        name: displayName,
+        description: description || `Template ${displayName}`,
+        provider: provider || undefined,
+        model: model || undefined,
+        content: content || '# {{title}}\n\nDescribe the workflow here.\n',
+    };
+
+    const serialized = yaml.stringify(payload).trim() + '\n';
+    await fs.promises.writeFile(filePath, serialized, 'utf8');
+    return { slug, file: filePath };
+}
+
+async function listTemplates() {
+    await ensureTemplatesDir();
+    const entries = await fs.promises.readdir(TEMPLATES_DIR, { withFileTypes: true });
+    const templates = [];
+    for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!TEMPLATE_EXTENSIONS.includes(ext)) continue;
+        const slug = normalizeTemplateSlug(path.basename(entry.name, ext));
+        try {
+            const data = await readTemplateFile(path.join(TEMPLATES_DIR, entry.name));
+            templates.push(normalizeTemplateObject(slug, data));
+        } catch (err) {
+            // skip invalid templates
+        }
+    }
+
+    return templates.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function loadTemplate(name) {
+    const slug = normalizeTemplateSlug(name);
+    const filePath = templateFilePath(slug);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Template "${slug}" not found`);
+    }
+    const raw = await readTemplateFile(filePath);
+    return normalizeTemplateObject(slug, raw);
+}
+
+function renderTemplateContent(content, context = {}) {
+    if (!content || typeof content !== 'string') return '';
+    return content.replace(/{{\s*([a-zA-Z0-9_.-]+)\s*}}/g, (match, key) => {
+        const value = context && typeof context === 'object' ? context[key] : undefined;
+        if (value === undefined || value === null) return '';
+        return String(value);
+    });
+}
+
+module.exports = {
+    getTemplatesDir,
+    createTemplate,
+    listTemplates,
+    loadTemplate,
+    renderTemplateContent,
+    ensureTemplatesDir,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mndrk/agx",
-  "version": "1.4.60",
+  "version": "1.4.62",
   "description": "Autonomous AI Agent Orchestrator for Claude, Gemini, and Ollama",
   "main": "lib/index.js",
   "exports": {
@@ -50,7 +50,8 @@
     "execa": "^5.1.1",
     "p-map": "^7.0.4",
     "p-retry": "^7.1.1",
-    "posthog-node": "^5.24.15"
+    "posthog-node": "^4.18.0",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "esbuild": "^0.25.0",