taskode 0.4.0

package/src/tracker/linear.js

@@ -0,0 +1,229 @@
+const LINEAR_URL = 'https://api.linear.app/graphql';
+
+export class LinearTracker {
+  constructor({ config, store }) {
+    this.config = config;
+    this.store = store;
+
+    if (!config.tracker.apiKey) {
+      throw new Error('LINEAR tracker requires tracker.api_key or LINEAR_API_KEY');
+    }
+  }
+
+  async fetchCandidates() {
+    const data = await this.callLinear(
+      `
+        query CandidateIssues($projectSlug: String, $states: [String!]) {
+          issues(filter: { state: { name: { in: $states } }, project: { slugId: { eq: $projectSlug } } }, first: 50) {
+            nodes { id identifier title description priority url state { name } labels { nodes { name } } }
+          }
+        }
+      `,
+      {
+        projectSlug: this.config.tracker.projectSlug,
+        states: this.config.tracker.activeStates
+      }
+    );
+
+    return this.syncIssues((data.issues?.nodes || []).map(mapIssue));
+  }
+
+  async fetchByIds(ids) {
+    if (!ids.length) return [];
+
+    const data = await this.callLinear(
+      `
+        query IssuesById($ids: [String!]) {
+          issues(filter: { id: { in: $ids } }, first: 50) {
+            nodes { id identifier title description priority url state { name } labels { nodes { name } } }
+          }
+        }
+      `,
+      { ids }
+    );
+
+    return this.syncIssues((data.issues?.nodes || []).map(mapIssue));
+  }
+
+  async writeComment(issueId, body) {
+    await this.callLinear(
+      `
+        mutation CreateComment($issueId: String!, $body: String!) {
+          commentCreate(input: { issueId: $issueId, body: $body }) { success }
+        }
+      `,
+      { issueId, body }
+    );
+  }
+
+  async transitionState(issueId, stateName) {
+    const stateId = await this.findWorkflowStateId(stateName);
+    if (!stateId) return;
+
+    await this.callLinear(
+      `
+        mutation UpdateIssueState($issueId: String!, $stateId: String!) {
+          issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
+        }
+      `,
+      { issueId, stateId }
+    );
+  }
+
+  async linkPullRequest(issueId, prUrl) {
+    await this.writeComment(issueId, `PR: ${prUrl}`);
+  }
+
+  async executeDynamicTool(name, argumentsValue) {
+    if (name !== 'linear_graphql') {
+      return toolFailure(`Unsupported dynamic tool: ${name}`);
+    }
+
+    try {
+      const { query, variables } = normalizeGraphqlArguments(argumentsValue);
+      const data = await this.callLinear(query, variables);
+      return toolSuccess(data);
+    } catch (error) {
+      return toolFailure(error.message);
+    }
+  }
+
+  async findWorkflowStateId(stateName) {
+    const data = await this.callLinear(
+      `
+        query WorkflowStates($projectSlug: String) {
+          projects(filter: { slugId: { eq: $projectSlug } }, first: 1) {
+            nodes {
+              team { states { nodes { id name } } }
+            }
+          }
+        }
+      `,
+      { projectSlug: this.config.tracker.projectSlug }
+    );
+
+    const states = data.projects?.nodes?.[0]?.team?.states?.nodes || [];
+    return states.find((state) => state.name === stateName)?.id || null;
+  }
+
+  async callLinear(query, variables) {
+    const response = await fetch(LINEAR_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: this.config.tracker.apiKey
+      },
+      body: JSON.stringify({ query, variables })
+    });
+
+    if (!response.ok) {
+      throw new Error(`Linear API failed: ${response.status}`);
+    }
+
+    const payload = await response.json();
+    if (payload.errors?.length) {
+      throw new Error(`Linear errors: ${payload.errors.map((entry) => entry.message).join('; ')}`);
+    }
+    return payload.data;
+  }
+
+  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: numberToPriority(issue.priority),
+        externalId: issue.id,
+        trackerKind: 'linear',
+        trackerState: issue.state,
+        url: issue.url,
+        labels: issue.labels,
+        dependencies: issue.blocked_by
+      });
+    }
+
+    return issues;
+  }
+}
+
+function mapIssue(issue) {
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    description: issue.description,
+    priority: issue.priority ?? null,
+    state: issue.state?.name || 'unknown',
+    url: issue.url,
+    labels: (issue.labels?.nodes || []).map((label) => (label.name || '').toLowerCase()),
+    blocked_by: []
+  };
+}
+
+function normalizeTrackerState(state) {
+  const value = String(state || '').toLowerCase();
+  if (value.includes('review')) return 'review';
+  if (value.includes('progress')) return 'in_progress';
+  if (['done', 'closed', 'cancelled', 'duplicate'].some((token) => value.includes(token))) return 'done';
+  return 'todo';
+}
+
+function mergeSyncedStatus(currentStatus, remoteStatus) {
+  if (['review', 'done', 'failed'].includes(currentStatus)) return currentStatus;
+  return remoteStatus;
+}
+
+function numberToPriority(priority) {
+  if (priority === 1 || priority === 2) return 'high';
+  if (priority === 3) return 'medium';
+  return 'low';
+}
+
+function normalizeGraphqlArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') {
+    const query = argumentsValue.trim();
+    if (!query) {
+      throw new Error('linear_graphql requires a non-empty query string');
+    }
+    return { query, variables: {} };
+  }
+
+  if (!argumentsValue || typeof argumentsValue !== 'object' || Array.isArray(argumentsValue)) {
+    throw new Error('linear_graphql expects a query string or an object with query and variables');
+  }
+
+  const query = String(argumentsValue.query || '').trim();
+  if (!query) {
+    throw new Error('linear_graphql requires a non-empty query string');
+  }
+
+  const variables = argumentsValue.variables ?? {};
+  if (variables === null) {
+    return { query, variables: {} };
+  }
+  if (typeof variables !== 'object' || Array.isArray(variables)) {
+    throw new Error('linear_graphql.variables must be an object');
+  }
+
+  return { query, variables };
+}
+
+function toolSuccess(data) {
+  const output = JSON.stringify(data, null, 2);
+  return {
+    success: true,
+    output,
+    contentItems: [{ type: 'inputText', text: output }]
+  };
+}
+
+function toolFailure(message) {
+  return {
+    success: false,
+    output: message,
+    contentItems: [{ type: 'inputText', text: message }]
+  };
+}

package/src/tracker/local.js

@@ -0,0 +1,75 @@
+export class LocalTracker {
+  constructor({ store, config }) {
+    this.store = store;
+    this.config = config;
+  }
+
+  async fetchCandidates() {
+    return this.store.listTasks()
+      .filter((task) => task.trackerKind === 'local')
+      .filter((task) => ['todo', 'in_progress', 'blocked'].includes(task.status))
+      .map((task) => mapTask(task, this.store));
+  }
+
+  async fetchByIds(ids) {
+    return ids
+      .map((id) => this.store.getTask(id) || this.store.getTaskByExternalId(id))
+      .filter(Boolean)
+      .map((task) => mapTask(task, this.store));
+  }
+
+  async writeComment(issueId, body) {
+    this.store.appendAudit({
+      action: 'tracker_comment',
+      actor: 'local-tracker',
+      metadata: { issueId, body }
+    });
+  }
+
+  async transitionState(issueId, stateName) {
+    const mapped = mapStateName(stateName);
+    this.store.updateTaskByIdentifier(issueId, { status: mapped, trackerState: stateName });
+  }
+
+  async linkPullRequest(issueId, prUrl) {
+    this.store.appendAudit({
+      action: 'tracker_pr_linked',
+      actor: 'local-tracker',
+      metadata: { issueId, prUrl }
+    });
+  }
+}
+
+function mapTask(task, store) {
+  const blockedBy = (task.dependencies || []).filter((dependencyId) => {
+    const dependency = store.getTask(dependencyId);
+    return dependency && dependency.status !== 'done';
+  });
+
+  return {
+    id: task.id,
+    identifier: task.id,
+    title: task.title,
+    description: task.description,
+    priority: priorityToNumber(task.priority),
+    state: task.status,
+    url: task.url,
+    labels: task.labels || [task.type],
+    blocked_by: blockedBy
+  };
+}
+
+function priorityToNumber(priority) {
+  if (priority === 'high') return 1;
+  if (priority === 'medium') return 2;
+  return 3;
+}
+
+function mapStateName(stateName) {
+  const value = String(stateName || '').toLowerCase();
+  if (value.includes('review')) return 'review';
+  if (value.includes('progress')) return 'in_progress';
+  if (value.includes('done') || value.includes('closed')) return 'done';
+  if (value.includes('cancel')) return 'cancelled';
+  return 'todo';
+}

package/src/workflow-store.js

@@ -0,0 +1,77 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { loadWorkflow, replaceConfigContents, resolveRuntimeConfig } from './workflow.js';
+
+export class WorkflowStore {
+  constructor({ workflowPath, cliOptions = {}, onReloadError = null }) {
+    this.workflowPath = workflowPath;
+    this.cliOptions = { ...cliOptions };
+    this.onReloadError = typeof onReloadError === 'function' ? onReloadError : null;
+    this.state = this.loadFreshState();
+  }
+
+  getConfig() {
+    return this.state.config;
+  }
+
+  getWorkflow() {
+    return this.state.workflow;
+  }
+
+  getMetadata() {
+    return {
+      workflowPath: this.workflowPath,
+      lastLoadedAt: this.state.loadedAt,
+      lastError: this.state.lastError
+    };
+  }
+
+  refresh({ force = false } = {}) {
+    try {
+      const nextStamp = readWorkflowStamp(this.workflowPath);
+      if (!force && stampsEqual(this.state.stamp, nextStamp)) {
+        return { changed: false, config: this.state.config, error: null };
+      }
+
+      const workflow = loadWorkflow(this.workflowPath);
+      const nextConfig = resolveRuntimeConfig(workflow, this.cliOptions);
+      replaceConfigContents(this.state.config, nextConfig);
+      this.state.workflow = workflow;
+      this.state.stamp = nextStamp;
+      this.state.loadedAt = new Date().toISOString();
+      this.state.lastError = null;
+      return { changed: true, config: this.state.config, error: null };
+    } catch (error) {
+      this.state.lastError = { at: new Date().toISOString(), message: error.message };
+      if (this.onReloadError) {
+        this.onReloadError(error);
+      }
+      return { changed: false, config: this.state.config, error };
+    }
+  }
+
+  loadFreshState() {
+    const workflow = loadWorkflow(this.workflowPath);
+    return {
+      workflow,
+      config: resolveRuntimeConfig(workflow, this.cliOptions),
+      stamp: readWorkflowStamp(this.workflowPath),
+      loadedAt: new Date().toISOString(),
+      lastError: null
+    };
+  }
+}
+
+function readWorkflowStamp(workflowPath) {
+  const stat = fs.statSync(workflowPath);
+  const content = fs.readFileSync(workflowPath);
+  return {
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    hash: crypto.createHash('sha1').update(content).digest('hex')
+  };
+}
+
+function stampsEqual(left, right) {
+  return left?.mtimeMs === right?.mtimeMs && left?.size === right?.size && left?.hash === right?.hash;
+}