@calltelemetry/openclaw-linear 0.3.1 → 0.4.1

package/src/tier-assess.ts

@@ -0,0 +1,157 @@
+/**
+ * tier-assess.ts — LLM-based complexity assessment for Linear issues.
+ *
+ * Uses runAgent() with the agent's configured model (e.g. kimi-k2.5)
+ * to assess issue complexity. The agent model handles orchestration —
+ * it never calls coding CLIs directly.
+ *
+ * Cost: one short agent turn (~500 tokens). Latency: ~2-5s.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { Tier } from "./dispatch-state.js";
+
+// ---------------------------------------------------------------------------
+// Tier → Model mapping
+// ---------------------------------------------------------------------------
+
+export const TIER_MODELS: Record<Tier, string> = {
+  junior: "anthropic/claude-haiku-4-5",
+  medior: "anthropic/claude-sonnet-4-6",
+  senior: "anthropic/claude-opus-4-6",
+};
+
+export interface TierAssessment {
+  tier: Tier;
+  model: string;
+  reasoning: string;
+}
+
+export interface IssueContext {
+  identifier: string;
+  title: string;
+  description?: string | null;
+  labels?: string[];
+  commentCount?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Assessment
+// ---------------------------------------------------------------------------
+
+const ASSESS_PROMPT = `You are a complexity assessor. Assess this issue and respond ONLY with JSON.
+
+Tiers:
+- junior: typos, copy changes, config tweaks, simple CSS, env var additions
+- medior: features, bugfixes, moderate refactoring, adding tests, API changes
+- senior: architecture changes, database migrations, security fixes, multi-service coordination
+
+Consider:
+1. How many files/services are likely affected?
+2. Does it touch auth, data, or external APIs? (higher risk → higher tier)
+3. Is the description clear and actionable?
+4. Are there dependencies or unknowns?
+
+Respond ONLY with: {"tier":"junior|medior|senior","reasoning":"one sentence"}`;
+
+/**
+ * Assess issue complexity using the agent's configured model.
+ *
+ * Falls back to "medior" if the agent call fails or returns invalid JSON.
+ */
+export async function assessTier(
+  api: OpenClawPluginApi,
+  issue: IssueContext,
+  agentId?: string,
+): Promise<TierAssessment> {
+  const issueText = [
+    `Issue: ${issue.identifier} — ${issue.title}`,
+    issue.description ? `Description: ${issue.description.slice(0, 1500)}` : "",
+    issue.labels?.length ? `Labels: ${issue.labels.join(", ")}` : "",
+    issue.commentCount != null ? `Comments: ${issue.commentCount}` : "",
+  ].filter(Boolean).join("\n");
+
+  const message = `${ASSESS_PROMPT}\n\n${issueText}`;
+
+  try {
+    const { runAgent } = await import("./agent.js");
+    const result = await runAgent({
+      api,
+      agentId: agentId ?? resolveDefaultAgent(api),
+      sessionId: `tier-assess-${issue.identifier}-${Date.now()}`,
+      message,
+      timeoutMs: 30_000, // 30s — this should be fast
+    });
+
+    // Try to parse assessment from output regardless of success flag.
+    // runAgent may report success:false (non-zero exit code) even when
+    // the agent produced valid JSON output — e.g. agent exited with
+    // signal but wrote the response before terminating.
+    if (result.output) {
+      const parsed = parseAssessment(result.output);
+      if (parsed) {
+        api.logger.info(`Tier assessment for ${issue.identifier}: ${parsed.tier} — ${parsed.reasoning} (agent success=${result.success})`);
+        return parsed;
+      }
+    }
+
+    if (!result.success) {
+      api.logger.warn(`Tier assessment agent failed for ${issue.identifier}: ${result.output.slice(0, 200)}`);
+    } else {
+      api.logger.warn(`Tier assessment for ${issue.identifier}: could not parse response: ${result.output.slice(0, 200)}`);
+    }
+  } catch (err) {
+    api.logger.warn(`Tier assessment error for ${issue.identifier}: ${err}`);
+  }
+
+  // Fallback: medior is the safest default
+  const fallback: TierAssessment = {
+    tier: "medior",
+    model: TIER_MODELS.medior,
+    reasoning: "Assessment failed — defaulting to medior",
+  };
+  api.logger.info(`Tier assessment fallback for ${issue.identifier}: medior`);
+  return fallback;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolveDefaultAgent(api: OpenClawPluginApi): string {
+  // Use the plugin's configured default agent (same one that runs the pipeline)
+  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
+  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
+
+  // Fall back to isDefault in agent profiles
+  try {
+    const profilesPath = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+    const raw = readFileSync(profilesPath, "utf8");
+    const profiles = JSON.parse(raw).agents ?? {};
+    const defaultAgent = Object.entries(profiles).find(([, p]: [string, any]) => p.isDefault);
+    if (defaultAgent) return defaultAgent[0];
+  } catch { /* fall through */ }
+
+  return "zoe";
+}
+
+function parseAssessment(raw: string): TierAssessment | null {
+  // Extract JSON from the response (may have markdown wrapping)
+  const jsonMatch = raw.match(/\{[^}]+\}/);
+  if (!jsonMatch) return null;
+
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    const tier = parsed.tier as string;
+    if (tier !== "junior" && tier !== "medior" && tier !== "senior") return null;
+
+    return {
+      tier: tier as Tier,
+      model: TIER_MODELS[tier as Tier],
+      reasoning: parsed.reasoning ?? "no reasoning provided",
+    };
+  } catch {
+    return null;
+  }
+}

package/src/tools.ts

@@ -1,84 +1,34 @@
-import type { AnyAgentTool, OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { jsonResult } from "openclaw/plugin-sdk";
-import { LinearClient } from "./client.js";
-import { resolveLinearToken } from "./linear-api.js";
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { createCodeTool } from "./code-tool.js";
+import { createOrchestrationTools } from "./orchestration-tools.js";
 
-export function createLinearTools(api: OpenClawPluginApi, ctx: OpenClawPluginToolContext): AnyAgentTool[] {
-  const getClient = () => {
-    const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
-    const resolved = resolveLinearToken(pluginConfig);
-    if (!resolved.accessToken) {
-      throw new Error("Linear access token not found. Run 'openclaw openclaw-linear auth' to authenticate.");
+export function createLinearTools(api: OpenClawPluginApi, ctx: Record<string, unknown>): any[] {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+
+  // Unified code_run tool — dispatches to configured backend (claude/codex/gemini)
+  const codeTools: AnyAgentTool[] = [];
+  try {
+    codeTools.push(createCodeTool(api, ctx));
+  } catch (err) {
+    api.logger.warn(`code_run tool not available: ${err}`);
+  }
+
+  // Orchestration tools (conditional on config — defaults to enabled)
+  const orchestrationTools: AnyAgentTool[] = [];
+  const enableOrchestration = pluginConfig?.enableOrchestration !== false;
+  if (enableOrchestration) {
+    try {
+      orchestrationTools.push(...createOrchestrationTools(api, ctx));
+    } catch (err) {
+      api.logger.warn(`Orchestration tools not available: ${err}`);
     }
-    return new LinearClient(resolved.accessToken);
-  };
-  
+  }
+
+  // Linear issue management (list, create, update, close, comment, etc.)
+  // is handled by the `linearis` skill — no custom tools needed here.
+
   return [
-    {
-      name: "linear_list_issues",
-      description: "List issues from a Linear workspace",
-      parameters: {
-        type: "object",
-        properties: {
-          limit: { type: "number", description: "Max issues to return", default: 10 },
-          teamId: { type: "string", description: "Filter by team ID" }
-        }
-      },
-      execute: async ({ limit, teamId }) => {
-        const client = getClient();
-        const data = await client.listIssues({ limit, teamId });
-        return jsonResult({ 
-          message: `Found ${data.issues.nodes.length} issues`,
-          issues: data.issues.nodes 
-        });
-      }
-    },
-    {
-      name: "linear_create_issue",
-      description: "Create a new issue in Linear",
-      parameters: {
-        type: "object",
-        properties: {
-          title: { type: "string", description: "Issue title" },
-          description: { type: "string", description: "Issue description" },
-          teamId: { type: "string", description: "Team ID" }
-        },
-        required: ["title", "teamId"]
-      },
-      execute: async ({ title, description, teamId }) => {
-        const client = getClient();
-        const data = await client.createIssue({ title, description, teamId });
-        if (data.issueCreate.success) {
-          return jsonResult({
-            message: "Created issue successfully",
-            issue: data.issueCreate.issue
-          });
-        }
-        return jsonResult({ message: "Failed to create issue" });
-      }
-    },
-    {
-      name: "linear_add_comment",
-      description: "Add a comment to a Linear issue",
-      parameters: {
-        type: "object",
-        properties: {
-          issueId: { type: "string", description: "Issue ID" },
-          body: { type: "string", description: "Comment body" }
-        },
-        required: ["issueId", "body"]
-      },
-      execute: async ({ issueId, body }) => {
-        const client = getClient();
-        const data = await client.addComment({ issueId, body });
-        if (data.commentCreate.success) {
-          return jsonResult({
-            message: "Added comment successfully",
-            commentId: data.commentCreate.comment.id
-          });
-        }
-        return jsonResult({ message: "Failed to add comment" });
-      }
-    }
+    ...codeTools,
+    ...orchestrationTools,
   ];
 }