Encode your project's intelligence — stack, architecture, constraints, patterns, and risks.
DNAManager
The DNAManager provides a high-level API for creating and managing ProjectDNA -- the structured encoding of your project's stack, architecture, constraints, learned patterns, and risk zones. It persists to manifest.crtx via CortexIO.
import { DNAManager, CortexIO } from '@codmir/cortex';Constructor
new DNAManager(io: CortexIO)| Parameter | Type | Description |
|---|---|---|
io | CortexIO | The CortexIO instance for file operations |
const io = new CortexIO('/home/dev/my-project');
await io.init();
const dna = new DNAManager(io);Methods
initialize()
Creates a new ProjectDNA from scratch and writes it to manifest.crtx.
async initialize(opts: {
id: string;
name: string;
purpose: string;
stack: Partial<StackFingerprint>;
architectureType?: ArchitectureMap['type'];
ownerStyle?: string;
ownerPreferences?: string[];
}): Promise<ProjectDNA>| Parameter | Type | Description |
|---|---|---|
opts.id | string | Project identifier |
opts.name | string | Human-readable project name |
opts.purpose | string | One-line description of the project |
opts.stack | Partial<StackFingerprint> | Technology stack (languages, frameworks, etc.) |
opts.architectureType | string (optional) | One of 'monorepo', 'polyrepo', 'monolith', 'microservices'. Default: 'monorepo' |
opts.ownerStyle | string (optional) | Owner's coding style description |
opts.ownerPreferences | string[] (optional) | Owner's technology preferences |
const projectDna = await dna.initialize({
id: 'codmir',
name: 'Codmir',
purpose: 'AI-powered project management and development platform',
stack: {
languages: ['TypeScript'],
frameworks: ['Next.js', 'NestJS', 'React', 'Tauri'],
databases: ['PostgreSQL', 'Redis'],
infrastructure: ['Vercel', 'Railway', 'Cloudflare'],
aiProviders: ['Anthropic', 'OpenAI', 'Google'],
buildTools: ['turbo', 'tsup', 'pnpm'],
},
architectureType: 'monorepo',
ownerStyle: 'type-first, pragmatic',
ownerPreferences: ['TypeScript', 'Tailwind', 'Zod'],
});get()
Returns the current ProjectDNA, or null if not initialized.
async get(): Promise<ProjectDNA | null>addConstraint()
Adds a constraint to the project DNA.
async addConstraint(constraint: ProjectConstraint): Promise<void>await dna.addConstraint({
type: 'memory',
rule: 'Node heap must not exceed 7GB',
severity: 'must',
reason: 'System has 16GB RAM; uncapped builds crash the IDE',
});
await dna.addConstraint({
type: 'convention',
rule: 'All API responses wrapped in { data, meta } envelope',
severity: 'must',
reason: 'Desktop client unwraps automatically via successResponse()',
});addPattern()
Adds or updates a learned pattern. If a pattern with the same domain and pattern already exists, it is updated in place. The id and lastValidated fields are set automatically.
async addPattern(pattern: Omit<LearnedPattern, 'id' | 'lastValidated'>): Promise<void>| Parameter | Type | Description |
|---|---|---|
pattern.domain | string | Pattern category (e.g., 'auth', 'api', 'build') |
pattern.pattern | string | Description of the pattern |
pattern.confidence | number | Confidence score 0-1 |
pattern.learnedFrom | string[] | Source references (files, commits, etc.) |
await dna.addPattern({
domain: 'auth',
pattern: 'CLI tokens are opaque 32-char strings, not JWTs',
confidence: 1.0,
learnedFrom: ['apps/web/src/lib/auth.ts', 'CLAUDE.md'],
});addRisk()
Adds or updates a risk zone. If a risk with the same path exists, it is replaced.
async addRisk(risk: RiskZone): Promise<void>await dna.addRisk({
path: 'packages/types/src/api',
reason: 'Shared types between server and client; mismatches cause runtime errors',
breakFrequency: 5,
lastBroken: Date.now(),
mitigations: ['Zod schema validation on both sides', 'Integration tests'],
});updateArchitecture()
Partially updates the architecture map.
async updateArchitecture(update: Partial<ArchitectureMap>): Promise<void>await dna.updateArchitecture({
entryPoints: ['apps/web/src/app/layout.tsx', 'apps/server/src/main.ts'],
dataFlow: [
{
from: 'apps/desktop',
to: 'apps/web',
protocol: 'REST',
description: 'Auth, CRUD operations',
},
{
from: 'apps/desktop',
to: 'apps/server',
protocol: 'WebSocket',
description: 'Realtime events, voice, MCP',
},
],
});updateOwner()
Updates the owner style and/or preferences.
async updateOwner(style?: string, preferences?: string[]): Promise<void>getConstraints()
Returns constraints, optionally filtered by type.
async getConstraints(type?: ProjectConstraint['type']): Promise<ProjectConstraint[]>const securityConstraints = await dna.getConstraints('security');getPatterns()
Returns learned patterns, optionally filtered by domain.
async getPatterns(domain?: string): Promise<LearnedPattern[]>const authPatterns = await dna.getPatterns('auth');getRisks()
Returns all risk zones.
async getRisks(): Promise<RiskZone[]>briefing()
Returns a human-readable markdown summary of the project DNA. Useful for generating context for agents.
async briefing(): Promise<string>const brief = await dna.briefing();
console.log(brief);
// # Codmir
// AI-powered project management and development platform
//
// ## Stack
// Languages: TypeScript
// Frameworks: Next.js, NestJS, React, Tauri
// AI Providers: Anthropic, OpenAI, Google
//
// ## Architecture: monorepo
// ...Types
ProjectDNA
interface ProjectDNA {
version: 1;
project: {
id: string;
name: string;
purpose: string;
created: number;
updated: number;
};
stack: StackFingerprint;
architecture: ArchitectureMap;
constraints: ProjectConstraint[];
patterns: LearnedPattern[];
risks: RiskZone[];
owner: {
style: string;
preferences: string[];
timezone?: string;
};
}StackFingerprint
interface StackFingerprint {
languages: string[];
frameworks: string[];
databases: string[];
infrastructure: string[];
aiProviders: string[];
buildTools: string[];
}ArchitectureMap
interface ArchitectureMap {
type: 'monorepo' | 'polyrepo' | 'monolith' | 'microservices';
entryPoints: string[];
boundaries: ArchitectureBoundary[];
dataFlow: DataFlowEdge[];
}ProjectConstraint
interface ProjectConstraint {
type: 'memory' | 'cost' | 'latency' | 'security' | 'compliance' | 'convention';
rule: string;
severity: 'must' | 'should' | 'prefer';
reason: string;
}LearnedPattern
interface LearnedPattern {
id: string;
domain: string;
pattern: string;
confidence: number;
learnedFrom: string[];
lastValidated: number;
}RiskZone
interface RiskZone {
path: string;
reason: string;
breakFrequency: number;
lastBroken: number;
mitigations: string[];
}