godpowers 1.6.13 → 1.6.15

package/lib/automation-providers.js

@@ -1,9 +1,10 @@
 /**
  * Godpowers Automation Providers
  *
- * Detects host-native automation surfaces and renders opt-in setup guidance.
- * This module never creates schedules, routines, background agents, commits,
- * pushes, packages, publishes, deploys, or clears reviews by itself.
+ * Detects host-native automation surfaces, renders opt-in setup guidance, and
+ * records completed host setup after explicit confirmation. This module never
+ * creates schedules, routines, background agents, commits, pushes, packages,
+ * publishes, deploys, or clears reviews by itself.
  */
 
 const fs = require('fs');
@@ -219,6 +220,82 @@ const PROVIDERS = [
   }
 ];
 
+const EXECUTION_ADAPTERS = {
+  'codex-app': {
+    method: 'host-tool-calling',
+    hostTool: 'codex_app.automation_update',
+    action: 'Call the Codex App automation tool after the user approves provider, template, cadence, and scope.'
+  },
+  'claude-routines': {
+    method: 'host-native-command',
+    hostCommand: '/schedule',
+    action: 'Use Claude Code schedule or routine creation after explicit user approval.'
+  },
+  'cline-schedule': {
+    method: 'local-command',
+    localCommand: 'cline schedule',
+    action: 'Use the Cline scheduler after explicit user approval.'
+  },
+  'kilo-scheduled-triggers': {
+    method: 'host-native-ui',
+    action: 'Use KiloClaw Scheduled Triggers after explicit user approval.'
+  },
+  'qwen-loop': {
+    method: 'session-command',
+    hostCommand: '/loop',
+    action: 'Use Qwen Code loop only for session-scoped recurring checks.'
+  },
+  'cursor-background-agent': {
+    method: 'background-agent',
+    action: 'Use Cursor Background Agent mode or API for branch-scoped asynchronous work.'
+  },
+  'github-copilot-cloud-agent': {
+    method: 'background-agent',
+    action: 'Use GitHub issue, pull request, or Copilot cloud agent entry points for branch-scoped work.'
+  },
+  'windsurf-workflows': {
+    method: 'manual-workflow',
+    action: 'Install or select a Windsurf workflow manually because durable scheduling is not confirmed.'
+  },
+  'gemini-headless': {
+    method: 'scriptable-headless',
+    localCommand: 'gemini -p',
+    action: 'Use Gemini CLI headless execution only with an approved host, CI, or OS scheduler.'
+  },
+  'opencode-run': {
+    method: 'scriptable-headless',
+    localCommand: 'opencode run',
+    action: 'Use OpenCode run or serve only with an approved host, CI, or OS scheduler.'
+  },
+  'augment-subagents': {
+    method: 'manual-workflow',
+    action: 'Use Augment Agent, Agent Auto, or subagents manually unless a native scheduler is confirmed.'
+  },
+  'codebuddy-sdk': {
+    method: 'scriptable-headless',
+    action: 'Use CodeBuddy SDK only with an approved host, CI, or OS scheduler.'
+  },
+  'pi-sdk': {
+    method: 'scriptable-headless',
+    action: 'Use Pi CLI or SDK only with an approved host, CI, or OS scheduler.'
+  },
+  trae: {
+    method: 'unsupported',
+    action: 'Report scheduled automation as unknown until Trae exposes a confirmed provider.'
+  },
+  antigravity: {
+    method: 'unsupported',
+    action: 'Report scheduled automation as unknown until Antigravity exposes a confirmed provider.'
+  }
+};
+
+const EXECUTION_GUARDRAILS = [
+  'Ask for explicit approval before creating, updating, triggering, pausing, resuming, or deleting host automations.',
+  'Use direct host tool calling only for one read-only template with a known provider and approved cadence.',
+  'Spawn god-automation-engineer for multiple templates, write-capable automation, background agents, scriptable schedulers, or provider uncertainty.',
+  'Write .godpowers/automations.json only after host setup succeeds.'
+];
+
 function detect(projectRoot = process.cwd(), opts = {}) {
   const ctx = {
     projectRoot,
@@ -298,9 +375,12 @@ function render(report) {
 function setupPlan(projectRoot = process.cwd(), opts = {}) {
   const report = detect(projectRoot, opts);
   const provider = report.recommendedProvider;
+  const selectedTemplates = selectTemplates(report.safeTemplates, opts.templates);
   return {
     ...report,
-    setup: provider ? provider.setup : ['No automation provider is available. Use /god-next or godpowers next --project . manually.']
+    selectedTemplates,
+    setup: provider ? provider.setup : ['No automation provider is available. Use /god-next or godpowers next --project . manually.'],
+    execution: buildExecutionPlan(projectRoot, provider, selectedTemplates, opts)
   };
 }
 
@@ -316,6 +396,13 @@ function renderSetupPlan(plan) {
     'Setup steps:',
     ...plan.setup.map((step, index) => `  ${index + 1}. ${step}`),
     '',
+    'Execution path:',
+    `  - Method: ${plan.execution.method}`,
+    `  - Action: ${plan.execution.action}`,
+    `  - Direct host tool calling: ${plan.execution.directHostToolCalling ? 'available after approval' : 'not available'}`,
+    `  - Specialist agent: ${plan.execution.specialistAgent || 'not required for simple read-only setup'}`,
+    `  - Record after success: ${plan.execution.recordPath}`,
+    '',
     'Recommended safe templates:',
     ...plan.safeTemplates.map(template => `  - ${template.id}: ${template.prompt}`),
     '',
@@ -326,6 +413,100 @@ function renderSetupPlan(plan) {
   ].join('\n');
 }
 
+function selectTemplates(safeTemplates, selectedIds) {
+  if (!Array.isArray(selectedIds) || selectedIds.length === 0) {
+    const daily = safeTemplates.find(template => template.id === 'daily-status');
+    return daily ? [daily] : safeTemplates.slice(0, 1);
+  }
+  const selected = [];
+  for (const id of selectedIds) {
+    const found = safeTemplates.find(template => template.id === id);
+    if (found) selected.push(found);
+  }
+  return selected;
+}
+
+function buildExecutionPlan(projectRoot, provider, selectedTemplates, opts = {}) {
+  if (!provider) {
+    return {
+      method: 'manual',
+      action: 'No provider is available. Run Godpowers commands manually.',
+      directHostToolCalling: false,
+      hostTool: null,
+      hostCommand: null,
+      localCommand: null,
+      specialistAgent: null,
+      approvalRequired: true,
+      recordPath: path.join(projectRoot, CONFIG_PATH),
+      guardrails: EXECUTION_GUARDRAILS.slice()
+    };
+  }
+
+  const adapter = EXECUTION_ADAPTERS[provider.id] || {
+    method: provider.class,
+    action: 'Use the provider-native setup surface after explicit user approval.'
+  };
+  const writeCapable = Boolean(opts.writeCapable);
+  const complex = writeCapable ||
+    selectedTemplates.length > 1 ||
+    provider.class === 'background-agent' ||
+    provider.class === 'scriptable-headless' ||
+    provider.class === 'unknown';
+  const directHostToolCalling = !complex && (
+    adapter.method === 'host-tool-calling' ||
+    adapter.method === 'host-native-command' ||
+    adapter.method === 'local-command' ||
+    adapter.method === 'session-command'
+  );
+
+  return {
+    method: adapter.method,
+    action: adapter.action,
+    directHostToolCalling,
+    hostTool: adapter.hostTool || null,
+    hostCommand: adapter.hostCommand || null,
+    localCommand: adapter.localCommand || null,
+    specialistAgent: complex ? 'god-automation-engineer' : null,
+    approvalRequired: true,
+    recordPath: path.join(projectRoot, CONFIG_PATH),
+    guardrails: EXECUTION_GUARDRAILS.slice()
+  };
+}
+
+function buildAutomationRecord(providerId, templateId, opts = {}) {
+  const provider = PROVIDERS.find(item => item.id === providerId);
+  const template = SAFE_TEMPLATES.find(item => item.id === templateId);
+  if (!provider) throw new Error(`unknown automation provider: ${providerId}`);
+  if (!template) throw new Error(`unknown automation template: ${templateId}`);
+  return {
+    id: template.id,
+    provider: provider.id,
+    status: opts.status || 'active',
+    cadence: opts.cadence || template.cadence,
+    summary: opts.summary || template.prompt,
+    risk: template.risk,
+    createdAt: opts.createdAt || new Date().toISOString(),
+    host: opts.host || provider.label,
+    hostId: opts.hostId || null,
+    hostSurface: opts.hostSurface || (EXECUTION_ADAPTERS[provider.id] && EXECUTION_ADAPTERS[provider.id].method) || provider.class
+  };
+}
+
+function recordAutomation(projectRoot, record, opts = {}) {
+  if (!opts.confirmedHostSuccess) {
+    throw new Error('confirmedHostSuccess is required before recording automation');
+  }
+  const file = path.join(projectRoot, CONFIG_PATH);
+  const config = readConfig(projectRoot);
+  const next = config.automations.filter(item =>
+    !(item.id === record.id && item.provider === record.provider)
+  );
+  next.push(record);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ automations: next }, null, 2)}\n`);
+  return { automations: next };
+}
+
 function readConfig(projectRoot) {
   const file = path.join(projectRoot, CONFIG_PATH);
   if (!fs.existsSync(file)) return { automations: [] };
@@ -407,5 +588,9 @@ module.exports = {
   render,
   setupPlan,
   renderSetupPlan,
+  selectTemplates,
+  buildExecutionPlan,
+  buildAutomationRecord,
+  recordAutomation,
   readConfig
 };