Does holaOS Offer Code Refactoring Assistance?

Yes, holaOS provides native code refactoring assistance through its Personal Intelligence (PI) runtime tools, specifically via codex.ts, claude-code.ts, and pi-runtime-tools.ts, which expose LLM-driven endpoints for automated code transformation.

holaOS is an open-source AI operating system that embeds refactoring capabilities directly into its runtime harness. According to the source code analysis, the platform contains dedicated modules designed to parse, summarize, and rewrite code programmatically on behalf of the user.

How holaOS Implements Code Refactoring

The refactoring functionality in holaOS is distributed across three primary TypeScript modules located in runtime/harness-host/src/. Grep analysis identified 8 matches for the term "refactor" throughout the repository, confirming that code transformation is treated as a first-class operation within the system.

PI Runtime Tools Architecture

The pi-runtime-tools.ts module serves as the central orchestration layer for refactoring tasks. It exposes a unified API that accepts refactoring instructions and dispatches them to the appropriate LLM backend based on the task complexity.

Core LLM Backend Modules

• codex.ts: Handles OpenAI Codex-powered code generation and refactoring (Line 1 contains LLM integration imports).
• claude-code.ts: Wraps Claude-based refactoring logic for complex semantic transformations.
• code-summary.ts: Generates preliminary code summaries at runtime/harness-host/src/code-summary.ts (Line 1) to inform refactoring decisions before transformation.

Evidence in Test Suites

The presence of refactoring logic is further confirmed in runtime/harness-host/src/codex.test.ts, where Line 2 indicates test coverage for code-generation scenarios that include refactoring workflows.

Practical Refactoring Examples

The following examples demonstrate how developers invoke refactoring operations through the holaOS PI-tool API.

Refactoring with PI Runtime Tools

Use the piTool function to submit structured refactoring requests with specific language targeting:

import { piTool } from '@/runtime/harness-host/src/pi-runtime-tools';

// Split a monolithic function into pure helpers
await piTool({
  type: 'refactor',
  language: 'javascript',
  input: `
function calculate(a, b) {
  const sum = a + b;
  const product = a * b;
  return { sum, product };
}
`,
  instruction: 'Split the function into two separate functions: one that computes the sum, another that computes the product, and then compose them.'
});

Codex-Powered Code Transformation

The codex module handles large-scale syntactic conversions across frameworks:

import { codex } from '@/runtime/harness-host/src/codex';

// Modernize React class components to functional components with hooks
await codex({
  prompt: 'Convert this React class component to a functional component using useState and useEffect.',
  code: `
class Counter extends React.Component {
  state = { count: 0 };
  componentDidMount() {
    document.title = \`Count: \${this.state.count}\`;
  }
  render() {
    return <button onClick={() => this.setState({ count: this.state.count + 1 })}>+</button>;
  }
}
`
});

Claude-Assisted Type Refactoring

For TypeScript-specific semantic analysis and type-level improvements:

import { claudeCode } from '@/runtime/harness-host/src/claude-code';

// Apply strict typing transformations across files
await claudeCode({
  action: 'refactor',
  target: 'src/utils/helpers.ts',
  instruction: 'Replace all `any` types with proper generics and add missing JSDoc comments.'
});

Key Source Files for Refactoring

File	Purpose
runtime/harness-host/src/codex.ts	OpenAI Codex integration for code generation and refactoring
runtime/harness-host/src/claude-code.ts	Anthropic Claude wrapper for semantic code transformations
runtime/harness-host/src/pi-runtime-tools.ts	Orchestration layer for PI-tool refactoring commands
runtime/harness-host/src/code-summary.ts	Code analysis and summarization pre-refactoring
runtime/harness-host/src/codex.test.ts	Test coverage for refactoring and generation scenarios

Summary

• holaOS includes native code refactoring assistance through its PI runtime harness located in runtime/harness-host/src/.
• Three core modules—codex.ts, claude-code.ts, and pi-runtime-tools.ts—provide LLM-backed transformation capabilities with 8 documented references to refactoring operations in the source.
• The API supports task-specific refactoring via structured prompts, language parameters, and file targeting.
• Both JavaScript/TypeScript modernization and React component refactoring are supported through specialized backend modules.

Frequently Asked Questions

Does holaOS support automated refactoring for JavaScript and TypeScript?

Yes. The pi-runtime-tools.ts module accepts a language parameter that supports both JavaScript and TypeScript. The codex.ts and claude-code.ts backends parse these languages to apply syntax-aware transformations, such as converting class components to functional components or replacing any types with strict generics.

How does holaOS handle refactoring safety and validation?

holaOS processes refactoring operations as discrete turns in a conversation queue, as evidenced by the test structure in codex.test.ts. While the specific validation logic resides within the runtime harness, the modular architecture suggests that transformations are evaluated within the PI-tool sandbox before application to the target codebase.

Can holaOS refactor code across multiple files simultaneously?

Yes. The claudeCode function accepts a target parameter that specifies file paths, and the piTool API supports batch instructions. The orchestration capabilities in pi-runtime-tools.ts enable both sequential and parallel task dispatch for multi-file refactoring workflows.

What LLM backends does holaOS use for code refactoring?

holaOS utilizes a dual-backend approach. The codex.ts module interfaces with OpenAI Codex for code-specific operations, while claude-code.ts provides access to Anthropic Claude for semantic refactoring tasks. This allows the system to select the appropriate model based on whether the task requires syntactic or semantic analysis.

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