Where Understand-Anything Configuration Is Stored: Complete File Structure Guide

Understand-Anything stores all per-project configuration in a hidden .understand-anything folder at the repository root, specifically within .understand-anything/config.json, which persists settings like autoUpdate and outputLanguage across sessions.

Understand-Anything is an open-source code analysis tool that generates knowledge graphs and summaries for your repositories. Understanding where this tool stores its Understand-Anything configuration is essential for team collaboration, CI/CD integration, and customization workflows. This guide examines the exact file paths, persistence mechanisms, and methods for accessing these settings both programmatically and through the CLI.

Where Understand-Anything Configuration Files Live

The .understand-anything Directory Structure

According to the Understand-Anything source code, the tool creates a hidden directory named .understand-anything at the root of your analyzed repository. This directory serves as the central storage location for both the configuration and the generated knowledge graph data.

The specific structure includes:

• .understand-anything/config.json — The primary configuration file
• .understand-anything/knowledge-graph.json — The generated graph data

The config.json File Format

The .understand-anything/config.json file stores JSON-encoded configuration flags. As defined in packages/core/src/types.ts, the ProjectConfig type specifies the structure:

{
  "autoUpdate": false,
  "outputLanguage": "en"
}

The autoUpdate boolean controls whether the knowledge graph regenerates automatically on every commit, while outputLanguage determines the language used for generated summaries and UI labels.

Core Persistence Implementation

The Persistence Module (index.ts)

In packages/core/src/persistence/index.ts, the persistence layer defines the constant CONFIG_FILE = "config.json" and exposes two primary functions for managing the Understand-Anything configuration.

The loadConfig(projectRoot) function reads the existing configuration or returns defaults if the file doesn't exist:

// From packages/core/src/persistence/index.ts (lines 40-47)
const config = loadConfig(process.cwd());
// Returns: { autoUpdate: false, outputLanguage: "en" } if file missing

The saveConfig(projectRoot, config) function writes updates back to disk:

// From packages/core/src/persistence/index.ts (lines 33-38)
saveConfig(process.cwd(), { autoUpdate: true, outputLanguage: 'zh' });

Default Configuration Values

When loadConfig encounters a missing or corrupted configuration file, it automatically falls back to the following default values as implemented in the persistence module:

• autoUpdate: false (manual graph regeneration)
• outputLanguage: "en" (English summaries and labels)

CLI-Based Configuration Updates

Auto-Update Flags

The /understand CLI command modifies .understand-anything/config.json directly when you pass specific flags. As documented in skills/understand/SKILL.md, the --auto-update flag writes {"autoUpdate": true} to the configuration file, while --no-auto-update writes {"autoUpdate": false}.

Example usage:

/understand --auto-update

Language Preferences

To change the output language persistently, use the --language flag followed by your desired language code. This stores the preference in the same configuration file, ensuring subsequent runs maintain consistency:

/understand --language zh

Programmatic Configuration Access

For developers building extensions or integrations, the @understand-anything/core package exports direct methods to manipulate the Understand-Anything configuration without spawning CLI processes.

Reading and writing configuration in Node.js/TypeScript:

import { loadConfig, saveConfig } from '@understand-anything/core/persistence';

// Load current project configuration
const config = loadConfig(process.cwd());
console.log('Current config:', config);

// Update settings programmatically
saveConfig(process.cwd(), { 
  autoUpdate: true, 
  outputLanguage: 'ja' 
});

Inspecting the raw file directly:

cat .understand-anything/config.json

Version Control and Deployment Considerations

Because the Understand-Anything configuration lives alongside your project code in the .understand-anything directory, you can choose to version-control these settings or exclude them via .gitignore. Storing config.json in Git ensures team members share consistent auto-update and language settings, though you may want to exclude the knowledge-graph.json file if it generates large diffs.

Summary

• Understand-Anything configuration resides in .understand-anything/config.json at your repository root
• The persistence layer in packages/core/src/persistence/index.ts handles all reads via loadConfig() and writes via saveConfig()
• Default values are autoUpdate: false and outputLanguage: "en"
• CLI flags --auto-update, --no-auto-update, and --language <lang> automatically modify the JSON configuration
• Configuration travels with your project and can be version-controlled or gitignored based on your workflow needs

Frequently Asked Questions

Where does Understand-Anything store its configuration?

Understand-Anything stores its configuration in a hidden folder named .understand-anything at the root of your repository, specifically within the file .understand-anything/config.json. This location keeps settings project-specific and portable across different development environments.

What is the default configuration for Understand-Anything?

The default configuration sets autoUpdate to false and outputLanguage to "en" (English). These values are hardcoded in the loadConfig function within packages/core/src/persistence/index.ts and apply when no configuration file exists or when the file is corrupted.

How do I change the output language in Understand-Anything permanently?

Use the CLI command /understand --language <lang> where <lang> is your desired language code (e.g., zh for Chinese or ja for Japanese). This writes the language preference to .understand-anything/config.json, ensuring all future runs use the specified language until changed again.

Can I version control the Understand-Anything configuration?

Yes, since .understand-anything/config.json is a standard JSON file in your repository, you can commit it to version control to share settings like autoUpdate and outputLanguage with your team. However, you may want to add knowledge-graph.json to .gitignore if the generated graph data creates unwanted noise in your commit history.

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