What Are the Dependencies for UditAkhourii/adhd? Complete Runtime Stack Guide

The UditAkhourii/adhd repository depends on three production packages—@anthropic-ai/claude-agent-sdk, p-limit, and zod—which provide the AI agent framework, concurrency limiting, and schema validation required for the tree-of-thought reasoning system.

The UditAkhourii/adhd project is a TypeScript-based skill built on the Claude Agent SDK that implements divergent thinking capabilities for AI agents. Understanding the dependencies for UditAkhourii/adhd is essential for developers looking to contribute to the codebase, troubleshoot runtime issues, or deploy the skill in production environments. According to the package.json file in the repository root, the project maintains a minimal runtime footprint with only three production dependencies while leveraging additional tools strictly for development and build processes.

Production Dependencies in UditAkhourii/adhd

The functional core of the ADHD project relies exclusively on three runtime dependencies declared in package.json (lines 58-63). These libraries handle everything from AI model interaction to data validation, eliminating unnecessary bloat while maintaining type safety and performance.

@anthropic-ai/claude-agent-sdk

The @anthropic-ai/claude-agent-sdk package (version ^0.1.0) provides the foundational Claude Agent SDK that drives the tree-of-thought reasoning engine. This dependency enables message handling, tool execution, and structured interaction with Anthropic's Claude models.

In src/agent.ts, the SDK is instantiated as follows:

import { ClaudeAgent } from '@anthropic-ai/claude-agent-sdk';

const agent = new ClaudeAgent({
  apiKey: process.env.CLAUDE_API_KEY,
  model: 'claude-3-5-sonnet-20240620',
});

p-limit

The p-limit package (version ^5.0.0) serves as a concurrency control mechanism, limiting the number of simultaneous asynchronous operations to prevent overwhelming the LLM API with parallel thought branches. This is crucial for managing resources when the agent explores multiple reasoning paths simultaneously.

As implemented in src/parallel.ts, the library creates a wrapper function that restricts concurrent execution:

import pLimit from 'p-limit';

const limit = pLimit(4); // run at most 4 branches concurrently

const branchPromises = thoughts.map(thought =>
  limit(() => agent.evaluateThought(thought))
);
await Promise.all(branchPromises);

Zod

The zod package (version ^3.23.0) provides runtime schema validation, ensuring that configuration objects and data structures conform to expected TypeScript shapes before processing. Unlike compile-time type checking, Zod validates data at runtime, catching malformed inputs that could destabilize the agent.

The src/schema.ts file demonstrates typical usage for validating agent configurations:

import { z } from 'zod';

const ConfigSchema = z.object({
  maxDepth: z.number().int().positive(),
  pruneThreshold: z.number().min(0).max(1),
});

type Config = z.infer<typeof ConfigSchema>;

function loadConfig(raw: unknown): Config {
  return ConfigSchema.parse(raw); // throws if validation fails
}

Development vs. Runtime Dependencies

While the production environment only requires the three dependencies above, the repository includes several devDependencies essential for building and maintaining the TypeScript source code. Packages such as @types/node, tsx, and typescript listed in package.json are only necessary during development, testing, and compilation phases. These tools provide type definitions and build utilities but are not loaded when the ADHD skill executes in production.

Integration Across the Codebase

The separation of concerns across the three runtime dependencies creates a robust architecture for handling complex AI workflows. The Claude Agent SDK manages the cognitive layer, p-limit governs execution flow to respect API rate limits, and Zod ensures data integrity throughout the pipeline. This specific combination allows the ADHD project to safely explore multiple reasoning branches without risking type errors or resource exhaustion.

Summary

• @anthropic-ai/claude-agent-sdk (^0.1.0): Core SDK providing the tree-of-thought reasoning framework and Claude model integration as implemented in src/agent.ts.
• p-limit (^5.0.0): Concurrency limiter that prevents API overload by restricting parallel thought branch execution, utilized in src/parallel.ts.
• zod (^3.23.0): Runtime validation library ensuring configuration objects and data structures meet schema requirements, defined in src/schema.ts.
• The package.json file declares these dependencies in the dependencies section, while development tools remain separate in devDependencies.

Frequently Asked Questions

What is the primary AI framework dependency in UditAkhourii/adhd?

The primary AI framework is @anthropic-ai/claude-agent-sdk, which provides the ClaudeAgent class and associated methods for tree-of-thought reasoning. This package handles all interactions with Anthropic's Claude models, including message formatting, tool calling, and response parsing according to the source code in src/agent.ts.

How does the ADHD repository manage API rate limits during parallel execution?

The project uses p-limit (version 5.0.0) to cap concurrent operations. By wrapping asynchronous functions in a limiter instance—typically configured to 4 concurrent branches as shown in src/parallel.ts—the agent prevents overwhelming the LLM API while still exploring multiple reasoning paths efficiently.

Is Zod used for compile-time type checking in the ADHD project?

No, Zod performs runtime validation. While TypeScript provides compile-time type safety, Zod schemas in src/schema.ts validate incoming configuration data and API responses during execution. This catches edge cases where data might bypass TypeScript's static analysis, such as environment variables or external API payloads parsed through ConfigSchema.parse().

Can I run the ADHD skill without installing devDependencies?

Yes, production deployments only require the three runtime dependencies listed in the dependencies section of package.json. The devDependencies—including typescript, tsx, and @types/node—are only necessary for building from source or development work. In a production container or compiled environment, you can install with npm install --production to exclude development packages.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}