@tyvm/knowhow 0.0.89 → 0.0.91

package/leaderboard/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "leaderboard",
-  "version": "0.1.0",
-  "private": true,
-  "scripts": {
-    "dev": "next dev -p 3333",
-    "build": "next build",
-    "start": "next start",
-    "lint": "next lint"
-  },
-  "dependencies": {
-    "next": "^14.2.31",
-    "react": "^18",
-    "react-dom": "^18",
-    "recharts": "^2.8.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20",
-    "@types/react": "^18",
-    "@types/react-dom": "^18",
-    "autoprefixer": "^10.0.1",
-    "eslint": "^8",
-    "eslint-config-next": "14.0.0",
-    "postcss": "^8",
-    "tailwindcss": "^3.3.0",
-    "typescript": "^5"
-  }
-}

package/leaderboard/postcss.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

package/leaderboard/tailwind.config.js

@@ -1,17 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: [
-    './pages/**/*.{js,ts,jsx,tsx,mdx}',
-    './components/**/*.{js,ts,jsx,tsx,mdx}',
-    './app/**/*.{js,ts,jsx,tsx,mdx}',
-  ],
-  theme: {
-    extend: {
-      colors: {
-        background: 'var(--background)',
-        foreground: 'var(--foreground)',
-      },
-    },
-  },
-  plugins: [],
-}

package/leaderboard/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "lib": ["dom", "dom.iterable", "es6"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "preserve",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./*"]
-    }
-  },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"]
-}

package/leaderboard/types/benchmark.ts

@@ -1,67 +0,0 @@
-export interface BenchmarkConfig {
-  language: string;
-  maxExercises: number;
-  model: string;
-  provider: string;
-  agent?: string;
-  limits: BenchmarkLimits;
-  outputFile: string;
-}
-
-export interface BenchmarkLimits {
-  maxTurns: number;
-  maxTime: number;
-  maxCost: number;
-}
-
-export interface ExerciseResult {
-  exerciseName: string;
-  status: 'success' | 'failure' | 'timeout' | 'cost_limit' | 'turn_limit';
-  testResult?: any;
-  turns: number;
-  timeElapsed: number;
-  cost: number;
-  startTime: string;
-  endTime: string;
-  errorMessage?: string;
-  finalOutput?: string;
-}
-
-export interface BenchmarkResults {
-  config: BenchmarkConfig;
-  commitHash?: string;
-  exercises: ExerciseResult[];
-  summary: {
-    totalExercises: number;
-    testableExercises?: number;
-    testsPassedCount?: number;
-    testsFailedCount?: number;
-    testPassRate?: number;
-    agentSuccessRate?: number;
-    successCount: number;
-    failureCount: number;
-    timeoutCount: number;
-    costLimitCount: number;
-    turnLimitCount: number;
-    totalTime: number;
-    totalCost: number;
-    averageTurns: number;
-    averageTime: number;
-    successRate: number;
-  };
-  startTime: string;
-  endTime: string;
-}
-
-export interface LeaderboardEntry {
-  model: string;
-  provider: string;
-  language: string;
-  successRate: number;
-  totalExercises: number;
-  averageCost: number;
-  averageTime: number;
-  averageTurns: number;
-  totalRuns: number;
-  lastRun: string;
-}

package/leaderboard/utils/dataProcessor.ts

@@ -1,33 +0,0 @@
-import { LeaderboardEntry } from '@/types/benchmark';
-
-export async function loadLeaderboardData(): Promise<LeaderboardEntry[]> {
-  try {
-    const response = await fetch('/api/benchmark-data');
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    console.error('Error loading benchmark results:', error);
-    return [];
-  }
-}
-
-export function formatPercentage(value: number): string {
-  return `${value.toFixed(1)}%`;
-}
-
-export function formatCurrency(value: number): string {
-  return `$${value.toFixed(3)}`;
-}
-
-export function formatTime(seconds: number): string {
-  if (seconds < 60) {
-    return `${seconds.toFixed(1)}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return `${minutes}m ${remainingSeconds.toFixed(1)}s`;
-}
-
-export function formatNumber(value: number): string {
-  return value.toFixed(1);
-}

package/src/agents/tools/asana/definitions.ts

@@ -1,199 +0,0 @@
-export const definitions = [
-  {
-    type: "function",
-    function: {
-      name: "createTask",
-      description: "Create a new task in Asana",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          projectId: {
-            type: "string",
-            description: "The ID of the project where the task will be created",
-          },
-          taskName: {
-            type: "string",
-            description: "The name of the task to be created",
-          },
-          taskNotes: {
-            type: "string",
-            description: "The notes or description of the task",
-          },
-        },
-        required: ["projectId", "taskName", "taskNotes"],
-      },
-      returns: {
-        type: "object",
-        description: "The created task object",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "updateTask",
-      description: "Update an existing task in Asana",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          taskId: {
-            type: "string",
-            description: "The ID of the task to be updated",
-          },
-          updates: {
-            type: "object",
-            description:
-              "An object containing the updates to be applied to the task",
-          },
-        },
-        required: ["taskId", "updates"],
-      },
-      returns: {
-        type: "object",
-        description: "The updated task object",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "searchTasks",
-      description: "Search for tasks in Asana based on a search term",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          searchTerm: {
-            type: "string",
-            description: "The term to search for in task names and notes",
-          },
-        },
-        required: ["searchTerm"],
-      },
-      returns: {
-        type: "array",
-        description: "An array of tasks that match the search term",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "listProjects",
-      description: "List all projects in Asana",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {},
-        required: [],
-      },
-      returns: {
-        type: "array",
-        description: "An array of project objects",
-      },
-    },
-  },
-
-  {
-    type: "function",
-    function: {
-      name: "findTask",
-      description: "Find a specific task in Asana by its ID",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          taskId: {
-            type: "string",
-            description: "The ID of the task to be found",
-          },
-        },
-        required: ["taskId"],
-      },
-      returns: {
-        type: "object",
-        description: "The task object that matches the given ID",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "myTasks",
-      description:
-        "Retrieve tasks assigned to the current user in Asana, only shows the uncompleted ones",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          project: {
-            type: "string",
-            description: "The ID of the project to filter tasks by (optional)",
-          },
-        },
-        required: [],
-      },
-      returns: {
-        type: "array",
-        description: "An array of tasks assigned to the current user",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "getSubtasks",
-      description: "Retrieve all subtasks for a given Asana task.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          taskId: {
-            type: "string",
-            description:
-              "The ID of the parent task for which to retrieve subtasks.",
-          },
-        },
-        required: ["taskId"],
-      },
-      returns: {
-        type: "array",
-        description:
-          "An array of subtasks associated with the specified parent task.",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "createSubtask",
-      description: "Create a new subtask under a given Asana task.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          taskId: {
-            type: "string",
-            description:
-              "The ID of the parent task under which the subtask will be created.",
-          },
-          taskName: {
-            type: "string",
-            description: "The name of the subtask to be created.",
-          },
-          taskNotes: {
-            type: "string",
-            description: "The optional notes or description of the subtask.",
-          },
-        },
-        required: ["taskId", "taskName"],
-      },
-      returns: {
-        type: "object",
-        description: "The created subtask object.",
-      },
-    },
-  },
-];

package/src/agents/tools/asana/index.ts

@@ -1,108 +0,0 @@
-const workspace = process.env.ASANA_WORKSPACE;
-class AsanaTools {
-  private client = require("asana").ApiClient.instance;
-
-  constructor(private accessToken: string) {
-    this.client.authentications.token = process.env.ASANA_TOKEN;
-    this.client.defaultHeaders = {
-      "Asana-Enable": "new_user_task_lists,new_goal_memberships",
-    };
-  }
-
-  async createTask(projectId: string, taskName: string, taskNotes: string) {
-    if (!workspace) {
-      throw new Error("Need to set ENV Variable ASANA Workspace");
-    }
-
-    const task = await this.client.tasks.create({
-      workspace,
-      projects: [projectId],
-      name: taskName,
-      notes: taskNotes,
-    });
-    console.log(`Task created: ${task.permalink_url}`);
-    return task;
-  }
-
-  async updateTask(taskId: string, updates: object) {
-    const task = await this.client.tasks.updateTask(taskId, updates);
-    console.log(`Task updated: ${task.permalink_url}`);
-    return task;
-  }
-
-  async searchTasks(searchTerm: string) {
-    if (!workspace) {
-      throw new Error("Need to set ENV Variable ASANA Workspace");
-    }
-    searchTerm = searchTerm.toLowerCase();
-    const allTasks = await this.client.tasks.findAll({
-      opt_expand: "notes",
-      workspace,
-    });
-    const found = allTasks.data.filter(
-      (t) =>
-        t.notes.toLowerCase().includes(searchTerm) ||
-        t.name.toLowerCase().includes(searchTerm)
-    );
-
-    console.log("Found", found.length, "tasks");
-    return found;
-  }
-
-  async findTask(taskId: string) {
-    const task = await this.client.tasks.findById(taskId);
-    console.log(`Task found: ${task.permalink_url}`);
-    return task;
-  }
-
-  async getSubtasks(taskId: string) {
-    const tasks = await this.client.tasks.subtasks(taskId);
-    return tasks.data;
-  }
-
-  async createSubtask(taskId: string, taskName: string, taskNotes = "") {
-    const task = await this.client.tasks.addSubtask(taskId, {
-      name: taskName,
-      notes: taskNotes,
-    });
-    return task;
-  }
-
-  async myTasks(project?: string) {
-    const me = await this.client.users.me();
-    const tasks = await this.client.tasks.findAll({
-      assignee: Number(me.gid),
-      project,
-      workspace,
-      opt_expand: "completed",
-    });
-    return tasks.data.filter((t) => !t.completed);
-  }
-
-  async listProjects() {
-    if (!workspace) {
-      throw new Error("Need to set ENV Variable ASANA Workspace");
-    }
-    const allData = [];
-    let projects = await this.client.projects.findAll({
-      workspace,
-      archived: false,
-    });
-    do {
-      allData.push(...projects.data);
-      projects = await projects.nextPage();
-    } while (projects && projects?.data?.length);
-
-    return allData;
-  }
-}
-
-const asana = new AsanaTools(process.env.ASANA_TOKEN);
-export const createTask = asana.createTask.bind(asana);
-export const updateTask = asana.updateTask.bind(asana);
-export const searchTasks = asana.searchTasks.bind(asana);
-export const findTask = asana.findTask.bind(asana);
-export const getSubtasks = asana.getSubtasks.bind(asana);
-export const createSubtask = asana.createSubtask.bind(asana);
-export const myTasks = asana.myTasks.bind(asana);
-export const listProjects = asana.listProjects.bind(asana);

package/src/agents/tools/ast/astAppendNode.ts

@@ -1,90 +0,0 @@
-import * as fs from "fs";
-import { fileExists } from "../../../utils";
-import { services, ToolsService } from "../../../services";
-import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
-import { TreeEditor } from "../../../plugins/tree-sitter/editor";
-
-/**
- * Append a child node to a specific path in a file using tree-sitter AST parsing
- */
-export async function astAppendNode(filePath: string, parentPath: string, newContent: string): Promise<string> {
-  // Get context from bound ToolsService
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-
-  const context = toolService.getContext();
-
-  const exists = await fileExists(filePath);
-  if (!exists) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
-  // Read original content for event emission
-  let originalContent = "";
-  try {
-    originalContent = fs.readFileSync(filePath, "utf8");
-  } catch (error) {
-    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
-  }
-
-  // Emit pre-edit blocking event
-  if (context.Events) {
-    await context.Events.emitBlocking("file:pre-edit", {
-      filePath,
-      operation: "ast-append-node",
-      content: newContent,
-      originalContent,
-      astParentPath: parentPath,
-    });
-  }
-
-  try {
-    if (!LanguageAgnosticParser.supportsFile(filePath)) {
-      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
-    }
-
-    const parser = LanguageAgnosticParser.createParserForFile(filePath);
-    const editor = new TreeEditor(parser, originalContent);
-    const updatedEditor = editor.appendChild(parentPath, newContent);
-    const updatedContent = updatedEditor.getCurrentText();
-
-    // Write the updated content back to the file
-    fs.writeFileSync(filePath, updatedContent, "utf8");
-
-    // Emit post-edit blocking event (only on success)
-    let eventResults: any[] = [];
-    if (context.Events) {
-      eventResults = await context.Events.emitBlocking("file:post-edit", {
-        filePath,
-        operation: "ast-append-node",
-        content: newContent,
-        originalContent,
-        updatedContent,
-        astParentPath: parentPath,
-        success: true,
-      });
-    }
-
-    const result = {
-      file: filePath,
-      parentPath,
-      action: "appendChild",
-      success: true,
-      message: `Successfully appended child node to path: ${parentPath}`,
-    };
-
-    // Format event results
-    let eventResultsText = "";
-    if (eventResults && eventResults.length > 0) {
-      eventResultsText =
-        "\n\nAdditional Information:\n" +
-        JSON.stringify(eventResults, null, 2);
-    }
-
-    return JSON.stringify(result, null, 2) + eventResultsText;
-  } catch (error: any) {
-    // Do NOT emit post-edit event on error
-    throw new Error(`Failed to append node in ${filePath}: ${error.message}`);
-  }
-}

package/src/agents/tools/ast/astDeleteNode.ts

@@ -1,88 +0,0 @@
-import * as fs from "fs";
-import { fileExists } from "../../../utils";
-import { services, ToolsService } from "../../../services";
-import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
-import { TreeEditor } from "../../../plugins/tree-sitter/editor";
-
-/**
- * Delete a node at a specific path in a file using tree-sitter AST parsing
- */
-export async function astDeleteNode(filePath: string, path: string): Promise<string> {
-  // Get context from bound ToolsService
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-
-  const context = toolService.getContext();
-
-  const exists = await fileExists(filePath);
-  if (!exists) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
-  // Read original content for event emission
-  let originalContent = "";
-  try {
-    originalContent = fs.readFileSync(filePath, "utf8");
-  } catch (error) {
-    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
-  }
-
-  // Emit pre-edit blocking event
-  if (context.Events) {
-    await context.Events.emitBlocking("file:pre-edit", {
-      filePath,
-      operation: "ast-delete-node",
-      originalContent,
-      astPath: path,
-    });
-  }
-
-  try {
-    if (!LanguageAgnosticParser.supportsFile(filePath)) {
-      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
-    }
-
-    const parser = LanguageAgnosticParser.createParserForFile(filePath);
-    const editor = new TreeEditor(parser, originalContent);
-    const updatedEditor = editor.deleteNodeByPath(path);
-    const updatedContent = updatedEditor.getCurrentText();
-
-    // Write the updated content back to the file
-    fs.writeFileSync(filePath, updatedContent, "utf8");
-
-    // Emit post-edit blocking event (only on success)
-    let eventResults: any[] = [];
-    if (context.Events) {
-      eventResults = await context.Events.emitBlocking("file:post-edit", {
-        filePath,
-        operation: "ast-delete-node",
-        originalContent,
-        updatedContent,
-        astPath: path,
-        success: true,
-      });
-    }
-
-    const result = {
-      file: filePath,
-      path,
-      action: "delete",
-      success: true,
-      message: `Successfully deleted node at path: ${path}`,
-    };
-
-    // Format event results
-    let eventResultsText = "";
-    if (eventResults && eventResults.length > 0) {
-      eventResultsText =
-        "\n\nAdditional Information:\n" +
-        JSON.stringify(eventResults, null, 2);
-    }
-
-    return JSON.stringify(result, null, 2) + eventResultsText;
-  } catch (error: any) {
-    // Do NOT emit post-edit event on error
-    throw new Error(`Failed to delete node in ${filePath}: ${error.message}`);
-  }
-}