@soundchain/openclaw-plugin 1.0.0 → 2.0.0

package/src/messaging.ts

@@ -1,309 +0,0 @@
-/**
- * SoundChain Messaging Client
- *
- * GraphQL client for SoundChain DM operations.
- * Used by the channel plugin for outbound messaging
- * and inbound message polling.
- *
- * CRITICAL: `toId` must be a PROFILE ID, not a chat ID.
- * Using chat.id instead of chat.profile.id causes blank page crash
- * (documented Bug #17 in CLAUDE.md).
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ChatMessage {
-  id: string;
-  message: string;
-  fromId?: string;
-  toId?: string;
-  createdAt: string;
-  fromProfile?: { id: string; displayName?: string; handle?: string };
-}
-
-export interface Chat {
-  id: string;
-  message: string;
-  fromId?: string;
-  unread?: boolean;
-  createdAt: string;
-  profile?: {
-    id: string;
-    displayName?: string;
-  };
-}
-
-// ---------------------------------------------------------------------------
-// GraphQL transport
-// ---------------------------------------------------------------------------
-
-interface GraphQLResponse {
-  data?: Record<string, unknown>;
-  errors?: Array<{ message: string }>;
-}
-
-async function graphql(
-  apiUrl: string,
-  token: string,
-  query: string,
-  variables?: Record<string, unknown>,
-): Promise<Record<string, unknown>> {
-  const res = await fetch(apiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({ query, variables }),
-    signal: AbortSignal.timeout(10_000),
-  });
-
-  if (!res.ok) {
-    throw new Error(`SoundChain GraphQL HTTP error ${res.status}: ${res.statusText}`);
-  }
-  const json = (await res.json()) as GraphQLResponse;
-
-  if (json.errors && json.errors.length > 0) {
-    throw new Error(`SoundChain GraphQL: ${json.errors[0].message}`);
-  }
-
-  return json.data ?? {};
-}
-
-// ---------------------------------------------------------------------------
-// Queries & Mutations
-// ---------------------------------------------------------------------------
-
-const CHATS_QUERY = `
-  query Chats {
-    chats(page: { first: 50 }) {
-      nodes {
-        id
-        message
-        fromId
-        unread
-        createdAt
-        profile {
-          id
-          displayName
-        }
-      }
-    }
-  }
-`;
-
-const SEND_MESSAGE_MUTATION = `
-  mutation SendMessage($toId: String!, $message: String!) {
-    sendMessage(input: { toId: $toId, message: $message }) {
-      message {
-        id
-        fromId
-        toId
-        message
-        createdAt
-      }
-    }
-  }
-`;
-
-const UNREAD_COUNT_QUERY = `
-  query UnreadMessageCount {
-    unreadMessageCount
-  }
-`;
-
-const EXPLORE_USERS_QUERY = `
-  query ExploreUsers($page: PageInput) {
-    exploreUsers(page: $page) {
-      nodes {
-        id
-        userHandle
-        displayName
-        isFollowed
-      }
-      pageInfo {
-        hasNextPage
-        endCursor
-      }
-    }
-  }
-`;
-
-const FOLLOW_PROFILE_MUTATION = `
-  mutation FollowProfile($input: FollowProfileInput!) {
-    followProfile(input: $input) {
-      followedProfile {
-        id
-        userHandle
-        isFollowed
-      }
-    }
-  }
-`;
-
-// ---------------------------------------------------------------------------
-// Client
-// ---------------------------------------------------------------------------
-
-export interface UserProfile {
-  id: string;
-  userHandle?: string;
-  displayName?: string;
-  isFollowed?: boolean;
-}
-
-export interface MessagingClient {
-  getChats(): Promise<Chat[]>;
-  sendMessage(toProfileId: string, message: string): Promise<ChatMessage>;
-  getUnreadCount(): Promise<number>;
-  getAllUsers(): Promise<UserProfile[]>;
-  followUser(profileId: string): Promise<void>;
-}
-
-/**
- * Dual-mode client: tries Vercel REST API first (always available),
- * falls back to Lambda GraphQL if REST fails.
- */
-export function createMessagingClient(apiUrl: string, token: string): MessagingClient {
-  // Derive REST base URL from the configured apiUrl
-  // e.g. "https://api.soundchain.io/graphql" → "https://soundchain.io"
-  // e.g. "https://staging.soundchain.io/graphql" → "https://staging.soundchain.io"
-  let baseUrl: string;
-  try {
-    const parsed = new URL(apiUrl);
-    // Strip "api." prefix — REST routes live on the main domain (soundchain.io)
-    const host = parsed.hostname.replace(/^api\./, "");
-    const port = parsed.port ? `:${parsed.port}` : "";
-    baseUrl = `${parsed.protocol}//${host}${port}`;
-  } catch {
-    throw new Error(
-      `Invalid SoundChain apiUrl: "${apiUrl}". Expected a valid URL like "https://soundchain.io" or "https://api.soundchain.io/graphql".`,
-    );
-  }
-
-  const REST_TIMEOUT_MS = 10_000;
-
-  async function restGet(path: string): Promise<Record<string, unknown>> {
-    const res = await fetch(`${baseUrl}${path}`, {
-      headers: { Authorization: `Bearer ${token}` },
-      signal: AbortSignal.timeout(REST_TIMEOUT_MS),
-    });
-    if (!res.ok) throw new Error(`REST ${path}: ${res.status}`);
-    return (await res.json()) as Record<string, unknown>;
-  }
-
-  async function restPost(
-    path: string,
-    body: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    const res = await fetch(`${baseUrl}${path}`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(REST_TIMEOUT_MS),
-    });
-    if (!res.ok) throw new Error(`REST ${path}: ${res.status}`);
-    return (await res.json()) as Record<string, unknown>;
-  }
-
-  return {
-    async getChats(): Promise<Chat[]> {
-      try {
-        const data = await restGet("/api/pulse/chats");
-        return (data.chats as Chat[]) ?? [];
-      } catch {
-        // Fallback to GraphQL
-        const data = await graphql(apiUrl, token, CHATS_QUERY);
-        const connection = data.chats as { nodes?: Chat[] } | undefined;
-        return connection?.nodes ?? [];
-      }
-    },
-
-    async sendMessage(toProfileId: string, message: string): Promise<ChatMessage> {
-      // Try REST first; only fall back to GraphQL on connection/network errors
-      // (NOT on HTTP errors where the server may have already processed the message)
-      try {
-        const data = await restPost("/api/pulse/send", { toId: toProfileId, message });
-        const result = data.message as ChatMessage | undefined;
-        if (!result) throw new Error("sendMessage returned null");
-        return result;
-      } catch (err: unknown) {
-        const isNetworkError =
-          err instanceof TypeError || // fetch network failure
-          (err instanceof DOMException &&
-            (err.name === "AbortError" || err.name === "TimeoutError")); // timeout (Node uses TimeoutError)
-        if (!isNetworkError) throw err; // Server responded — do NOT retry (avoids duplicate DMs)
-
-        // Network failure — safe to retry via GraphQL since REST never reached the server
-        const data = await graphql(apiUrl, token, SEND_MESSAGE_MUTATION, {
-          toId: toProfileId,
-          message,
-        });
-        const payload = data.sendMessage as { message?: ChatMessage } | undefined;
-        const result = payload?.message;
-        if (!result) throw new Error("sendMessage returned null");
-        return result;
-      }
-    },
-
-    async getUnreadCount(): Promise<number> {
-      try {
-        const data = await restGet("/api/pulse/chats");
-        const chats = (data.chats as Chat[]) ?? [];
-        return chats.filter((c) => c.unread).length;
-      } catch {
-        const data = await graphql(apiUrl, token, UNREAD_COUNT_QUERY);
-        return (data.unreadMessageCount as number | undefined) ?? 0;
-      }
-    },
-
-    async getAllUsers(): Promise<UserProfile[]> {
-      try {
-        // Paginate REST users (100 per page, max 1000)
-        const allUsers: UserProfile[] = [];
-        for (let skip = 0; skip < 1000; skip += 100) {
-          const data = await restGet(`/api/pulse/users?limit=100&skip=${skip}`);
-          const users = (data.users as UserProfile[]) ?? [];
-          allUsers.push(...users);
-          if (users.length < 100) break; // Last page
-        }
-        return allUsers;
-      } catch {
-        // Fallback to GraphQL pagination
-        const allUsers: UserProfile[] = [];
-        let cursor: string | null = null;
-        let hasNext = true;
-        const MAX_PAGES = 20; // Cap at 1,000 users (20 × 50)
-        let pageCount = 0;
-        while (hasNext && pageCount < MAX_PAGES) {
-          pageCount++;
-          const page: Record<string, unknown> = { first: 50 };
-          if (cursor) page.after = cursor;
-          const data = await graphql(apiUrl, token, EXPLORE_USERS_QUERY, { page });
-          const connection = data.exploreUsers as
-            | { nodes?: UserProfile[]; pageInfo?: { hasNextPage?: boolean; endCursor?: string } }
-            | undefined;
-          allUsers.push(...(connection?.nodes ?? []));
-          hasNext = connection?.pageInfo?.hasNextPage ?? false;
-          cursor = connection?.pageInfo?.endCursor ?? null;
-        }
-        return allUsers;
-      }
-    },
-
-    async followUser(profileId: string): Promise<void> {
-      try {
-        await restPost("/api/pulse/follow", { profileId });
-      } catch {
-        await graphql(apiUrl, token, FOLLOW_PROFILE_MUTATION, {
-          input: { followedId: profileId },
-        });
-      }
-    },
-  };
-}

package/src/phil-jackson.ts

@@ -1,343 +0,0 @@
-/**
- * Phil Jackson Triangle Pipeline — 7 Ollama Models, Zero Tokens
- *
- * The legendary triangle offense, adapted for code diagnostics.
- * Each model has a role. Each role has a trigger. The pipeline
- * chains them in sequence — syntax → deep analysis → fast fix →
- * deps → architect → captain → backup — until the problem is solved.
- *
- * "The strength of the team is each individual member.
- *  The strength of each member is the team." — Phil Jackson
- *
- * Team Chemistry (from agentide_optimizer.py):
- *   falcon:7b       — Syntax Specialist (Steph Curry's shooting)
- *   jmorgan/grok    — Deep Analyst (LeBron: sees the whole court)
- *   mistral:latest  — First Responder (Curry: fast handles, instant patch)
- *   gemma:7b        — Dependency Coordinator (Draymond: organizes the team)
- *   mixtral:8x22b   — Architect (Durant: builds with long-range vision)
- *   llama3.1        — Team Captain (Jordan: closes with dominance)
- *   qwen:7b         — Backup (Iguodala: steps up when needed)
- */
-
-import type { WarRoomClient } from "./warroom.js";
-
-// ---------------------------------------------------------------------------
-// Pipeline stage definitions (mirrors ORCHESTRATION_CONFIG from Python)
-// ---------------------------------------------------------------------------
-
-export interface PipelineStage {
-  name: string;
-  model: string;
-  role: string;
-  trigger: string;
-  tasks: string[];
-  output: string;
-  /** NBA analogy from team_chemistry */
-  chemistry: string;
-}
-
-export const PIPELINE_STAGES: PipelineStage[] = [
-  {
-    name: "syntax_correction",
-    model: "falcon:7b",
-    role: "Syntax Specialist",
-    trigger: "any_syntax_error",
-    tasks: [
-      "Detect and fix syntax errors (missing >, ;, unterminated regex)",
-      "Ensure JSX/TSX validity",
-    ],
-    output: "syntax_patch",
-    chemistry: "Steph Curry's shooting — precision from deep",
-  },
-  {
-    name: "logic_validation",
-    model: "jmorgan/grok:latest",
-    role: "Deep Analyst",
-    trigger: "any_type_error",
-    tasks: [
-      "Detect logic conflicts across tsconfig, next.config.js, dockerfiles",
-      "Explain error causes in human-friendly terms",
-      "Validate and update type definitions",
-    ],
-    output: "validated_fix",
-    chemistry: "LeBron — sees the whole court, validates plays",
-  },
-  {
-    name: "fast_reaction",
-    model: "mistral:latest",
-    role: "First Responder",
-    trigger: "any_build_error",
-    tasks: [
-      "Scan logs instantly",
-      "Apply quick fixes like missing imports and typos",
-      "Suggest yarn install if lockfile integrity fails",
-    ],
-    output: "quick_fix_patch",
-    chemistry: "Curry — fast handles, instant patch",
-  },
-  {
-    name: "dependency_management",
-    model: "gemma:7b",
-    role: "Dependency Coordinator",
-    trigger: "after_quick_fix_patch",
-    tasks: [
-      "Validate dependency versions in package.json and lock files",
-      "Suggest yarn/pnpm add/remove for missing or conflicting deps",
-    ],
-    output: "dependency_patch",
-    chemistry: "Draymond — organizes the team, sets the screen",
-  },
-  {
-    name: "strategic_reasoning",
-    model: "mixtral:8x22b",
-    role: "Architect",
-    trigger: "after_validated_fix",
-    tasks: [
-      "Analyze project-wide implications of fixes",
-      "Suggest architectural or config-level improvements",
-      "Future-proof corrections for CI/CD and workspace",
-    ],
-    output: "strategic_fix_plan",
-    chemistry: "Durant — builds with long-range vision",
-  },
-  {
-    name: "final_review",
-    model: "llama3.1:latest",
-    role: "Team Captain",
-    trigger: "after_strategic_fix_plan",
-    tasks: ["Review all fixes for consistency", "Ensure build success", "Make the final call"],
-    output: "final_patch",
-    chemistry: "Jordan — closes with dominance",
-  },
-  {
-    name: "fallback",
-    model: "qwen:7b",
-    role: "Backup",
-    trigger: "after_final_review_fail",
-    tasks: [
-      "Provide alternative fixes if primary pipeline fails",
-      "Fresh perspective on the problem",
-    ],
-    output: "fallback_fix",
-    chemistry: "Iguodala — steps up when it matters most",
-  },
-];
-
-// ---------------------------------------------------------------------------
-// Decision flow — routes errors to the right starting stage
-// ---------------------------------------------------------------------------
-
-export type ErrorCategory = "syntax" | "type" | "build" | "dependency" | "complex" | "unknown";
-
-export function classifyError(error: string): ErrorCategory {
-  const lower = error.toLowerCase();
-  if (
-    lower.includes("unexpected token") ||
-    lower.includes("unterminated") ||
-    lower.includes("missing >") ||
-    lower.includes("jsx") ||
-    lower.includes("parsing error")
-  ) {
-    return "syntax";
-  }
-  if (
-    lower.includes("type error") ||
-    lower.includes("does not exist on type") ||
-    lower.includes("is not assignable") ||
-    lower.includes("ts(") ||
-    lower.includes("cannot find name")
-  ) {
-    return "type";
-  }
-  if (
-    lower.includes("module not found") ||
-    lower.includes("cannot find module") ||
-    lower.includes("yarn add") ||
-    lower.includes("pnpm add") ||
-    lower.includes("peer dep") ||
-    lower.includes("version mismatch")
-  ) {
-    return "dependency";
-  }
-  if (
-    lower.includes("build") ||
-    lower.includes("compile") ||
-    lower.includes("webpack") ||
-    lower.includes("next build") ||
-    lower.includes("tsc")
-  ) {
-    return "build";
-  }
-  if (
-    lower.includes("architecture") ||
-    lower.includes("refactor") ||
-    lower.includes("circular") ||
-    lower.includes("design")
-  ) {
-    return "complex";
-  }
-  return "unknown";
-}
-
-/** Get the starting stage index for an error category */
-function getStartStage(category: ErrorCategory): number {
-  switch (category) {
-    case "syntax":
-      return 0; // Start with falcon (syntax specialist)
-    case "type":
-      return 1; // Start with grok (deep analyst)
-    case "build":
-      return 2; // Start with mistral (fast reaction)
-    case "dependency":
-      return 3; // Start with gemma (dep coordinator)
-    case "complex":
-      return 4; // Start with mixtral (architect)
-    case "unknown":
-      return 2; // Default to mistral (first responder)
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Pipeline execution
-// ---------------------------------------------------------------------------
-
-export interface StageResult {
-  stage: string;
-  model: string;
-  role: string;
-  chemistry: string;
-  response: unknown;
-  durationMs: number;
-}
-
-export interface DiagnoseResult {
-  problem: string;
-  category: ErrorCategory;
-  stagesRun: StageResult[];
-  totalDurationMs: number;
-}
-
-/**
- * Run the Phil Jackson Triangle Pipeline.
- *
- * Routes the problem through models in sequence based on error category.
- * Each stage builds on the previous — like passing the ball around the
- * triangle until someone has the open shot.
- *
- * @param maxStages - Max models to consult (default: all 7). Use fewer for speed.
- */
-export async function runPipeline(
-  client: WarRoomClient,
-  problem: string,
-  maxStages = 7,
-): Promise<DiagnoseResult> {
-  const category = classifyError(problem);
-  const startIdx = getStartStage(category);
-  const totalStart = Date.now();
-
-  const stagesRun: StageResult[] = [];
-
-  // Build context that accumulates across stages
-  let context = problem;
-
-  for (let i = 0; i < maxStages && i < PIPELINE_STAGES.length; i++) {
-    const stageIdx = (startIdx + i) % PIPELINE_STAGES.length;
-    const stage = PIPELINE_STAGES[stageIdx];
-
-    const prompt = buildStagePrompt(stage, context, stagesRun);
-
-    const stageStart = Date.now();
-    let response: unknown;
-    try {
-      response = await client.ollamaGenerate(stage.model, prompt);
-    } catch (err) {
-      response = { error: `Model ${stage.model} unavailable: ${err}` };
-    }
-    const durationMs = Date.now() - stageStart;
-
-    const result: StageResult = {
-      stage: stage.name,
-      model: stage.model,
-      role: stage.role,
-      chemistry: stage.chemistry,
-      response,
-      durationMs,
-    };
-    stagesRun.push(result);
-
-    // Add this stage's output to the rolling context
-    const responseText =
-      typeof response === "object" && response !== null && "response" in response
-        ? String((response as Record<string, unknown>).response)
-        : JSON.stringify(response);
-    context += `\n\n--- ${stage.role} (${stage.model}) ---\n${responseText}`;
-  }
-
-  return {
-    problem,
-    category,
-    stagesRun,
-    totalDurationMs: Date.now() - totalStart,
-  };
-}
-
-/**
- * Quick diagnose — only runs the most relevant model for the error type.
- * Fast. One model. One answer. Like a fast break.
- */
-export async function quickDiagnose(
-  client: WarRoomClient,
-  problem: string,
-): Promise<DiagnoseResult> {
-  return runPipeline(client, problem, 1);
-}
-
-/**
- * Deep diagnose — runs all 7 models. Full triangle rotation.
- * Takes longer but gives a 360-degree view of the problem.
- */
-export async function deepDiagnose(
-  client: WarRoomClient,
-  problem: string,
-): Promise<DiagnoseResult> {
-  return runPipeline(client, problem, 7);
-}
-
-// ---------------------------------------------------------------------------
-// Prompt construction
-// ---------------------------------------------------------------------------
-
-function buildStagePrompt(
-  stage: PipelineStage,
-  context: string,
-  previousResults: StageResult[],
-): string {
-  const taskList = stage.tasks.map((t, i) => `  ${i + 1}. ${t}`).join("\n");
-
-  let prompt = `You are the ${stage.role} in the Phil Jackson Triangle Pipeline.
-Your job: ${stage.tasks[0]}
-
-PROBLEM:
-${context}
-
-YOUR TASKS:
-${taskList}
-
-`;
-
-  if (previousResults.length > 0) {
-    prompt += `PREVIOUS ANALYSIS FROM THE TEAM:\n`;
-    for (const prev of previousResults) {
-      const text =
-        typeof prev.response === "object" && prev.response !== null && "response" in prev.response
-          ? String((prev.response as Record<string, unknown>).response)
-          : JSON.stringify(prev.response);
-      prompt += `- ${prev.role} (${prev.model}): ${text.slice(0, 500)}\n`;
-    }
-    prompt += `\nBuild on their analysis. Don't repeat what they already found.\n`;
-  }
-
-  prompt += `\nBe concise and actionable. Give specific file paths, line numbers, and code fixes where possible. No fluff.`;
-
-  return prompt;
-}