# Global CLI
npm install -g fusion-agent

# Project dependency
npm install fusion-agent

# From source
git clone https://github.com/fury-r/fusion-agent.git
cd fusion-agent
npm install && npm run build

# Pick at least one
export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-ant-...
export GEMINI_API_KEY=AIza...

{
  "provider": "openai",
  "model":    "gpt-4o",
  "port":     3000,
  "sessionDir": "~/.fusion-agent/sessions",
  "github": {
    "token":            "ghp_...",
    "repoUrl":          "https://github.com/org/repo",
    "autoAssignCopilot": false
  }
}

ai-agent config --show    # print resolved config
ai-agent chat             # start interactive vibe coder

```typescript:src/middleware/auth.ts
// full corrected file content here
```

ai-agent chat [options]

  -p, --provider <name>    openai | anthropic | gemini
  -m, --model <name>       e.g. gpt-4o, claude-3-5-sonnet-20241022
  -s, --session <name>     create or resume a named session
  -k, --speckit <name>     agent persona (default: vibe-coder)
  -g, --guardrail <rule>   add a guardrail rule (repeatable)
      --context            inject project dir structure upfront

# Anthropic with guardrails + session resume
ai-agent chat \
  --provider anthropic \
  --model claude-3-5-sonnet-20241022 \
  --session my-project \
  --guardrail "Use TypeScript strict mode" \
  --guardrail "No inline styles" \
  --context

import { AgentCLI, createGuardrail } from 'fusion-agent';

const agent = new AgentCLI({ provider: 'openai' });

const session = agent.createSession({
  name:       'my-project',
  speckit:    'vibe-coder',
  projectDir: process.cwd(),
  guardrails: [
    createGuardrail('custom',     'Use TypeScript strict mode'),
    createGuardrail('deny-paths', ['secrets/', '.env']),
  ],
});

// Streaming turn
const turn = await session.chat('Add JWT authentication middleware', {
  stream:  true,
  onChunk: (chunk) => process.stdout.write(chunk),
});

console.log('Files written:', turn.fileChanges?.map(f => f.filePath));

// Revert all changes from this turn
session.revertTurnChanges(turn.id);

// Persist session
agent.sessionManager.persistSession(session);

import { AgentCLI, AutonomousVibeAgent } from 'fusion-agent';

const agent   = new AgentCLI({ provider: 'openai' });
const session = agent.createSession({
  name:    'auto-build',
  speckit: 'vibe-coder',
  projectDir: process.cwd(),
});

const auto = new AutonomousVibeAgent(session, {
  requirementsFile:  './REQUIREMENTS.md',
  maxSteps:          50,
  timeLimitSeconds:  600,
  rules: [
    { id: 'ts',       description: 'All files must be TypeScript' },
    { id: 'no-class', description: 'Use functional patterns, no classes' },
  ],
});

auto.on('step',     (step) => console.log(`Step ${step.stepNumber}`, step.filesChanged));
auto.on('complete',  (steps) => { console.log(`✓ Done in ${steps.length} steps`); });
auto.on('hil',      (req) =>  console.log('HIL:', req.confusionSummary));
auto.on('error',    (err) =>  console.error(err.message));

await auto.run();

const auto = new AutonomousVibeAgent(session, {
  requirementsContent: `
## Build a REST API
- Express server on port 3000
- GET /users returns list of users
- POST /users creates a user
- Use TypeScript, Zod for validation
`,
  maxSteps: 20,
});

# Tail a log file, notify Slack on error
ai-agent debug \
  --file /var/log/api.log \
  --log-level ERROR,FATAL \
  --batch 20 \
  --notify-slack https://hooks.slack.com/services/XXX/YYY/ZZZ \
  --ui --port 3000

# Attach to a running Docker container by name or ID
ai-agent debug \
  --docker my-api \
  --log-level ERROR,WARN \
  --batch 15 \
  --session my-api-prod \
  --ui --port 3000

# Multiple containers — start separate debuggers
ai-agent debug --docker api-service --port 3000 &
ai-agent debug --docker worker-service --port 3001 &

# Spawn a command and capture its stdout + stderr
ai-agent debug --cmd "node dist/server.js"

ai-agent debug [options]

  -f, --file <path>          watch a log file
  -d, --docker <name>        attach to Docker stdout/stderr
  -c, --cmd <command>        spawn a process and capture output
  -p, --provider <name>      openai | anthropic | gemini
  -m, --model <name>         model name override
  -s, --session <name>       named session (saved to disk)
      --log-level <lvls>     comma-separated: ERROR,FATAL,WARN,INFO
      --batch <n>            lines per AI call (default: 20)
      --retry <n>            max retries per AI call (default: 3)
      --notify-slack <url>   Slack incoming webhook URL
      --notify-teams <url>   Microsoft Teams webhook URL
      --ui                   launch web dashboard
      --port <port>          dashboard port (default: 3000)

# Only send ERROR and FATAL lines for AI analysis
ai-agent debug --docker my-api --log-level ERROR,FATAL

# Include warnings too
ai-agent debug --docker my-api --log-level ERROR,FATAL,WARN

import { AgentCLI, LiveDebugger } from 'fusion-agent';

const agent   = new AgentCLI({ provider: 'openai' });
const session = agent.createSession({ name: 'prod', speckit: 'debugger' });

const dbg = new LiveDebugger({
  session,
  batchSize:      15,
  maxWaitSeconds: 30,
  logLevels:      ['ERROR', 'FATAL'],
  notifications: {
    slack: { enabled: true, webhookUrl: process.env.SLACK_WEBHOOK },
    teams: { enabled: true, webhookUrl: process.env.TEAMS_WEBHOOK },
  },
  onAnalysis: (analysis, meta) => {
    console.log('Analysis:', analysis);
    console.log('Repeats:',  meta?.repeatCount);
    console.log('Fingerprint:', meta?.errorFingerprint);
  },
});

dbg.on('error', (err) => console.error(err.message));

// Pick one source:
dbg.watchLogFile('/var/log/app.log', 50);
// dbg.connectToService({ type: 'docker',  container: 'my-api' });
// dbg.connectToService({ type: 'process', command: 'node server.js' });
// dbg.connectToService({ type: 'http',    url: 'http://...',  intervalMs: 5000 });

process.on('SIGINT', () => dbg.stop());

import { AgentCLI } from 'fusion-agent';

const agent = new AgentCLI({ provider: 'openai' });
const sm    = agent.sessionManager;

// Create + chat
const session = agent.createSession({ name: 'my-project' });
await session.chat('Hello');
sm.persistSession(session);

// List all sessions
const all = sm.listSessions();  // SessionMeta[]

// Resume an existing session
const loaded = sm.loadSession(all[0].id);
loaded.getTurns().forEach(t => console.log(t.userMessage));

// Export to JSON string
const json = sm.exportSession(all[0].id);

// Delete
sm.deleteSession(all[0].id);

interface SessionTurn {
  id:               string;
  timestamp:        string;          // ISO 8601
  userMessage:      string;
  assistantMessage: string;
  fileChanges?: {
    filePath:        string;
    previousContent: string | null;  // null = new file
    newContent:      string;
  }[];
  usage?: {
    promptTokens:     number;
    completionTokens: number;
    totalTokens:      number;
  };
  debuggerMeta?: {
    matchedLogLines:  string[];
    promptSentAt:     string;
    repeatCount:      number;
    errorFingerprint: string;
  };
}

const agent = new AgentCLI({
  provider: 'anthropic',
  model:    'claude-3-5-sonnet-20241022',
  apiKey:   process.env.ANTHROPIC_API_KEY,
});

const turn = await session.chat('Refactor this file', {
  stream:  true,
  onChunk: (chunk) => process.stdout.write(chunk),
});

import { GitHubPatcher } from 'fusion-agent';

const patcher = new GitHubPatcher({
  token:     process.env.GITHUB_TOKEN,
  remoteUrl: 'https://github.com/org/my-repo',
  branch:    'fusion-agent/auto-fix',
});

const result = await patcher.applyAndCommit({
  files: {
    'src/services/user.ts': newContent,
    'src/utils/auth.ts':    otherContent,
  },
  commitMessage:    'fix: resolve null-pointer in UserService',
  pullRequestTitle: 'Auto-fix from Live Debugger',
  baseBranch:       'main',
});

console.log('Branch:', result.branch);
console.log('Commit:', result.commitSha);
console.log('PR URL:', result.pullRequestUrl);

import { GitPatchApplier } from 'fusion-agent';

const applier = new GitPatchApplier({
  repoDir:  process.cwd(),
  branch:   'fusion-agent/auto-fix',
  remote:   'origin',
  pushAfterCommit: true,
});

await applier.applyAndCommit({
  files:         { 'src/utils/auth.ts': newContent },
  commitMessage: 'fix: auth token expiry bug',
});

import { JiraClient } from 'fusion-agent';

const jira = new JiraClient({
  baseUrl:    'https://your-org.atlassian.net',
  email:      'you@example.com',
  apiToken:   process.env.JIRA_TOKEN,
  projectKey: 'ENG',
  issueType:  'Bug',
});

const issue = await jira.createIssue({
  summary:     'NullPointerException in UserService.getById',
  description: aiAnalysisText,
  priority:    'High',
  labels:      ['auto-detected', 'live-debugger'],
});

console.log('Created:', issue.key, issue.url);

{
  "jira": {
    "baseUrl":    "https://your-org.atlassian.net",
    "email":      "you@example.com",
    "apiToken":   "<jira-api-token>",
    "projectKey": "ENG",
    "issueType":  "Bug"
  }
}

import { GitHubClient } from 'fusion-agent';

const gh = new GitHubClient({
  token:   process.env.GITHUB_TOKEN,
  repoUrl: 'https://github.com/org/my-repo',
});

const result = await gh.createIssueForCopilot(
  '[Auto] Fix NullPointerException in UserService',
  aiAnalysisText,
  ['bug', 'auto-detected'],
);

console.log('Issue #' + result.issueNumber, result.issueUrl);
console.log('Copilot assigned:', result.copilotAssigned);

{
  "github": {
    "token":             "ghp_...",
    "repoUrl":           "https://github.com/org/repo",
    "autoAssignCopilot": true
  }
}

ai-agent chat \
  --guardrail "deny-path:secrets/" \
  --guardrail "max-files:5" \
  --guardrail "Use TypeScript strict mode"

import { createGuardrail } from 'fusion-agent';

const session = agent.createSession({
  guardrails: [
    createGuardrail('custom',     'Use TypeScript strict mode'),
    createGuardrail('deny-paths', ['secrets/', '.env', '*.pem']),
    createGuardrail('max-files',  5),
  ],
});

ai-agent chat --speckit debugger

const session = agent.createSession({ speckit: 'code-review' });

import { registerSpeckit } from 'fusion-agent';

registerSpeckit({
  name:        'security-auditor',
  description: 'Reviews code for OWASP Top 10 vulnerabilities',
  systemPrompt: `You are a security expert specialising in web application security.
When reviewing code:
1. Check for injection vulnerabilities (SQL, XSS, SSTI)
2. Verify authentication and authorisation
3. Look for insecure direct object references

For every vulnerability, provide:
- Severity: Critical / High / Medium / Low
- CWE reference
- Minimal PoC exploit
- Exact fix with \`\`\`language:filepath\`\`\` blocks`,
  examples: [
    'Review this Express route for SQL injection',
    'Is this JWT verification correct?',
  ],
});

const res = await fetch(`/api/debugger/${sessionId}/preview-git-fix`, {
  method:  'POST',
  headers: { 'Content-Type': 'application/json' },
  body:    JSON.stringify({ turnId: 'turn-abc123' }),
});

// { changes: [{ filePath, before, after }] }
const { changes } = await res.json();
changes.forEach(c =>
  console.log(c.filePath, c.before === null ? 'NEW' : 'MODIFIED')
);

# Watch cluster with rules file, auto-remediate
ai-agent cluster \
  --rules ./cluster-debug-rules.yaml \
  --mode remediate \
  --namespace production \
  --notify-slack https://hooks.slack.com/services/XXX/YYY/ZZZ \
  --ui --port 3000

ai-agent cluster [options]

      --rules <path>       YAML rules file (default: ./cluster-debug-rules.yaml)
      --mode <mode>        monitor | diagnose | remediate
      --namespace <ns>     Kubernetes namespace (default: default)
      --interval <secs>    poll interval seconds (default: 30)
      --notify-slack <url> Slack webhook for alerts
      --notify-teams <url> Teams webhook for alerts
      --ui                 open web dashboard
      --port <port>        dashboard port (default: 3000)

rules:
  - id: crash-loop
    description: Detect CrashLoopBackOff pods
    condition: pod.status == "CrashLoopBackOff"
    severity: critical
    actions:
      - type: restart-pod
      - type: notify
      - type: ai-diagnose

  - id: high-cpu
    description: Pod CPU usage above 90%
    condition: pod.cpu > 90
    severity: warning
    actions:
      - type: scale-up
        replicas: 2
      - type: notify

  - id: oom-killed
    description: OOMKilled containers
    condition: pod.status == "OOMKilled"
    severity: critical
    actions:
      - type: ai-diagnose
      - type: notify

import { ClusterMonitor } from 'fusion-agent';

const monitor = new ClusterMonitor({
  mode:       'remediate',
  namespace:  'production',
  rulesFile:  './cluster-debug-rules.yaml',
  intervalMs: 30_000,
  notifications: {
    slack: { enabled: true, webhookUrl: process.env.SLACK_WEBHOOK },
  },
});

monitor.on('violation',   (v) => console.log('Rule violated:', v.ruleId, v.podName));
monitor.on('remediation', (r) => console.log('Action taken:',  r.action, r.outcome));
monitor.on('analysis',    (a) => console.log('AI diagnosis:',  a.text));

await monitor.start();
process.on('SIGINT', () => monitor.stop());

import { registerSkill, getSkill, listSkills } from 'fusion-agent';

registerSkill({
  name:        'typescript-strict',
  description: 'Enforce TypeScript strict mode patterns',
  prompt:      `Always use TypeScript strict mode.
- Avoid \`any\` type; use \`unknown\` + type guards
- Prefer \`const\` over \`let\`
- Use \`readonly\` on all interface properties`,
});

// Attach skills to a session
const session = agent.createSession({
  speckit: 'vibe-coder',
  skills:  ['typescript-strict', 'prefer-zod'],
});

console.log(listSkills());           // all registered skill names
console.log(getSkill('typescript-strict').prompt);

# Add a recurring job (9 AM Mon–Fri)
ai-agent cron add \
  --name daily-review \
  --cron "0 9 * * 1-5" \
  --message "Review pull requests opened yesterday and summarise" \
  --speckit code-review

ai-agent cron list                       # list all jobs
ai-agent cron remove --name daily-review  # remove a job
ai-agent cron run    --name daily-review  # run immediately

import { CronManager } from 'fusion-agent';

const cron = new CronManager(agent);

cron.addJob({
  name:       'daily-review',
  expression: '0 9 * * 1-5',
  message:    'Review open PRs and summarise',
  speckit:    'code-review',
});

cron.on('job:start',    (name) =>        console.log(`Job started: ${name}`));
cron.on('job:complete', (name, turn) =>  console.log(turn.assistantMessage));
cron.on('job:error',    (name, err) =>   console.error(err.message));

cron.start();

console.log(cron.listJobs());
cron.removeJob('daily-review');

import { WebhookStore } from 'fusion-agent';

const store = new WebhookStore();

store.register({
  id:     'my-hook',
  url:    'https://my-service.example.com/hooks/agent',
  events: ['debugger:analysis', 'cluster:violation'],
  secret: process.env.WEBHOOK_SECRET,  // HMAC-SHA256 signing
});

console.log(store.list());
store.unregister('my-hook');

<browser-action type="navigate"   url="https://example.com" />
<browser-action type="click"      selector="#login-btn" />
<browser-action type="fill"       selector="#email"    value="user@example.com" />
<browser-action type="fill"       selector="#password" value="secret" />
<browser-action type="click"      selector="button[type=submit]" />
<browser-action type="screenshot" />

import { BrowserController } from 'fusion-agent';

const browser = new BrowserController({ headless: true });
await browser.launch();

await browser.navigate('https://example.com');
await browser.click('#login-btn');
await browser.fill('#email', 'user@example.com');

const screenshot = await browser.screenshot();  // base64 PNG
const html       = await browser.getPageSource();

await browser.close();

import { AgentBus } from 'fusion-agent';

const bus = new AgentBus();

// Agent A publishes
bus.publish('review-done', {
  sessionId: 'review-123',
  summary:   'Found 2 high severity issues',
  files:     ['src/auth.ts'],
});

// Agent B subscribes and reacts
bus.subscribe('review-done', async (payload) => {
  await fixerAgent.chat(`Fix issues in ${payload.files.join(', ')}`);
});

// Unsubscribe: call the returned function
const unsub = bus.subscribe('review-done', handler);
unsub();

# 1. Copy and fill in the config
cp deploy/live-debugger-selffix/config.example.json config.json

# 2. Edit config.json — set provider, GitHub token, repo URL

# 3. Start
cd deploy/live-debugger-selffix
docker compose up -d

{
  "provider":  "openai",
  "model":     "gpt-4o",
  "container": "my-api",
  "logLevels": ["ERROR", "FATAL"],
  "github": {
    "token":      "ghp_...",
    "repoUrl":    "https://github.com/org/repo",
    "branch":     "fusion-agent/auto-fix",
    "baseBranch": "main"
  },
  "notifications": {
    "slack": { "enabled": true, "webhookUrl": "https://hooks.slack.com/..." }
  }
}

cp deploy/live-debugger-copilot-autoassign/config.example.json config.json
# Set autoAssignCopilot: true, fill in github token + repoUrl
cd deploy/live-debugger-copilot-autoassign
docker compose up -d

{
  "provider":  "anthropic",
  "model":     "claude-3-5-sonnet-20241022",
  "container": "my-api",
  "logLevels": ["ERROR", "FATAL"],
  "github": {
    "token":             "ghp_...",
    "repoUrl":           "https://github.com/org/repo",
    "autoAssignCopilot": true
  }
}