@m8i-51/shoal 0.1.10 → 0.1.11

package/.env.example

@@ -62,12 +62,37 @@ TARGET=none             # example | none | カスタムターゲット名
 BASE_URL=http://localhost:3000
 
 # ================================================================
-# GitHub Issues (optional)
+# Issue Tracker (optional)
 # ================================================================
+# カンマ区切りで複数のトラッカーを同時に有効化できます。
+# ISSUE_TRACKERS が未設定で GITHUB_TOKEN/GITHUB_REPO がある場合は github が自動で有効になります。
 
+# ISSUE_TRACKERS=github,backlog
+
+# --- GitHub Issues ---
 GITHUB_TOKEN=
 GITHUB_REPO=owner/repo
 
+# --- Jira ---
+# JIRA_BASE_URL=https://yourcompany.atlassian.net
+# JIRA_EMAIL=user@example.com
+# JIRA_API_TOKEN=
+# JIRA_PROJECT_KEY=PROJ
+
+# --- Notion ---
+# NOTION_API_KEY=
+# NOTION_DATABASE_ID=
+# ※ Notion のデータベースには Name (title) / Labels (multi_select) / Status (select) プロパティが必要です
+
+# --- Backlog ---
+# BACKLOG_SPACE=yourspace
+# BACKLOG_API_KEY=
+# BACKLOG_PROJECT_ID=12345
+
+# --- Asana ---
+# ASANA_ACCESS_TOKEN=
+# ASANA_PROJECT_ID=
+
 # ================================================================
 # Run config
 # ================================================================

package/README.md

@@ -39,7 +39,7 @@ Target App (any URL)
   explore via API                  browse the real UI
         │                                  │
         └──────────────┬───────────────────┘
-                       ▼  deduplicates and files GitHub Issues
+                       ▼  deduplicates and files issue tickets
                  Triage Agent
 ```
 
@@ -56,7 +56,7 @@ At the end of each run:
 - **Feature suggestions** — things that would add real value
 - **Goal gaps** — where the app falls short of what it's trying to achieve
 
-Findings are filed as GitHub Issues or saved as a self-contained HTML report. A **web dashboard** lets you start runs, watch live progress, review findings by category, and track estimated LLM cost per run.
+Findings are filed as issue tickets (GitHub Issues, Jira, Notion, Backlog, or Asana) or saved as a self-contained HTML report. A **web dashboard** lets you start runs, watch live progress, review findings by category, and track estimated LLM cost per run.
 
 ---
 
@@ -88,6 +88,7 @@ Then run:
 ```bash
 shoal serve    # open web dashboard at http://localhost:4000
 shoal          # or run agents directly from the terminal
+shoal config   # update settings in existing .env (e.g. issue trackers)
 ```
 
 **Or clone and develop locally:**
@@ -128,10 +129,23 @@ Opens at `http://localhost:4000`. From there you can:
 | `MAX_EXPLORERS` | `4` | API explorer agent count (0 to disable) |
 | `MAX_BROWSERS` | `2` | Browser agent count |
 | `ANTHROPIC_API_KEY` | — | Required |
-| `GITHUB_TOKEN` | — | Optional — enables Issue creation |
-| `GITHUB_REPO` | — | `owner/repo` format |
+| `ISSUE_TRACKERS` | — | Comma-separated list of active trackers: `github`, `jira`, `notion`, `backlog`, `asana` |
 | `REFRESH_SPEC` | — | Set to `1` to re-run product discovery |
 
+**Issue tracker variables** (set only what you need):
+
+| Tracker | Variables |
+|---|---|
+| GitHub Issues | `GITHUB_TOKEN`, `GITHUB_REPO` (`owner/repo`) |
+| Jira | `JIRA_BASE_URL`, `JIRA_EMAIL`, `JIRA_API_TOKEN`, `JIRA_PROJECT_KEY` |
+| Notion | `NOTION_API_KEY`, `NOTION_DATABASE_ID` ¹ |
+| Backlog | `BACKLOG_SPACE`, `BACKLOG_API_KEY`, `BACKLOG_PROJECT_ID` |
+| Asana | `ASANA_ACCESS_TOKEN`, `ASANA_PROJECT_ID` |
+
+¹ The Notion database must have `Name` (title), `Labels` (multi_select), and `Status` (select) properties.
+
+Multiple trackers can be active at the same time — findings are posted to all of them. If `ISSUE_TRACKERS` is not set but `GITHUB_TOKEN` and `GITHUB_REPO` are present, GitHub is used automatically (backward compatible).
+
 ---
 
 ## Adding a target

package/bin/init.js

@@ -1,5 +1,5 @@
-import { intro, outro, select, text, confirm, isCancel, cancel } from "@clack/prompts";
-import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { intro, outro, select, multiselect, text, confirm, isCancel, cancel } from "@clack/prompts";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 
 const PROVIDERS = [
@@ -101,19 +101,9 @@ export async function runInit(cwd) {
     defaultValue: "http://localhost:3000",
   }));
 
-  // ── GitHub (optional) ─────────────────────────────────────────────
-  const githubToken = guard(await text({
-    message: "GitHub token  (optional — for Issue creation)",
-    placeholder: "ghp_...  leave blank to skip",
-  }));
-  if (githubToken.trim()) {
-    env.GITHUB_TOKEN = githubToken.trim();
-    const githubRepo = guard(await text({
-      message: "GitHub repo",
-      placeholder: "owner/repo",
-    }));
-    if (githubRepo.trim()) env.GITHUB_REPO = githubRepo.trim();
-  }
+  // ── Issue trackers (optional) ─────────────────────────────────────
+  const trackerEnv = await promptTrackers();
+  Object.assign(env, trackerEnv);
 
   // ── Write .env ────────────────────────────────────────────────────
   const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
@@ -184,3 +174,174 @@ jobs:
 
   outro("Created .env\n\n  shoal serve   — open the dashboard at http://localhost:4000\n  shoal         — run agents from the terminal");
 }
+
+// ── Tracker config helpers ─────────────────────────────────────────
+
+const TRACKER_KEYS = [
+  "ISSUE_TRACKERS",
+  "GITHUB_TOKEN", "GITHUB_REPO",
+  "JIRA_BASE_URL", "JIRA_EMAIL", "JIRA_API_TOKEN", "JIRA_PROJECT_KEY",
+  "NOTION_API_KEY", "NOTION_DATABASE_ID",
+  "BACKLOG_SPACE", "BACKLOG_API_KEY", "BACKLOG_PROJECT_ID",
+  "ASANA_ACCESS_TOKEN", "ASANA_PROJECT_ID",
+];
+
+function parseEnv(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) continue;
+    result[trimmed.slice(0, idx)] = trimmed.slice(idx + 1);
+  }
+  return result;
+}
+
+function updateEnvFile(envPath, newKeys, removeKeys) {
+  const content = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+  const lines = content.split("\n").filter((line) => {
+    const key = line.split("=")[0].trim();
+    return !removeKeys.includes(key);
+  });
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+  const newLines = Object.entries(newKeys).map(([k, v]) => `${k}=${v}`);
+  writeFileSync(envPath, [...lines, "", ...newLines, ""].join("\n"), "utf-8");
+}
+
+async function promptTrackers(existing = {}) {
+  const currentTrackers = (existing.ISSUE_TRACKERS ?? "")
+    .split(",").map((s) => s.trim()).filter(Boolean);
+
+  const selectedTrackers = guard(await multiselect({
+    message: "Issue trackers  (select all that apply; leave empty to save locally only)",
+    options: [
+      { value: "github",  label: "GitHub Issues", selected: currentTrackers.includes("github") },
+      { value: "jira",    label: "Jira",           selected: currentTrackers.includes("jira") },
+      { value: "notion",  label: "Notion",          selected: currentTrackers.includes("notion") },
+      { value: "backlog", label: "Backlog",         selected: currentTrackers.includes("backlog") },
+      { value: "asana",   label: "Asana",           selected: currentTrackers.includes("asana") },
+    ],
+    required: false,
+  }));
+
+  const env = {};
+
+  if (selectedTrackers.length > 0) {
+    env.ISSUE_TRACKERS = selectedTrackers.join(",");
+  }
+
+  if (selectedTrackers.includes("github")) {
+    env.GITHUB_TOKEN = guard(await text({
+      message: "GitHub token",
+      placeholder: "ghp_...",
+      initialValue: existing.GITHUB_TOKEN ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.GITHUB_REPO = guard(await text({
+      message: "GitHub repo",
+      placeholder: "owner/repo",
+      initialValue: existing.GITHUB_REPO ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+  }
+
+  if (selectedTrackers.includes("jira")) {
+    env.JIRA_BASE_URL = guard(await text({
+      message: "Jira base URL",
+      placeholder: "https://yourcompany.atlassian.net",
+      initialValue: existing.JIRA_BASE_URL ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.JIRA_EMAIL = guard(await text({
+      message: "Jira account email",
+      initialValue: existing.JIRA_EMAIL ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.JIRA_API_TOKEN = guard(await text({
+      message: "Jira API token",
+      initialValue: existing.JIRA_API_TOKEN ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.JIRA_PROJECT_KEY = guard(await text({
+      message: "Jira project key",
+      placeholder: "PROJ",
+      initialValue: existing.JIRA_PROJECT_KEY ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+  }
+
+  if (selectedTrackers.includes("notion")) {
+    env.NOTION_API_KEY = guard(await text({
+      message: "Notion API key",
+      placeholder: "secret_...",
+      initialValue: existing.NOTION_API_KEY ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.NOTION_DATABASE_ID = guard(await text({
+      message: "Notion database ID",
+      hint: "DB must have Name (title), Labels (multi_select), Status (select) properties",
+      initialValue: existing.NOTION_DATABASE_ID ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+  }
+
+  if (selectedTrackers.includes("backlog")) {
+    env.BACKLOG_SPACE = guard(await text({
+      message: "Backlog space name",
+      placeholder: "yourspace  (from yourspace.backlog.com)",
+      initialValue: existing.BACKLOG_SPACE ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.BACKLOG_API_KEY = guard(await text({
+      message: "Backlog API key",
+      initialValue: existing.BACKLOG_API_KEY ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.BACKLOG_PROJECT_ID = guard(await text({
+      message: "Backlog project ID  (numeric)",
+      initialValue: existing.BACKLOG_PROJECT_ID ?? "",
+      validate: (v) => /^\d+$/.test(v?.trim()) ? undefined : "Must be a number",
+    }));
+  }
+
+  if (selectedTrackers.includes("asana")) {
+    env.ASANA_ACCESS_TOKEN = guard(await text({
+      message: "Asana personal access token",
+      initialValue: existing.ASANA_ACCESS_TOKEN ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+    env.ASANA_PROJECT_ID = guard(await text({
+      message: "Asana project ID",
+      initialValue: existing.ASANA_PROJECT_ID ?? "",
+      validate: (v) => v?.trim() ? undefined : "Required",
+    }));
+  }
+
+  return env;
+}
+
+export async function runConfig(cwd) {
+  const envPath = join(cwd, ".env");
+
+  if (!existsSync(envPath)) {
+    console.log(".env not found. Run shoal init first.");
+    process.exit(1);
+  }
+
+  intro("shoal config");
+
+  const section = guard(await select({
+    message: "What do you want to configure?",
+    options: [
+      { value: "trackers", label: "Issue trackers" },
+    ],
+  }));
+
+  if (section === "trackers") {
+    const existing = parseEnv(readFileSync(envPath, "utf-8"));
+    const newTrackerEnv = await promptTrackers(existing);
+    updateEnvFile(envPath, newTrackerEnv, TRACKER_KEYS);
+    outro("Updated .env — run shoal to apply changes");
+  }
+}

package/bin/shoal.js

@@ -4,6 +4,7 @@
  *
  * Usage:
  *   shoal init     # interactive setup — creates .env in current directory
+ *   shoal config   # update settings in existing .env (e.g. issue trackers)
  *   shoal serve    # web dashboard at http://localhost:4000
  *   shoal          # run agents from the terminal
  *   shoal triage   # triage-only mode
@@ -25,6 +26,13 @@ async function main() {
     process.exit(0);
   }
 
+  // config — 既存の .env を対話形式で更新する
+  if (subcommand === "config") {
+    const { runConfig } = await import("./init.js");
+    await runConfig(process.cwd());
+    process.exit(0);
+  }
+
   // serve の場合、web/dist が存在しなければ自動ビルドする
   if (subcommand === "serve") {
     const distIndex = join(packageRoot, "web", "dist", "index.html");

package/framework/scenario-designer.ts

@@ -59,7 +59,7 @@ const OUTPUT_SCENARIOS_TOOL: Anthropic.Tool = {
 
 export async function designScenarios(
   spec: ProductSpec,
-  openIssues: { number: number; title: string; labels: string[] }[],
+  openIssues: { number: number | string; title: string; labels: string[] }[],
   client: LLMClient,
   model: string,
   count: number = 5,

package/framework/trackers/asana.ts

@@ -0,0 +1,70 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+
+export class AsanaTracker implements IssueTracker {
+  readonly name = "asana";
+  private token: string;
+  private projectId: string;
+
+  constructor(token: string, projectId: string) {
+    this.token = token;
+    this.projectId = projectId;
+  }
+
+  private get headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+  }
+
+  async createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    const res = await fetch("https://app.asana.com/api/1.0/tasks", {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        data: {
+          name: title,
+          notes: `${body}\n\nLabels: ${labels.join(", ")}`,
+          projects: [this.projectId],
+        },
+      }),
+    });
+    const data = await res.json() as {
+      data?: { gid: string; permalink_url?: string };
+      errors?: { message: string }[];
+    };
+    if (!res.ok) {
+      console.error(`[asana] failed to create task (${res.status}): ${JSON.stringify(data.errors)}`);
+      return null;
+    }
+    const url = data.data?.permalink_url ?? `https://app.asana.com/0/${this.projectId}/${data.data?.gid}`;
+    console.log(`[asana] task created: ${url}`);
+    return url;
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    const res = await fetch(
+      `https://app.asana.com/api/1.0/tasks?project=${this.projectId}&completed_since=now&opt_fields=gid,name&limit=50`,
+      { headers: this.headers }
+    );
+    if (!res.ok) return [];
+    const data = await res.json() as { data?: { gid: string; name: string }[] };
+    return (data.data ?? []).map((t) => ({ number: t.gid, title: t.name, labels: [] }));
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    const res = await fetch(
+      `https://app.asana.com/api/1.0/tasks?project=${this.projectId}&completed=true&opt_fields=gid,name,notes&limit=20`,
+      { headers: this.headers }
+    );
+    if (!res.ok) return [];
+    const data = await res.json() as { data?: { gid: string; name: string; notes: string }[] };
+    return (data.data ?? []).map((t) => ({
+      number: t.gid,
+      title: t.name,
+      body: t.notes ?? "",
+      labels: [],
+    }));
+  }
+}

package/framework/trackers/backlog.ts

@@ -0,0 +1,70 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+
+export class BacklogTracker implements IssueTracker {
+  readonly name = "backlog";
+  private baseUrl: string;
+  private apiKey: string;
+  private projectId: number;
+
+  constructor(space: string, apiKey: string, projectId: number) {
+    this.baseUrl = `https://${space}.backlog.com`;
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+  }
+
+  private endpoint(path: string, params?: Record<string, string>): string {
+    const q = new URLSearchParams({ apiKey: this.apiKey, ...params });
+    return `${this.baseUrl}/api/v2${path}?${q}`;
+  }
+
+  async createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    const form = new URLSearchParams({
+      projectId: String(this.projectId),
+      summary: title,
+      description: `${body}\n\nLabels: ${labels.join(", ")}`,
+      issueTypeId: "1",
+      priorityId: "3",
+    });
+    const res = await fetch(this.endpoint("/issues"), {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: form,
+    });
+    const data = await res.json() as { issueKey?: string; message?: string };
+    if (!res.ok) {
+      console.error(`[backlog] failed to create issue (${res.status}): ${data.message}`);
+      return null;
+    }
+    const url = `${this.baseUrl}/view/${data.issueKey}`;
+    console.log(`[backlog] issue created: ${url}`);
+    return url;
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    const res = await fetch(this.endpoint("/issues", {
+      "projectId[]": String(this.projectId),
+      "statusId[]": "1",
+      count: "50",
+      keyword: "feedback-agent",
+    }));
+    if (!res.ok) return [];
+    const data = await res.json() as { issueKey: string; summary: string }[];
+    return Array.isArray(data)
+      ? data.map((i) => ({ number: i.issueKey, title: i.summary, labels: [] }))
+      : [];
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    const res = await fetch(this.endpoint("/issues", {
+      "projectId[]": String(this.projectId),
+      "statusId[]": "4",
+      count: "20",
+      keyword: "feedback-agent",
+    }));
+    if (!res.ok) return [];
+    const data = await res.json() as { issueKey: string; summary: string; description: string }[];
+    return Array.isArray(data)
+      ? data.map((i) => ({ number: i.issueKey, title: i.summary, body: i.description ?? "", labels: [] }))
+      : [];
+  }
+}

package/framework/trackers/github.ts

@@ -0,0 +1,23 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+import { postGitHubIssue, fetchOpenIssues as ghFetchOpen, fetchClosedIssues as ghFetchClosed } from "../github";
+
+export class GitHubTracker implements IssueTracker {
+  readonly name = "github";
+  private opts: { token: string; repo: string };
+
+  constructor(token: string, repo: string) {
+    this.opts = { token, repo };
+  }
+
+  createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    return postGitHubIssue(title, body, labels, this.opts);
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    return ghFetchOpen(this.opts);
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    return ghFetchClosed(this.opts);
+  }
+}

package/framework/trackers/index.ts

@@ -0,0 +1,120 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+import { GitHubTracker } from "./github";
+import { JiraTracker } from "./jira";
+import { NotionTracker } from "./notion";
+import { BacklogTracker } from "./backlog";
+import { AsanaTracker } from "./asana";
+
+export type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+
+export class AggregatedTracker implements IssueTracker {
+  readonly name = "aggregated";
+  private trackers: IssueTracker[];
+
+  constructor(trackers: IssueTracker[]) {
+    this.trackers = trackers;
+  }
+
+  get isEmpty(): boolean {
+    return this.trackers.length === 0;
+  }
+
+  async createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    if (this.trackers.length === 0) return null;
+    const urls = await Promise.all(this.trackers.map((t) => t.createIssue(title, body, labels)));
+    return urls.find((u) => u !== null) ?? null;
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    const results = await Promise.all(this.trackers.map((t) => t.fetchOpenIssues()));
+    return results.flat();
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    const results = await Promise.all(this.trackers.map((t) => t.fetchClosedIssues()));
+    return results.flat();
+  }
+}
+
+export function buildTrackers(): AggregatedTracker {
+  const raw = process.env.ISSUE_TRACKERS ?? "";
+  const enabled = raw
+    .split(",")
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+
+  // Backward compat: if ISSUE_TRACKERS not set but GITHUB_TOKEN/GITHUB_REPO are present, default to github
+  if (enabled.length === 0 && process.env.GITHUB_TOKEN && process.env.GITHUB_REPO) {
+    enabled.push("github");
+  }
+
+  const trackers: IssueTracker[] = [];
+
+  for (const name of enabled) {
+    switch (name) {
+      case "github": {
+        const token = process.env.GITHUB_TOKEN ?? "";
+        const repo = process.env.GITHUB_REPO ?? "";
+        if (token && repo) {
+          trackers.push(new GitHubTracker(token, repo));
+        } else {
+          console.warn("[trackers] github: GITHUB_TOKEN or GITHUB_REPO not set, skipping");
+        }
+        break;
+      }
+      case "jira": {
+        const baseUrl = process.env.JIRA_BASE_URL ?? "";
+        const email = process.env.JIRA_EMAIL ?? "";
+        const apiToken = process.env.JIRA_API_TOKEN ?? "";
+        const projectKey = process.env.JIRA_PROJECT_KEY ?? "";
+        if (baseUrl && email && apiToken && projectKey) {
+          trackers.push(new JiraTracker(baseUrl, email, apiToken, projectKey));
+        } else {
+          console.warn("[trackers] jira: JIRA_BASE_URL / JIRA_EMAIL / JIRA_API_TOKEN / JIRA_PROJECT_KEY required, skipping");
+        }
+        break;
+      }
+      case "notion": {
+        const token = process.env.NOTION_API_KEY ?? "";
+        const databaseId = process.env.NOTION_DATABASE_ID ?? "";
+        if (token && databaseId) {
+          trackers.push(new NotionTracker(token, databaseId));
+        } else {
+          console.warn("[trackers] notion: NOTION_API_KEY or NOTION_DATABASE_ID not set, skipping");
+        }
+        break;
+      }
+      case "backlog": {
+        const space = process.env.BACKLOG_SPACE ?? "";
+        const apiKey = process.env.BACKLOG_API_KEY ?? "";
+        const projectId = parseInt(process.env.BACKLOG_PROJECT_ID ?? "0", 10);
+        if (space && apiKey && projectId) {
+          trackers.push(new BacklogTracker(space, apiKey, projectId));
+        } else {
+          console.warn("[trackers] backlog: BACKLOG_SPACE / BACKLOG_API_KEY / BACKLOG_PROJECT_ID required, skipping");
+        }
+        break;
+      }
+      case "asana": {
+        const token = process.env.ASANA_ACCESS_TOKEN ?? "";
+        const projectId = process.env.ASANA_PROJECT_ID ?? "";
+        if (token && projectId) {
+          trackers.push(new AsanaTracker(token, projectId));
+        } else {
+          console.warn("[trackers] asana: ASANA_ACCESS_TOKEN or ASANA_PROJECT_ID not set, skipping");
+        }
+        break;
+      }
+      default:
+        console.warn(`[trackers] unknown tracker: "${name}"`);
+    }
+  }
+
+  if (trackers.length > 0) {
+    console.log(`[trackers] enabled: ${trackers.map((t) => t.name).join(", ")}`);
+  } else {
+    console.log("[trackers] no issue trackers configured — findings saved locally only");
+  }
+
+  return new AggregatedTracker(trackers);
+}

package/framework/trackers/jira.ts

@@ -0,0 +1,89 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+
+export class JiraTracker implements IssueTracker {
+  readonly name = "jira";
+  private baseUrl: string;
+  private authHeader: string;
+  private projectKey: string;
+
+  constructor(baseUrl: string, email: string, apiToken: string, projectKey: string) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.authHeader = `Basic ${Buffer.from(`${email}:${apiToken}`).toString("base64")}`;
+    this.projectKey = projectKey;
+  }
+
+  private get headers() {
+    return {
+      Authorization: this.authHeader,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+  }
+
+  async createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    const res = await fetch(`${this.baseUrl}/rest/api/3/issue`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        fields: {
+          project: { key: this.projectKey },
+          summary: title,
+          description: {
+            type: "doc",
+            version: 1,
+            content: [{ type: "paragraph", content: [{ type: "text", text: body }] }],
+          },
+          issuetype: { name: "Task" },
+          labels,
+        },
+      }),
+    });
+    const data = await res.json() as { key?: string; errors?: Record<string, string> };
+    if (!res.ok) {
+      console.error(`[jira] failed to create issue (${res.status}): ${JSON.stringify(data.errors ?? data)}`);
+      return null;
+    }
+    const url = `${this.baseUrl}/browse/${data.key}`;
+    console.log(`[jira] issue created: ${url}`);
+    return url;
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    const jql = encodeURIComponent(
+      `project = ${this.projectKey} AND statusCategory != Done AND labels = "feedback-agent" ORDER BY created DESC`
+    );
+    const res = await fetch(
+      `${this.baseUrl}/rest/api/3/search?jql=${jql}&maxResults=50&fields=summary,labels`,
+      { headers: this.headers }
+    );
+    if (!res.ok) return [];
+    const data = await res.json() as {
+      issues?: { key: string; fields: { summary: string; labels: string[] } }[];
+    };
+    return (data.issues ?? []).map((i) => ({
+      number: i.key,
+      title: i.fields.summary,
+      labels: i.fields.labels,
+    }));
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    const jql = encodeURIComponent(
+      `project = ${this.projectKey} AND statusCategory = Done AND labels = "feedback-agent" ORDER BY updated DESC`
+    );
+    const res = await fetch(
+      `${this.baseUrl}/rest/api/3/search?jql=${jql}&maxResults=20&fields=summary,labels,description`,
+      { headers: this.headers }
+    );
+    if (!res.ok) return [];
+    const data = await res.json() as {
+      issues?: { key: string; fields: { summary: string; labels: string[]; description: unknown } }[];
+    };
+    return (data.issues ?? []).map((i) => ({
+      number: i.key,
+      title: i.fields.summary,
+      body: typeof i.fields.description === "string" ? i.fields.description : "",
+      labels: i.fields.labels,
+    }));
+  }
+}

package/framework/trackers/notion.ts

@@ -0,0 +1,84 @@
+import type { IssueTracker, OpenIssue, ClosedIssue } from "./types";
+
+export class NotionTracker implements IssueTracker {
+  readonly name = "notion";
+  private token: string;
+  private databaseId: string;
+
+  constructor(token: string, databaseId: string) {
+    this.token = token;
+    this.databaseId = databaseId;
+  }
+
+  private get headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json",
+      "Notion-Version": "2022-06-28",
+    };
+  }
+
+  async createIssue(title: string, body: string, labels: string[]): Promise<string | null> {
+    const res = await fetch("https://api.notion.com/v1/pages", {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        parent: { database_id: this.databaseId },
+        properties: {
+          Name: { title: [{ text: { content: title } }] },
+          Labels: { multi_select: labels.map((l) => ({ name: l })) },
+          Status: { select: { name: "Open" } },
+        },
+        children: [
+          {
+            object: "block",
+            type: "paragraph",
+            paragraph: { rich_text: [{ type: "text", text: { content: body } }] },
+          },
+        ],
+      }),
+    });
+    const data = await res.json() as { id?: string; url?: string; message?: string };
+    if (!res.ok) {
+      console.error(`[notion] failed to create page (${res.status}): ${data.message}`);
+      return null;
+    }
+    console.log(`[notion] page created: ${data.url}`);
+    return data.url ?? null;
+  }
+
+  async fetchOpenIssues(): Promise<OpenIssue[]> {
+    return this._queryPages("Open");
+  }
+
+  async fetchClosedIssues(): Promise<ClosedIssue[]> {
+    const pages = await this._queryPages("Closed");
+    return pages.map((p) => ({ ...p, body: "" }));
+  }
+
+  private async _queryPages(status: string): Promise<{ number: string; title: string; labels: string[] }[]> {
+    const res = await fetch(`https://api.notion.com/v1/databases/${this.databaseId}/query`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        filter: { property: "Status", select: { equals: status } },
+        page_size: 50,
+      }),
+    });
+    if (!res.ok) return [];
+    const data = await res.json() as {
+      results?: {
+        id: string;
+        properties: {
+          Name?: { title: { plain_text: string }[] };
+          Labels?: { multi_select: { name: string }[] };
+        };
+      }[];
+    };
+    return (data.results ?? []).map((p) => ({
+      number: p.id,
+      title: p.properties.Name?.title[0]?.plain_text ?? "(no title)",
+      labels: p.properties.Labels?.multi_select.map((l) => l.name) ?? [],
+    }));
+  }
+}

package/framework/trackers/types.ts

@@ -0,0 +1,19 @@
+export interface OpenIssue {
+  number: number | string;
+  title: string;
+  labels: string[];
+}
+
+export interface ClosedIssue {
+  number: number | string;
+  title: string;
+  body: string;
+  labels: string[];
+}
+
+export interface IssueTracker {
+  readonly name: string;
+  createIssue(title: string, body: string, labels: string[]): Promise<string | null>;
+  fetchOpenIssues(): Promise<OpenIssue[]>;
+  fetchClosedIssues(): Promise<ClosedIssue[]>;
+}

package/framework/triage.ts

@@ -4,7 +4,7 @@ import * as path from "path";
 import type { LLMClient } from "./llm-client";
 import type { Finding } from "./types";
 import { createMessageWithRetry } from "./agent-loop";
-import { postGitHubIssue, fetchOpenIssues } from "./github";
+import type { IssueTracker } from "./trackers/index";
 
 const TRIAGE_TOOLS: Anthropic.Tool[] = [
   {
@@ -14,7 +14,7 @@ const TRIAGE_TOOLS: Anthropic.Tool[] = [
   },
   {
     name: "create_issue",
-    description: "Post feedback as a GitHub Issue; multiple related findings can be merged into one / フィードバックをGitHub Issueとして投稿する。類似フィードバックをまとめて1件にできる",
+    description: "Post feedback as an issue ticket; multiple related findings can be merged into one / フィードバックをissueチケットとして投稿する。類似フィードバックをまとめて1件にできる",
     input_schema: {
       type: "object",
       properties: {
@@ -32,7 +32,7 @@ const TRIAGE_TOOLS: Anthropic.Tool[] = [
   },
   {
     name: "skip_finding",
-    description: "Skip a finding that duplicates an existing open GitHub Issue / 既存のOpenなGitHub Issueと重複するためスキップする",
+    description: "Skip a finding that duplicates an existing open issue / 既存のOpenなissueと重複するためスキップする",
     input_schema: {
       type: "object",
       properties: {
@@ -55,7 +55,7 @@ export async function runTriageAgent(
   findings: Finding[],
   client: LLMClient,
   model: string,
-  githubOptions: { token: string; repo: string }
+  tracker: IssueTracker
 ): Promise<TriageResult> {
   if (findings.length === 0) {
     console.log("\n[triage] no findings, skipping");
@@ -64,7 +64,7 @@ export async function runTriageAgent(
 
   console.log(`\n[triage] starting (findings: ${findings.length})`);
 
-  const openIssues = await fetchOpenIssues(githubOptions);
+  const openIssues = await tracker.fetchOpenIssues();
   const pendingIds = new Set(findings.map((f) => f.id));
   const issuedIds: string[] = [];
   const skippedIds: string[] = [];
@@ -72,16 +72,16 @@ export async function runTriageAgent(
   let skipped = 0;
 
   const openIssueList = openIssues.length > 0
-    ? `\n\n[Existing open Issues (for deduplication)]\n${openIssues.map((i) => `- #${i.number}: ${i.title}`).join("\n")}`
+    ? `\n\n[Existing open issues (for deduplication)]\n${openIssues.map((i) => `- ${i.number}: ${i.title}`).join("\n")}`
     : "";
 
   const systemPrompt = `You are a feedback triage AI.
-Organize feedback collected by multiple agents and post it as GitHub Issues.
+Organize feedback collected by multiple agents and post it as issue tickets.
 
 [Steps]
 1. Call get_all_findings to review collected feedback
-2. Merge similar/duplicate feedback into a single Issue
-3. Skip feedback that duplicates an existing open Issue using skip_finding
+2. Merge similar/duplicate feedback into a single issue
+3. Skip feedback that duplicates an existing open issue using skip_finding
 4. Post the rest with create_issue (no duplicates, only valuable findings)
 5. Finish after processing all items${openIssueList}
 
@@ -92,8 +92,8 @@ Organize feedback collected by multiple agents and post it as GitHub Issues.
 - goal-gap: the app fails to meet one of its stated goals — use only when a finding directly undermines a specific app goal
 
 [Merging Guidelines]
-- Multiple reports about the same screen/feature can be merged into one Issue
-- Merge into one Issue even across categories if it's the same underlying problem
+- Multiple reports about the same screen/feature can be merged into one issue
+- Merge into one issue even across categories if it's the same underlying problem
 - Include multiple perspectives in the body when merging
 - Only post clearly valuable findings (skip operation errors or misunderstandings)
 
@@ -164,7 +164,7 @@ Organize feedback collected by multiple agents and post it as GitHub Issues.
           : "";
         const fullBody = `**Category:** ${category}\n\n${body}${screenshotSection}\n\n---\n**Reported by:** ${mergedAgents.join(", ")}\n*This Issue was auto-generated by an AI triage agent*`;
         const cleanTitle = title.replace(/^\[[^\]]+\]\s*/i, "");
-        const url = await postGitHubIssue(`[${category}] ${cleanTitle}`, fullBody, [category, "feedback-agent"], githubOptions);
+        const url = await tracker.createIssue(`[${category}] ${cleanTitle}`, fullBody, [category, "feedback-agent"]);
         mergedIds.forEach((id) => { pendingIds.delete(id); issuedIds.push(id); });
         issuesCreated++;
         result = { created: true, url, mergedCount: mergedIds.length };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m8i-51/shoal",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "description": "Multi-agent web exploration framework — finds bugs, UX issues, and missing features by running AI agents against your app",
   "repository": {

package/run.ts

@@ -18,7 +18,7 @@ import { createMessageWithRetry, runAgentLoop, sleep, rateLimitRetries } from ".
 import { collectedFindings, initRunLog, saveRunLog, saveFinding, runLog } from "./framework/findings";
 import { loadAgents, addAgent, retireAgent } from "./framework/agent-store";
 import { updateCoverage, computeWeightedSummary } from "./framework/coverage";
-import { postGitHubIssue, fetchClosedIssues, fetchOpenIssues } from "./framework/github";
+import { buildTrackers } from "./framework/trackers/index";
 import {
   setupObservation,
   getRecentConsoleLogs,
@@ -41,10 +41,8 @@ import { runAccountManager, loadTestAccounts, type TestAccount } from "./framewo
 import { estimateCost, formatCostUSD } from "./framework/cost";
 
 const BASE_URL = process.env.BASE_URL ?? "http://localhost:3000";
-const GITHUB_TOKEN = process.env.GITHUB_TOKEN ?? "";
-const GITHUB_REPO = process.env.GITHUB_REPO ?? "";
 const REFRESH_SPEC = process.env.REFRESH_SPEC === "1";
-const githubOptions = { token: GITHUB_TOKEN, repo: GITHUB_REPO };
+const trackers = buildTrackers();
 
 const TARGET = process.env.TARGET ?? "none";
 let targetConfig = loadTarget(TARGET);
@@ -228,11 +226,10 @@ function makeExecutor(agentLog: AgentLog, scenarioOutcomes: ScenarioOutcome[], s
           const { original_issue_number, original_issue_title, title, body } = input as {
             original_issue_number: number; original_issue_title: string; title: string; body: string;
           };
-          const url = await postGitHubIssue(
+          const url = await trackers.createIssue(
             `[regression] ${title}`,
-            `**Regression:** #${original_issue_number} "${original_issue_title}" has reappeared.\n\n${body}\n\n---\n*This Issue was auto-generated by an AI regression agent*`,
-            ["regression", "feedback-agent"],
-            githubOptions
+            `**Regression:** #${original_issue_number} "${original_issue_title}" has reappeared.\n\n${body}\n\n---\n*This issue was auto-generated by an AI regression agent*`,
+            ["regression", "feedback-agent"]
           );
           const check: RegressionCheck = {
             issueNumber: Number(original_issue_number),
@@ -346,7 +343,7 @@ Take 3–5 actions, then finish.`;
 
 async function runRegressionAgent(
   agent: { id: string; name: string; persona: string; role: string },
-  closedIssues: { number: number; title: string; body: string; labels: string[] }[],
+  closedIssues: { number: number | string; title: string; body: string; labels: string[] }[],
   productSpec: ProductSpec
 ) {
   console.log(`\n[regression] ${agent.name} start (${closedIssues.length} issues to check)`);
@@ -448,7 +445,7 @@ const PERSONA_DESIGNER_TOOLS: Anthropic.Tool[] = [
 async function runPersonaDesigner(
   productSpec: ProductSpec,
   orgGuidance: string,
-  openIssues: { number: number; title: string; labels: string[] }[],
+  openIssues: { number: number | string; title: string; labels: string[] }[],
   scenarios: Scenario[],
   testAccounts: TestAccount[] = [],
 ): Promise<void> {
@@ -1053,7 +1050,7 @@ function pickAssignment(idx: number, scenarios: Scenario[]): { scenario?: Scenar
 async function main() {
   initDirs();
   // run log を最初期化しておくことで、どの段階でエラーが起きても finally で saveRunLog() が動く
-  initRunLog(0, GITHUB_REPO);
+  initRunLog(0, process.env.GITHUB_REPO ?? "");
 
   // 1. product discovery (cache or live)
   const browser = await chromium.launch({ headless: true });
@@ -1082,7 +1079,7 @@ async function main() {
     const orgDesign = await designOrg(productSpec, client, defaultModel, coverageSummary.formatted);
 
     // 3. open issues + scenario design (both feed into HR)
-    const openIssues = await fetchOpenIssues(githubOptions);
+    const openIssues = await trackers.fetchOpenIssues();
     const scenarios = await designScenarios(productSpec, openIssues, client, defaultModel, 5, coverageSummary.formatted);
 
     // 3.5. Account Manager（credentials が設定されている場合のみ）
@@ -1113,7 +1110,7 @@ async function main() {
       console.error("No agents found. Check agents.json.");
       process.exit(1);
     }
-    const closedIssues = await fetchClosedIssues(githubOptions);
+    const closedIssues = await trackers.fetchClosedIssues();
 
     // 5. エージェント数が確定したので totalAgents を更新
     runLog.summary.totalAgents = allAgents.length;
@@ -1191,7 +1188,7 @@ async function main() {
     console.log(`\n[triage] collected findings: ${collectedFindings.length}`);
     let triageResult = { issued: [] as string[], skipped: [] as string[], unprocessed: [] as string[], issuesCreated: 0 };
     try {
-      triageResult = await runTriageAgent(collectedFindings, client, defaultModel, githubOptions);
+      triageResult = await runTriageAgent(collectedFindings, client, defaultModel, trackers);
       runLog.summary.totalIssuesPosted += triageResult.issuesCreated;
     } catch (e) {
       console.error("[triage] error:", e);

package/triage-only.ts

@@ -12,11 +12,9 @@ import * as fs from "fs";
 import * as path from "path";
 import { createLLMClient } from "./framework/llm-client";
 import { runTriageAgent } from "./framework/triage";
+import { buildTrackers } from "./framework/trackers/index";
 import type { Finding } from "./framework/types";
 
-const GITHUB_TOKEN = process.env.GITHUB_TOKEN ?? "";
-const GITHUB_REPO = process.env.GITHUB_REPO ?? "";
-
 function loadFindings(runId: string): Finding[] {
   const dir = path.join(process.cwd(), "findings", runId);
   if (!fs.existsSync(dir)) {
@@ -46,7 +44,8 @@ async function main() {
   findings.forEach((f) => console.log(`  - ${f.agentName}: ${f.title.slice(0, 50)}`));
 
   const { client, defaultModel } = createLLMClient();
-  const result = await runTriageAgent(findings, client, defaultModel, { token: GITHUB_TOKEN, repo: GITHUB_REPO });
+  const trackers = buildTrackers();
+  const result = await runTriageAgent(findings, client, defaultModel, trackers);
 
   console.log("\n=== トリアージ結果 ===");
   console.log(`  Issue作成: ${result.issuesCreated}件`);