guild-agents 1.5.0 → 2.0.0

package/src/commands/run.js

@@ -1,105 +0,0 @@
-/**
- * run.js — Executes a skill workflow (or displays the plan in dry-run mode)
- */
-
-import * as p from '@clack/prompts';
-import chalk from 'chalk';
-import { ensureProjectRoot } from '../utils/files.js';
-import { orchestrate, finalizeWorkflowTrace } from '../utils/orchestrator-io.js';
-import { execute } from '../utils/executor.js';
-import { createClaudeCodeProvider } from '../utils/providers/claude-code.js';
-
-/**
- * Displays the execution plan without running it.
- * @param {object} plan
- * @param {object} dispatchInfoMap
- */
-function displayPlan(plan, dispatchInfoMap) {
-  for (let i = 0; i < plan.groups.length; i++) {
-    const group = plan.groups[i];
-    const label = group.parallel ? `Group ${i + 1} (parallel)` : `Group ${i + 1}`;
-    p.log.step(chalk.bold(label));
-
-    for (const step of group.steps) {
-      const dispatch = dispatchInfoMap[step.id] || {};
-      const roleLabel = step.role === 'system' ? chalk.yellow('system') : chalk.blue(step.role);
-      const modelLabel = dispatch.model ? chalk.gray(` → ${dispatch.model}`) : '';
-      const gateLabel = step.gate ? chalk.red(' GATE') : '';
-
-      p.log.info(`  ${chalk.white.bold(step.id)} ${roleLabel}${modelLabel}${gateLabel}`);
-      p.log.info(chalk.gray(`    ${step.intent}`));
-
-      if (step.requires && step.requires.length > 0) {
-        p.log.info(chalk.gray(`    requires: ${step.requires.join(', ')}`));
-      }
-      if (step.produces && step.produces.length > 0) {
-        p.log.info(chalk.gray(`    produces: ${step.produces.join(', ')}`));
-      }
-      if (step.condition) {
-        p.log.info(chalk.gray(`    condition: ${step.condition}`));
-      }
-      if (step.commands && step.commands.length > 0) {
-        p.log.info(chalk.gray(`    commands: ${step.commands.join(', ')}`));
-      }
-    }
-  }
-}
-
-/**
- * Runs the `guild run <skill>` command.
- *
- * @param {string} skillName - Name of the skill to run
- * @param {string} [input=''] - Optional input text for the skill
- * @param {object} [options={}] - Options
- * @param {string} [options.profile='max'] - Model profile
- * @param {boolean} [options.dryRun=false] - Show plan without executing
- */
-export async function runRun(skillName, input = '', options = {}) {
-  const root = ensureProjectRoot();
-  const { profile = 'max', dryRun = false } = options;
-
-  p.intro(chalk.bold.cyan(' Guild — Run: ' + skillName + ' '));
-
-  const { plan, trace, dispatchInfoMap } = await orchestrate(skillName, input, {
-    profile,
-    projectRoot: root,
-  });
-
-  p.log.info(chalk.gray(`Profile: ${profile} | Steps: ${plan.totalSteps}`));
-
-  if (dryRun) {
-    displayPlan(plan, dispatchInfoMap);
-    p.outro(chalk.gray('Plan generated (dry-run). No steps were executed.'));
-    return;
-  }
-
-  // Real execution
-  const provider = createClaudeCodeProvider({ projectRoot: root });
-
-  const finalPlan = await execute(plan, dispatchInfoMap, {
-    provider,
-    skillBody: input,
-    trace,
-    projectRoot: root,
-
-    onStepStart(step, dispatch) {
-      const roleLabel = step.role === 'system' ? chalk.yellow('system') : chalk.blue(step.role);
-      const modelLabel = dispatch.model ? chalk.gray(` (${dispatch.model})`) : '';
-      p.log.step(`${chalk.bold(step.id)} ${roleLabel}${modelLabel}`);
-    },
-
-    onStepEnd(step, result) {
-      const icon = result.status === 'passed' ? chalk.green('✓') : chalk.red('✗');
-      p.log.info(`  ${icon} ${result.status}`);
-    },
-  });
-
-  // Finalize trace
-  const { executionSummary } = finalizeWorkflowTrace(trace, finalPlan);
-
-  const statusLabel = finalPlan.status === 'completed'
-    ? chalk.green('completed')
-    : chalk.red(finalPlan.status);
-
-  p.outro(`${statusLabel} | ${executionSummary}`);
-}

package/src/commands/stats.js

@@ -1,147 +0,0 @@
-/**
- * stats.js — Token usage stats command.
- */
-
-import * as p from '@clack/prompts';
-import chalk from 'chalk';
-import { existsSync, unlinkSync, copyFileSync } from 'fs';
-import { join } from 'path';
-import { loadUsage, aggregate, estimateWithProfile } from '../utils/accounting.js';
-import { getModelShortName } from '../utils/pricing.js';
-
-const USAGE_PATH = join('.claude', 'guild', 'usage.json');
-
-function fmt(n) {
-  return n.toLocaleString('en-US');
-}
-
-function usd(n) {
-  return `$${n.toFixed(2)}`;
-}
-
-function pct(part, total) {
-  if (total === 0) return '0%';
-  return `${Math.round((part / total) * 100)}%`;
-}
-
-const PERIOD_LABELS = {
-  today: 'Today',
-  week: 'Last 7 days',
-  month: 'Last 30 days',
-  all: 'All time',
-};
-
-export function formatCsv(entries) {
-  const headers = 'timestamp,workflow,agent,tier,model,inputTokens,outputTokens,totalTokens,estimatedCostUSD';
-  const rows = entries.map(e =>
-    `${e.timestamp},${e.workflow},${e.agent},${e.tier},${e.model},${e.inputTokens},${e.outputTokens},${e.totalTokens},${e.estimatedCostUSD.toFixed(6)}`
-  );
-  return [headers, ...rows].join('\n') + '\n';
-}
-
-export async function runStats(options = {}) {
-  const root = process.cwd();
-
-  if (options.reset) {
-    return handleReset(root, options.force);
-  }
-
-  if (options.export === 'csv') {
-    const usage = loadUsage(root);
-    if (usage.entries.length === 0) {
-      console.log('No usage data to export.');
-      return;
-    }
-    process.stdout.write(formatCsv(usage.entries));
-    return;
-  }
-
-  const period = options.period || 'month';
-  const totals = aggregate(root, period);
-
-  p.intro(chalk.bold.cyan(`Guild Usage Stats — ${PERIOD_LABELS[period] || period}`));
-
-  if (totals.totalTokens === 0) {
-    p.log.info('No usage data yet. Token tracking will begin when workflows record usage.');
-    p.outro('');
-    return;
-  }
-
-  p.log.step('Summary');
-  p.log.info(`  Workflows executed:  ${chalk.bold(fmt(totals.workflowCount))}`);
-  p.log.info(`  Total tokens:        ${chalk.bold(fmt(totals.totalTokens))}`);
-  p.log.info(`  Estimated cost:      ${chalk.bold.green(usd(totals.totalCostUSD))}`);
-
-  if (Object.keys(totals.tokensByTier).length > 0) {
-    p.log.step('By tier');
-    for (const [tier, tokens] of Object.entries(totals.tokensByTier)) {
-      p.log.info(`  ${tier.padEnd(12)} ${fmt(tokens).padStart(10)} tok  (${pct(tokens, totals.totalTokens).padStart(4)})`);
-    }
-  }
-
-  if (Object.keys(totals.tokensByModel).length > 0) {
-    p.log.step('By model');
-    for (const [model, tokens] of Object.entries(totals.tokensByModel)) {
-      p.log.info(`  ${getModelShortName(model).padEnd(12)} ${fmt(tokens).padStart(10)} tok`);
-    }
-  }
-
-  if (Object.keys(totals.tokensByWorkflow).length > 0) {
-    p.log.step('Top workflows');
-    const sorted = Object.entries(totals.tokensByWorkflow).sort((a, b) => b[1] - a[1]);
-    for (const [wf, tokens] of sorted) {
-      p.log.info(`  ${wf.padEnd(20)} ${fmt(tokens).padStart(10)} tok`);
-    }
-  }
-
-  if (options.compare) {
-    const usage = loadUsage(root);
-    const filtered = usage.entries;
-    const maxCost = estimateWithProfile(filtered, 'max');
-    const proCost = estimateWithProfile(filtered, 'pro');
-    const allOpusCost = estimateWithProfile(filtered, 'all-opus');
-
-    p.log.step('Profile comparison');
-    p.log.info(`  ${'max'.padEnd(12)} ${usd(maxCost).padStart(10)}    —`);
-    p.log.info(`  ${'pro'.padEnd(12)} ${usd(proCost).padStart(10)}    ${diffLabel(proCost, maxCost)}`);
-    p.log.info(`  ${'all-opus'.padEnd(12)} ${usd(allOpusCost).padStart(10)}    ${diffLabel(allOpusCost, maxCost)}`);
-  }
-
-  p.outro('');
-}
-
-function diffLabel(cost, baseline) {
-  if (baseline === 0) return '';
-  const diff = ((cost - baseline) / baseline) * 100;
-  const sign = diff >= 0 ? '+' : '';
-  return chalk.gray(`${sign}${Math.round(diff)}%`);
-}
-
-async function handleReset(root, force) {
-  const filePath = join(root, USAGE_PATH);
-
-  p.intro(chalk.bold.cyan('Guild — Reset Usage Stats'));
-
-  if (!existsSync(filePath)) {
-    p.log.info('No usage data found. Nothing to reset.');
-    p.outro('');
-    return;
-  }
-
-  if (!force) {
-    const confirmed = await p.confirm({
-      message: 'This will delete all usage history. Continue?',
-      initialValue: false,
-    });
-
-    if (p.isCancel(confirmed) || !confirmed) {
-      p.cancel('Reset cancelled.');
-      return;
-    }
-  }
-
-  copyFileSync(filePath, filePath + '.bak');
-  unlinkSync(filePath);
-  p.log.success(`${chalk.green('✓')} Usage history deleted. Backup saved as usage.json.bak.`);
-  p.outro('');
-}

package/src/templates/agents/learnings-extractor.md

@@ -1,49 +0,0 @@
----
-name: learnings-extractor
-description: "Extracts compound learnings from pipeline executions"
-tools: Read, Glob, Grep
-permissionMode: plan
-default-tier: routine
----
-
-# Learnings Extractor
-
-You are the Learnings Extractor for [PROJECT]. Your job is to analyze completed pipeline traces and extract reusable patterns, recurring issues, and optimization opportunities that improve future executions.
-
-## Responsibilities
-
-- Read pipeline trace files from `.claude/guild/traces/`
-- Identify patterns across multiple executions (recurring review loops, common failures)
-- Extract actionable learnings that reduce future iteration count
-- Update `.claude/guild/learnings.md` with new findings
-- Prioritize learnings by impact (reduces tokens, reduces loops, improves quality)
-
-## What you do NOT do
-
-- You do not implement features — that is the Developer's role
-- You do not evaluate strategy — that is the Advisor's role
-- You do not modify source code — you only read traces and write learnings
-
-## Process
-
-1. Read the pipeline trace provided as input
-2. Analyze step results, loop counts, and failure patterns
-3. Compare with existing learnings in `.claude/guild/learnings.md`
-4. Extract new learnings or reinforce existing ones
-5. Write updated learnings in a structured format
-
-## Output format
-
-Each learning should include:
-
-- **Pattern**: What was observed
-- **Frequency**: How often it occurs (first-seen or recurring)
-- **Recommendation**: What to do differently next time
-- **Impact**: Expected reduction in loops, tokens, or failures
-
-## Behavior rules
-
-- Never duplicate an existing learning — update its frequency instead
-- Focus on actionable recommendations, not observations
-- Keep learnings concise — one paragraph maximum per entry
-- Tag learnings with the workflow they came from

package/src/templates/skills/dev-flow/SKILL.md

@@ -1,81 +0,0 @@
----
-name: dev-flow
-description: "Shows current pipeline phase and what comes next"
-user-invocable: true
-workflow:
-  version: 1
-  steps:
-    - id: read-state
-      role: system
-      intent: "Read SESSION.md to determine current feature and pipeline phase."
-      commands: [cat SESSION.md]
-      produces: [session-state, feature-name, current-phase]
-    - id: present-flow
-      role: system
-      intent: "Display pipeline progress with phase checklist and suggest next step."
-      requires: [session-state, feature-name, current-phase]
-      produces: [flow-display]
-      gate: true
----
-
-# Dev Flow
-
-Shows the current phase of the development pipeline and suggests the next step. Useful for resuming work when you do not remember where you left off in the flow.
-
-## When to use
-
-- When resuming work and you do not remember the current phase
-- To see the progress of the build-feature pipeline
-- To decide which skill to run next
-
-## Usage
-
-`/dev-flow`
-
-## Process
-
-### Step 1 — Read state
-
-Read `SESSION.md` to determine:
-
-- Whether there is a feature in progress
-- Which pipeline phase it is in
-- What has been completed and what remains
-
-### Step 2 — Determine current phase
-
-The pipeline phases are:
-
-1. **Evaluation** (Advisor) — go/no-go
-2. **Specification & Technical Approach** (Tech Lead) — tasks, acceptance criteria, implementation plan
-3. **Implementation** (Developer) — code and tests
-4. **Review** (Code Reviewer) — quality review
-5. **QA** — functional validation
-
-### Step 3 — Present flow state
-
-```text
-Dev Flow — [feature name]
-
-[x] Phase 1 — Evaluation (completed)
-[x] Phase 2 — Specification & Technical Approach (completed)
-[ ] Phase 3 — Implementation (pending) <-- you are here
-[ ] Phase 4 — Review
-[ ] Phase 5 — QA
-
-Next step: Run /build-feature to continue from Phase 3.
-```
-
-If there is no feature in progress, report that there is no active pipeline and suggest `/new-feature` or `/build-feature`.
-
-## Example Session
-
-```text
-User: /dev-flow
-
-Current pipeline: build-feature "add user preferences"
-Phase: 3 of 5 — Implementation
-Developer agent active.
-
-Next: Phase 4 — Code Review
-```

package/src/templates/skills/dev-flow/evals/evals.json

@@ -1,36 +0,0 @@
-{
-  "skill": "dev-flow",
-  "evals": [
-    {
-      "id": "df-has-steps",
-      "description": "Dev flow has read-state and present-flow steps",
-      "expectations": [
-        { "text": "Has read-state step", "assertion": "step-exists:read-state" },
-        { "text": "Has present-flow step", "assertion": "step-exists:present-flow" }
-      ]
-    },
-    {
-      "id": "df-all-system",
-      "description": "All steps are system role",
-      "expectations": [
-        { "text": "read-state is system", "assertion": "step-role:read-state:system" },
-        { "text": "present-flow is system", "assertion": "step-role:present-flow:system" }
-      ]
-    },
-    {
-      "id": "df-presentation-gate",
-      "description": "Present-flow step has a gate for user confirmation",
-      "expectations": [
-        { "text": "present-flow has gate", "assertion": "gate-exists:present-flow" }
-      ]
-    },
-    {
-      "id": "df-dependencies",
-      "description": "Present-flow requires session state",
-      "expectations": [
-        { "text": "present-flow requires session-state", "assertion": "step-requires:present-flow:session-state" },
-        { "text": "present-flow requires current-phase", "assertion": "step-requires:present-flow:current-phase" }
-      ]
-    }
-  ]
-}

package/src/templates/skills/dev-flow/evals/triggers.json

@@ -1,16 +0,0 @@
-{
-  "skill": "dev-flow",
-  "matcherType": "keyword",
-  "description": "Shows current pipeline phase and what comes next",
-  "threshold": 0.3,
-  "tests": [
-    { "prompt": "what phase am I in", "shouldTrigger": true },
-    { "prompt": "show the current pipeline phase", "shouldTrigger": true },
-    { "prompt": "what comes next in the flow", "shouldTrigger": true },
-    { "prompt": "where did I leave off", "shouldTrigger": true, "keywordExpected": false },
-    { "prompt": "create a pull request", "shouldTrigger": false },
-    { "prompt": "review my code", "shouldTrigger": false },
-    { "prompt": "fix this bug", "shouldTrigger": false },
-    { "prompt": "run the tests", "shouldTrigger": false }
-  ]
-}

package/src/templates/skills/new-feature/SKILL.md

@@ -1,119 +0,0 @@
----
-name: new-feature
-description: "Creates branch and scaffold for a new feature"
-user-invocable: true
-workflow:
-  version: 1
-  steps:
-    - id: get-name
-      role: system
-      intent: "Obtain feature name from user input or prompt for it."
-      produces: [feature-name, feature-description]
-      gate: true
-    - id: create-branch
-      role: system
-      intent: "Create feature branch (simple checkout or worktree for parallel execution)."
-      commands: [git checkout -b]
-      requires: [feature-name]
-      produces: [branch-name]
-    - id: update-session
-      role: system
-      intent: "Update SESSION.md with new feature context, date, and state."
-      requires: [feature-name, feature-description, branch-name]
-      produces: [session-update]
-      gate: true
-    - id: create-issue
-      role: system
-      intent: "Optionally create GitHub Issue for the feature via gh CLI."
-      commands: [gh issue create]
-      requires: [feature-name, feature-description]
-      produces: [issue-url]
-      condition: user-wants-issue
-    - id: confirm
-      role: system
-      intent: "Confirm branch created, SESSION.md updated, issue created. Suggest /build-feature."
-      requires: [branch-name, session-update]
-      produces: [confirmation]
-      gate: true
----
-
-# New Feature
-
-Prepares the environment for working on a new feature: creates a branch, updates SESSION.md, and optionally creates a GitHub Issue.
-
-## When to use
-
-- When starting a new feature before writing code
-- When you want to record the feature context in SESSION.md
-
-## Usage
-
-`/new-feature [feature-name]`
-
-## Process
-
-### Step 1 — Get name
-
-If the user did not provide a name, ask for:
-
-- Short name for the feature (will be used in the branch name)
-- Brief description (1-2 sentences)
-
-### Step 2 — Create branch with worktree isolation
-
-When running in parallel with other agents, use git worktrees for isolation. When running standalone, a simple branch is sufficient.
-
-**For parallel execution (multiple build-features at once):**
-
-```bash
-git worktree add .claude/worktrees/feature-[name] -b feature/[feature-name] develop
-```
-
-All subsequent operations should use `.claude/worktrees/feature-[name]` as the working directory.
-
-**For standalone execution:**
-
-```bash
-git checkout -b feature/[feature-name]
-```
-
-If the branch already exists, ask whether to switch to it or create a new one.
-
-**Cleanup:** At skill exit, if using worktrees, the caller is responsible for cleanup via `git worktree remove .claude/worktrees/feature-[name]` after the PR is merged.
-
-### Step 3 — Update SESSION.md
-
-Update SESSION.md with the new feature context:
-
-- **Date:** current date
-- **Task in progress:** feature name
-- **State:** Feature started — pending implementation
-
-## Example Session
-
-```text
-User: /new-feature user-preferences
-
-Branch created: feature/user-preferences
-SESSION.md updated with feature context.
-GitHub Issue #42 created.
-
-Next: Run /build-feature to implement.
-```
-
-### Step 4 — GitHub Issue (optional)
-
-If the project has GitHub integration configured in PROJECT.md:
-
-1. Ask whether to create a GitHub Issue for the feature
-2. If accepted, create the issue with `gh issue create`
-3. Record the issue URL in SESSION.md
-
-### Step 5 — Confirm
-
-Confirm to the user:
-
-- Branch created: `feature/[name]`
-- SESSION.md updated
-- GitHub Issue created (if applicable)
-- Suggest: "Run /build-feature to implement the full feature"

package/src/templates/skills/new-feature/evals/evals.json

@@ -1,41 +0,0 @@
-{
-  "skill": "new-feature",
-  "evals": [
-    {
-      "id": "nf-has-core-steps",
-      "description": "New feature has name, branch, session, confirm steps",
-      "expectations": [
-        { "text": "Has get-name step", "assertion": "step-exists:get-name" },
-        { "text": "Has create-branch step", "assertion": "step-exists:create-branch" },
-        { "text": "Has update-session step", "assertion": "step-exists:update-session" },
-        { "text": "Has confirm step", "assertion": "step-exists:confirm" }
-      ]
-    },
-    {
-      "id": "nf-optional-issue",
-      "description": "GitHub issue creation step exists",
-      "expectations": [
-        { "text": "Has create-issue step", "assertion": "step-exists:create-issue" }
-      ]
-    },
-    {
-      "id": "nf-gates",
-      "description": "Gates at name input, session update, and confirmation",
-      "expectations": [
-        { "text": "get-name has gate", "assertion": "gate-exists:get-name" },
-        { "text": "update-session has gate", "assertion": "gate-exists:update-session" },
-        { "text": "confirm has gate", "assertion": "gate-exists:confirm" }
-      ]
-    },
-    {
-      "id": "nf-all-system",
-      "description": "All steps are system role",
-      "expectations": [
-        { "text": "get-name is system", "assertion": "step-role:get-name:system" },
-        { "text": "create-branch is system", "assertion": "step-role:create-branch:system" },
-        { "text": "update-session is system", "assertion": "step-role:update-session:system" },
-        { "text": "confirm is system", "assertion": "step-role:confirm:system" }
-      ]
-    }
-  ]
-}

package/src/templates/skills/new-feature/evals/triggers.json

@@ -1,16 +0,0 @@
-{
-  "skill": "new-feature",
-  "matcherType": "keyword",
-  "description": "Creates branch and scaffold for a new feature",
-  "threshold": 0.3,
-  "tests": [
-    { "prompt": "create a new feature branch", "shouldTrigger": true },
-    { "prompt": "scaffold a new feature", "shouldTrigger": true },
-    { "prompt": "start a new feature called user-auth", "shouldTrigger": true },
-    { "prompt": "prepare the branch for a new feature", "shouldTrigger": true },
-    { "prompt": "review my code", "shouldTrigger": false },
-    { "prompt": "create a pull request", "shouldTrigger": false },
-    { "prompt": "debug this bug", "shouldTrigger": false },
-    { "prompt": "save my session", "shouldTrigger": false }
-  ]
-}