What Programming Language Is thedotmack/claude-mem Written In?

The thedotmack/claude-mem repository is written primarily in TypeScript, a statically-typed superset of JavaScript that compiles to ES2022 for execution on Node.js 18+ or Bun 1+ runtimes.

The claude-mem project is a memory management system designed for Claude Code integrations. Understanding what programming language powers this codebase helps developers contribute effectively and deploy it correctly. The entire source tree lives under src/**/*.ts and leverages strict type-checking configurations to ensure runtime reliability.

TypeScript as the Primary Language

The claude-mem programming language is TypeScript, not vanilla JavaScript. Every module, utility, and service is implemented as a .ts file under the src/ directory. This choice provides compile-time type safety, interfaces for complex data structures, and modern ES2022 syntax support.

The project uses a tsconfig.json configuration that enforces strict type-checking and targets ES2022. This means the TypeScript compiler transpiles the source into JavaScript compatible with modern Node.js environments while catching type mismatches before deployment.

Runtime Requirements and Configuration

While the source is TypeScript, the runtime environment executes compiled JavaScript. The package.json specifies two supported runtimes:

• Node.js version 18 or higher
• Bun version 1 or higher

The tsconfig.json enforces strict compilation settings:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "sourceMap": true,
    "types": ["node"],
    "allowSyntheticDefaultImports": true
  },
  "include": ["src/**/*"]
}

This configuration confirms that TypeScript is the development language, with the compiler generating ES2022 JavaScript for modern runtime compatibility.

Key Source Files and Type Safety

The codebase demonstrates sophisticated use of TypeScript's type system across several critical modules.

Core Orchestration in worker-service.ts

The src/services/worker-service.ts file contains approximately 1,000 lines of TypeScript orchestrating the memory worker daemon. It defines strict interfaces for status communication:

export interface StatusOutput {
  continue: true;
  suppressOutput: true;
  status: 'ready' | 'error';
  message?: string;
}

/**
 * Returns a strongly‑typed status payload for the Claude Code hook system.
 */
export function buildStatusOutput(
  status: 'ready' | 'error',
  message?: string
): StatusOutput {
  return {
    continue: true,
    suppressOutput: true,
    status,
    ...(message && { message })
  };
}

This pattern of explicit return types and interface definitions appears throughout the service layer, ensuring that the Claude Code integration receives correctly shaped data payloads.

Utility Modules in logger.ts

The src/utils/logger.ts module implements a typed logging utility:

export const logger = {
  debug: (module: string, msg: string, meta?: unknown) => {/* ... */},
  info: (module: string, msg: string, meta?: unknown) => {/* ... */},
  warn: (module: string, msg: string, meta?: unknown) => {/* ... */},
  error: (module: string, msg: string, meta?: unknown, err?: Error) => {/* ... */}
};

Each method declares parameter types, preventing incorrect logging calls during development.

CLI Entry Point

The src/cli/claude-md-commands.ts file serves as the command-line interface entry point, written entirely in TypeScript and compiled to JavaScript for execution via Node.js or Bun.

Summary

• thedotmack/claude-mem is written primarily in TypeScript, not JavaScript.
• Source files reside in src/**/*.ts and compile to ES2022 JavaScript for modern runtimes.
• The project requires Node.js 18+ or Bun 1+ as specified in package.json.
• Strict type-checking is enforced via tsconfig.json, ensuring robust type safety across modules like worker-service.ts and logger.ts.

Frequently Asked Questions

Is claude-mem written in JavaScript or TypeScript?

Claude-mem is written in TypeScript. While it runs on JavaScript engines (Node.js or Bun), the source code uses .ts file extensions, strict type interfaces, and TypeScript-specific syntax that compiles down to JavaScript.

What Node.js version is required to run claude-mem?

The package.json specifies Node.js version 18 or higher. This requirement aligns with the ES2022 compilation target defined in tsconfig.json, ensuring compatibility with modern JavaScript features used by the compiled TypeScript output.

Does claude-mem support Bun as an alternative runtime?

Yes, the project explicitly supports Bun version 1 or higher as an alternative to Node.js. The engines field in package.json lists both runtimes, and the ES2022 module output is compatible with Bun's JavaScript runtime environment.

Where are the main TypeScript source files located?

All TypeScript source files are located under the src/ directory with the .ts extension. Key files include src/services/worker-service.ts (core orchestration), src/utils/logger.ts (typed utilities), and src/cli/claude-md-commands.ts (CLI interface). The tsconfig.json includes pattern src/**/* to compile all files in this tree.

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