taskode 0.4.0

package/src/store.js

@@ -0,0 +1,355 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEFAULT_SESSION = {
+  sessionId: null,
+  threadId: null,
+  turnId: null,
+  turnCount: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  totalTokens: 0,
+  lastEvent: null,
+  workerHost: null,
+  rateLimits: null
+};
+
+const DEFAULT_DIFF_SUMMARY = {
+  total: 0,
+  added: 0,
+  modified: 0,
+  deleted: 0
+};
+
+const DEFAULT_DB = {
+  tasks: [],
+  runs: [],
+  logs: [],
+  audit: [],
+  retries: {},
+  runtime: {},
+  seq: { task: 0, run: 0 }
+};
+
+export class TaskodeStore {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    ensureDir(path.dirname(dbPath));
+    if (!fs.existsSync(dbPath)) {
+      this.write(DEFAULT_DB);
+    }
+  }
+
+  read() {
+    const data = JSON.parse(fs.readFileSync(this.dbPath, 'utf8'));
+    return {
+      ...DEFAULT_DB,
+      ...data,
+      seq: { ...DEFAULT_DB.seq, ...(data.seq || {}) },
+      retries: { ...(data.retries || {}) },
+      runtime: { ...(data.runtime || {}) },
+      tasks: Array.isArray(data.tasks) ? data.tasks.map(normalizeTask) : [],
+      runs: Array.isArray(data.runs) ? data.runs.map(normalizeRun) : [],
+      logs: Array.isArray(data.logs) ? data.logs : [],
+      audit: Array.isArray(data.audit) ? data.audit : []
+    };
+  }
+
+  write(data) {
+    fs.writeFileSync(this.dbPath, JSON.stringify(data, null, 2), 'utf8');
+  }
+
+  listTasks() {
+    const db = this.read();
+    return db.tasks.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+
+  createTask(input) {
+    const db = this.read();
+    const id = input.id || `T-${++db.seq.task}`;
+    const task = buildTask({ ...input, id });
+    db.tasks.push(task);
+    this.write(db);
+    return task;
+  }
+
+  upsertTask(input) {
+    const db = this.read();
+    const index = findTaskIndex(db.tasks, input.id, input.externalId);
+    const now = new Date().toISOString();
+
+    if (index === -1) {
+      const id = input.id || `T-${++db.seq.task}`;
+      const task = buildTask({ ...input, id, createdAt: input.createdAt || now, updatedAt: now });
+      db.tasks.push(task);
+      this.write(db);
+      return task;
+    }
+
+    const existing = db.tasks[index];
+    db.tasks[index] = normalizeTask({
+      ...existing,
+      ...sanitizeTaskPatch(input),
+      id: existing.id,
+      createdAt: existing.createdAt,
+      updatedAt: now
+    });
+    this.write(db);
+    return db.tasks[index];
+  }
+
+  updateTask(id, patch) {
+    const db = this.read();
+    const index = db.tasks.findIndex((task) => task.id === id);
+    if (index === -1) return null;
+    db.tasks[index] = normalizeTask({
+      ...db.tasks[index],
+      ...sanitizeTaskPatch(patch),
+      updatedAt: new Date().toISOString()
+    });
+    this.write(db);
+    return db.tasks[index];
+  }
+
+  updateTaskByIdentifier(identifier, patch) {
+    return this.updateTask(identifier, patch);
+  }
+
+  getTask(id) {
+    return this.read().tasks.find((task) => task.id === id) || null;
+  }
+
+  getTaskByExternalId(externalId) {
+    return this.read().tasks.find((task) => task.externalId === externalId) || null;
+  }
+
+  listRuns(taskId) {
+    return this.read().runs
+      .filter((run) => !taskId || run.taskId === taskId || run.issueIdentifier === taskId)
+      .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  }
+
+  getRun(runId) {
+    return this.read().runs.find((run) => run.id === runId) || null;
+  }
+
+  createRun(input) {
+    const db = this.read();
+    const id = `R-${++db.seq.run}`;
+    const now = new Date().toISOString();
+    const run = normalizeRun({
+      id,
+      taskId: input.taskId,
+      issueIdentifier: input.issueIdentifier || input.taskId,
+      attempt: input.attempt || 1,
+      status: input.status || 'queued',
+      summary: input.summary || 'Run queued',
+      logs: [`${now} queued`],
+      startedAt: now,
+      reviewStatus: input.reviewStatus || 'none'
+    });
+    db.runs.push(run);
+    this.write(db);
+    return run;
+  }
+
+  appendRunLog(runId, line) {
+    const db = this.read();
+    const run = db.runs.find((entry) => entry.id === runId);
+    if (!run) return null;
+    run.logs.push(`${new Date().toISOString()} ${line}`);
+    this.write(db);
+    return run;
+  }
+
+  updateRunSession(runId, patch) {
+    const db = this.read();
+    const run = db.runs.find((entry) => entry.id === runId);
+    if (!run) return null;
+    run.session = { ...run.session, ...patch };
+    this.write(db);
+    return run;
+  }
+
+  updateRun(runId, patch) {
+    const db = this.read();
+    const run = db.runs.find((entry) => entry.id === runId);
+    if (!run) return null;
+    Object.assign(run, normalizeRun({ ...run, ...patch }));
+    this.write(db);
+    return run;
+  }
+
+  appendSystemLog(message) {
+    const db = this.read();
+    db.logs.push({ at: new Date().toISOString(), message });
+    if (db.logs.length > 2000) db.logs = db.logs.slice(-2000);
+    this.write(db);
+  }
+
+  listSystemLogs(limit = 200) {
+    const logs = this.read().logs;
+    return logs.slice(-limit).reverse();
+  }
+
+  appendAudit(entry) {
+    const db = this.read();
+    db.audit.push({ at: new Date().toISOString(), ...entry });
+    if (db.audit.length > 5000) db.audit = db.audit.slice(-5000);
+    this.write(db);
+  }
+
+  listAudit(limit = 200) {
+    const audit = this.read().audit;
+    return audit.slice(-limit).reverse();
+  }
+
+  setRetry(issueId, retryEntry) {
+    const db = this.read();
+    db.retries[issueId] = retryEntry;
+    this.write(db);
+  }
+
+  removeRetry(issueId) {
+    const db = this.read();
+    delete db.retries[issueId];
+    this.write(db);
+  }
+
+  listRetries() {
+    return this.read().retries;
+  }
+
+  saveRuntime(runtime) {
+    const db = this.read();
+    db.runtime = runtime;
+    this.write(db);
+  }
+
+  loadRuntime() {
+    return this.read().runtime;
+  }
+}
+
+function buildTask(input) {
+  const now = new Date().toISOString();
+  return normalizeTask({
+    id: input.id,
+    title: input.title,
+    description: input.description || '',
+    type: input.type || 'todo',
+    status: input.status || 'todo',
+    priority: input.priority || 'medium',
+    externalId: input.externalId || null,
+    trackerKind: input.trackerKind || 'local',
+    trackerState: input.trackerState || null,
+    url: input.url || null,
+    labels: input.labels || [],
+    dependencies: input.dependencies || [],
+    createdAt: input.createdAt || now,
+    updatedAt: input.updatedAt || now
+  });
+}
+
+function normalizeTask(task) {
+  const now = new Date().toISOString();
+  return {
+    id: task.id,
+    title: String(task.title || ''),
+    description: String(task.description || ''),
+    type: String(task.type || 'todo'),
+    status: normalizeStatus(task.status),
+    priority: normalizePriority(task.priority),
+    externalId: task.externalId ?? null,
+    trackerKind: task.trackerKind || 'local',
+    trackerState: task.trackerState || null,
+    url: task.url || null,
+    labels: normalizeStringArray(task.labels),
+    dependencies: normalizeStringArray(task.dependencies),
+    createdAt: task.createdAt || now,
+    updatedAt: task.updatedAt || now
+  };
+}
+
+function sanitizeTaskPatch(patch) {
+  const next = {};
+
+  if (patch.title !== undefined) next.title = String(patch.title || '');
+  if (patch.description !== undefined) next.description = String(patch.description || '');
+  if (patch.type !== undefined) next.type = String(patch.type || 'todo');
+  if (patch.status !== undefined) next.status = normalizeStatus(patch.status);
+  if (patch.priority !== undefined) next.priority = normalizePriority(patch.priority);
+  if (patch.externalId !== undefined) next.externalId = patch.externalId ?? null;
+  if (patch.trackerKind !== undefined) next.trackerKind = patch.trackerKind || 'local';
+  if (patch.trackerState !== undefined) next.trackerState = patch.trackerState || null;
+  if (patch.url !== undefined) next.url = patch.url || null;
+  if (patch.labels !== undefined) next.labels = normalizeStringArray(patch.labels);
+  if (patch.dependencies !== undefined) next.dependencies = normalizeStringArray(patch.dependencies);
+
+  return next;
+}
+
+function normalizeRun(run) {
+  return {
+    id: run.id,
+    taskId: run.taskId,
+    issueIdentifier: run.issueIdentifier || run.taskId,
+    attempt: Number(run.attempt || 1),
+    status: run.status || 'queued',
+    summary: run.summary || 'Run queued',
+    logs: Array.isArray(run.logs) ? run.logs : [],
+    session: { ...DEFAULT_SESSION, ...(run.session || {}) },
+    startedAt: run.startedAt || new Date().toISOString(),
+    finishedAt: run.finishedAt || null,
+    workspacePath: run.workspacePath || null,
+    workspaceKey: run.workspaceKey || null,
+    logFile: run.logFile || null,
+    diffFile: run.diffFile || null,
+    changedFiles: Array.isArray(run.changedFiles) ? run.changedFiles.map(normalizeChangedFile) : [],
+    diffSummary: { ...DEFAULT_DIFF_SUMMARY, ...(run.diffSummary || {}) },
+    reviewStatus: run.reviewStatus || 'none',
+    appliedAt: run.appliedAt || null,
+    error: run.error || null
+  };
+}
+
+function normalizeChangedFile(file) {
+  return {
+    path: String(file.path || ''),
+    status: file.status || 'modified'
+  };
+}
+
+function normalizeStatus(status) {
+  const value = String(status || 'todo').toLowerCase();
+  if (['todo', 'in_progress', 'blocked', 'review', 'done', 'failed', 'cancelled'].includes(value)) {
+    return value;
+  }
+  return 'todo';
+}
+
+function normalizePriority(priority) {
+  const value = String(priority || 'medium').toLowerCase();
+  if (['low', 'medium', 'high'].includes(value)) return value;
+  return 'medium';
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map((entry) => String(entry || '').trim()).filter(Boolean))];
+}
+
+function findTaskIndex(tasks, id, externalId) {
+  if (id) {
+    const byId = tasks.findIndex((task) => task.id === id);
+    if (byId !== -1) return byId;
+  }
+  if (externalId) {
+    return tasks.findIndex((task) => task.externalId === externalId);
+  }
+  return -1;
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}

package/src/tracker/github.js

@@ -0,0 +1,143 @@
+export class GitHubTracker {
+  constructor({ config, store }) {
+    this.config = config;
+    this.store = store;
+
+    if (!config.tracker.githubToken) {
+      throw new Error('GITHUB tracker requires tracker.github_token or GITHUB_TOKEN');
+    }
+    if (!config.tracker.githubOwner || !config.tracker.githubRepo) {
+      throw new Error('GITHUB tracker requires tracker.github_owner and tracker.github_repo');
+    }
+  }
+
+  async fetchCandidates() {
+    const issues = await this.callGitHub(
+      `/repos/${this.config.tracker.githubOwner}/${this.config.tracker.githubRepo}/issues?state=open&per_page=50`
+    );
+
+    const mapped = issues
+      .filter((issue) => !issue.pull_request)
+      .map(mapIssue)
+      .filter((issue) => labelsMatch(issue.labels, this.config.tracker.githubLabels));
+
+    return this.syncIssues(mapped);
+  }
+
+  async fetchByIds(ids) {
+    const mapped = [];
+
+    for (const id of ids) {
+      const issue = await this.callGitHub(
+        `/repos/${this.config.tracker.githubOwner}/${this.config.tracker.githubRepo}/issues/${id}`
+      );
+      if (issue.pull_request) continue;
+      mapped.push(mapIssue(issue));
+    }
+
+    return this.syncIssues(mapped);
+  }
+
+  async writeComment(issueId, body) {
+    await this.callGitHub(
+      `/repos/${this.config.tracker.githubOwner}/${this.config.tracker.githubRepo}/issues/${issueId}/comments`,
+      {
+        method: 'POST',
+        body: { body }
+      }
+    );
+  }
+
+  async transitionState(issueId, stateName) {
+    const normalized = String(stateName || '').toLowerCase();
+    const state = ['done', 'closed'].some((token) => normalized.includes(token)) ? 'closed' : 'open';
+
+    await this.callGitHub(
+      `/repos/${this.config.tracker.githubOwner}/${this.config.tracker.githubRepo}/issues/${issueId}`,
+      {
+        method: 'PATCH',
+        body: { state }
+      }
+    );
+  }
+
+  async linkPullRequest(issueId, prUrl) {
+    await this.writeComment(issueId, `PR: ${prUrl}`);
+  }
+
+  async callGitHub(resource, options = {}) {
+    const response = await fetch(`${this.config.tracker.githubBaseUrl}${resource}`, {
+      method: options.method || 'GET',
+      headers: {
+        Accept: 'application/vnd.github+json',
+        Authorization: `Bearer ${this.config.tracker.githubToken}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'taskode'
+      },
+      body: options.body ? JSON.stringify(options.body) : undefined
+    });
+
+    if (!response.ok) {
+      throw new Error(`GitHub API failed: ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  syncIssues(issues) {
+    for (const issue of issues) {
+      this.store.upsertTask({
+        id: issue.identifier,
+        title: issue.title,
+        description: issue.description,
+        type: 'issue',
+        status: mergeSyncedStatus(this.store.getTask(issue.identifier)?.status, normalizeTrackerState(issue.state)),
+        priority: issue.priority,
+        externalId: issue.id,
+        trackerKind: 'github',
+        trackerState: issue.state,
+        url: issue.url,
+        labels: issue.labels,
+        dependencies: issue.blocked_by
+      });
+    }
+
+    return issues;
+  }
+}
+
+function mapIssue(issue) {
+  const labels = (issue.labels || []).map((label) => String(label.name || '').toLowerCase());
+
+  return {
+    id: String(issue.number),
+    identifier: `GH-${issue.number}`,
+    title: issue.title,
+    description: issue.body || '',
+    priority: labelsToPriority(labels),
+    state: issue.state,
+    url: issue.html_url,
+    labels,
+    blocked_by: []
+  };
+}
+
+function labelsMatch(labels, requiredLabels) {
+  if (!requiredLabels.length) return true;
+  return requiredLabels.every((required) => labels.includes(required.toLowerCase()));
+}
+
+function labelsToPriority(labels) {
+  if (labels.includes('priority:high') || labels.includes('p0') || labels.includes('p1')) return 'high';
+  if (labels.includes('priority:low') || labels.includes('p3')) return 'low';
+  return 'medium';
+}
+
+function normalizeTrackerState(state) {
+  return String(state || '').toLowerCase() === 'closed' ? 'done' : 'todo';
+}
+
+function mergeSyncedStatus(currentStatus, remoteStatus) {
+  if (['review', 'done', 'failed'].includes(currentStatus)) return currentStatus;
+  return remoteStatus;
+}

package/src/tracker/index.js

@@ -0,0 +1,71 @@
+import { GitHubTracker } from './github.js';
+import { LinearTracker } from './linear.js';
+import { LocalTracker } from './local.js';
+
+export function createTracker({ store, config }) {
+  return new TrackerFacade({ store, config });
+}
+
+class TrackerFacade {
+  constructor({ store, config }) {
+    this.store = store;
+    this.config = config;
+    this.kind = null;
+    this.impl = null;
+  }
+
+  async fetchCandidates() {
+    return this.current().fetchCandidates();
+  }
+
+  async fetchByIds(ids) {
+    return this.current().fetchByIds(ids);
+  }
+
+  async writeComment(issueId, body) {
+    return this.current().writeComment(issueId, body);
+  }
+
+  async transitionState(issueId, stateName) {
+    return this.current().transitionState(issueId, stateName);
+  }
+
+  async linkPullRequest(issueId, prUrl) {
+    return this.current().linkPullRequest(issueId, prUrl);
+  }
+
+  async executeDynamicTool(name, argumentsValue) {
+    if (typeof this.current().executeDynamicTool === 'function') {
+      return this.current().executeDynamicTool(name, argumentsValue);
+    }
+
+    return {
+      success: false,
+      output: `Unsupported dynamic tool: ${name}`,
+      contentItems: [{ type: 'inputText', text: `Unsupported dynamic tool: ${name}` }]
+    };
+  }
+
+  current() {
+    const nextKind = this.config.tracker.kind;
+    if (this.impl && this.kind === nextKind) {
+      return this.impl;
+    }
+
+    this.kind = nextKind;
+    this.impl = instantiateTracker({ store: this.store, config: this.config, kind: nextKind });
+    return this.impl;
+  }
+}
+
+function instantiateTracker({ store, config, kind }) {
+  if (kind === 'linear') {
+    return new LinearTracker({ config, store });
+  }
+
+  if (kind === 'github') {
+    return new GitHubTracker({ config, store });
+  }
+
+  return new LocalTracker({ store, config });
+}