This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/gitnexus/test/unit/text-generator.test.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

308 lines
10 KiB
TypeScript

import { describe, it, expect } from 'vitest';
import {
generateEmbeddingText,
truncateDescription,
extractDeclarationOnly,
} from '../../src/core/embeddings/text-generator.js';
import { isChunkableLabel } from '../../src/core/embeddings/types.js';
import type { EmbeddableNode } from '../../src/core/embeddings/types.js';
const baseNode: EmbeddableNode = {
id: 'Function:src/utils.ts:parseJSON',
name: 'parseJSON',
label: 'Function',
filePath: 'src/utils/parser.ts',
content: 'function parseJSON(text: string): Result<any> {\n return JSON.parse(text);\n}',
startLine: 10,
endLine: 12,
};
describe('text-generator', () => {
describe('generateEmbeddingText', () => {
it('includes metadata header for Function', () => {
const node: EmbeddableNode = {
...baseNode,
isExported: true,
repoName: 'backend-user-ms',
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Function: parseJSON');
expect(text).toContain('Repo: backend-user-ms');
expect(text).toContain('Path: src/utils/parser.ts');
expect(text).toContain('Export: true');
expect(text).toContain('function parseJSON');
});
it('includes Server line when serverName is set', () => {
const node: EmbeddableNode = {
...baseNode,
repoName: 'backend-user-ms',
serverName: 'user-service',
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Server: user-service');
});
it('omits Server line when serverName is undefined', () => {
const text = generateEmbeddingText(baseNode, baseNode.content);
expect(text).not.toContain('Server:');
});
it('includes truncated description', () => {
const node: EmbeddableNode = {
...baseNode,
description: 'This function parses JSON text and returns a typed result object.',
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('This function parses JSON text');
});
it('generates short node text for TypeAlias without chunking', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'TypeAlias',
name: 'Result',
content: 'type Result<T> = Success<T> | Error;',
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('TypeAlias: Result');
expect(text).toContain('type Result<T> = Success<T> | Error;');
});
it('generates Class text with AST-extracted method/field names', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Class',
name: 'Parser',
methodNames: ['parseJSON', 'validate'],
fieldNames: ['options', 'cache'],
content: `class Parser {
options: ParserOptions;
private cache: Map<string, any>;
parseJSON(text: string) { return JSON.parse(text); }
validate() { return true; }
}`,
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Class: Parser');
expect(text).toContain('Methods: parseJSON, validate');
expect(text).toContain('Properties: options, cache');
// Method bodies should NOT appear in declaration section
expect(text).not.toContain('return JSON.parse');
expect(text).not.toContain('return true');
});
it('generates Class text without method names when not provided', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Class',
name: 'Parser',
content: `class Parser {
parse(input) { }
}`,
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Class: Parser');
expect(text).not.toContain('Methods:');
});
it('generates Interface text with structural names and signatures', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Interface',
name: 'Handler',
methodNames: ['handle', 'validate'],
fieldNames: ['name'],
content: `interface Handler {
handle(event: Event): void;
validate(input: string): boolean;
readonly name: string;
}`,
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Interface: Handler');
expect(text).toContain('Methods: handle, validate');
expect(text).toContain('Properties: name');
expect(text).toContain('handle(event: Event): void;');
expect(text).toContain('readonly name: string;');
});
it('includes chunk body for structural node chunks', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Class',
name: 'Parser',
methodNames: ['parseJSON', 'validate'],
fieldNames: ['options', 'cache'],
content: `class Parser {
options: ParserOptions;
cache: Map<string, any>;
parseJSON(text: string) { return JSON.parse(text); }
validate() { return true; }
}`,
};
const chunkBody = `parseJSON(text: string) { return JSON.parse(text); }`;
const text = generateEmbeddingText(node, chunkBody);
expect(text).toContain('Class: Parser');
expect(text).toContain('Methods: parseJSON, validate');
expect(text).toContain('class Parser {');
expect(text).toContain('parseJSON(text: string) { return JSON.parse(text); }');
});
it('generates Struct text with structural metadata', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Struct',
name: 'User',
fieldNames: ['name', 'age'],
content: `struct User {
name: String,
age: u32,
}`,
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Struct: User');
expect(text).toContain('Properties: name, age');
expect(text).toContain('Container: struct User {');
expect(text).toContain('struct User {');
});
it('keeps compact container context on later structural chunks', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Class',
name: 'Parser',
methodNames: ['parseJSON', 'validate'],
fieldNames: ['options', 'cache'],
content: `class Parser {
options: ParserOptions;
cache: Map<string, any>;
parseJSON(text: string) { return JSON.parse(text); }
validate() { return true; }
}`,
};
const text = generateEmbeddingText(
node,
'validate() { return true; }',
{},
1,
'parseJSON(text: string) { return JSON.parse(text); }',
);
expect(text).toContain('Class: Parser');
expect(text).toContain('Container: class Parser {');
expect(text).toContain('[preceding context]: ...parseJSON(text: string)');
expect(text).not.toContain('Methods: parseJSON, validate');
expect(text).not.toContain('Properties: options, cache');
});
it('adds preceding context to non-structural chunk text', () => {
const text = generateEmbeddingText(
baseNode,
'return JSON.parse(text);',
{},
1,
'function parseJSON(text: string): Result<any> {',
);
expect(text).toContain('Function: parseJSON');
expect(text).toContain('[preceding context]: ...function parseJSON');
expect(text).toContain('return JSON.parse(text);');
});
});
describe('Constructor label', () => {
it('is recognized as chunkable', () => {
expect(isChunkableLabel('Constructor')).toBe(true);
});
it('is recognized as embeddable', () => {
const node: EmbeddableNode = {
...baseNode,
label: 'Constructor',
name: 'constructor',
content: 'constructor(private service: ApiClient) {\n this.service = service;\n}',
};
const text = generateEmbeddingText(node, node.content);
expect(text).toContain('Constructor: constructor');
expect(text).toContain('this.service = service');
});
});
describe('extractDeclarationOnly', () => {
it('strips method bodies from TS class', () => {
const content = `class Foo {
prop1: string;
method1() {
if (x) { nested }
}
method2() { return 1; }
}`;
const result = extractDeclarationOnly(content);
expect(result).toContain('class Foo {');
expect(result).toContain('prop1: string;');
expect(result).not.toContain('if (x)');
expect(result).not.toContain('return 1');
});
it('keeps single-line methods with semicolon (property initializers)', () => {
const content = `class Foo {
config = { timeout: 5000 };
count = 0;
}`;
const result = extractDeclarationOnly(content);
expect(result).toContain('config = { timeout: 5000 };');
expect(result).toContain('count = 0;');
});
it('returns empty for non-brace languages (Python)', () => {
const content = `class User:
def __init__(self, name):
self.name = name`;
const result = extractDeclarationOnly(content);
expect(result).toBe('');
});
it('preserves all fields in Rust struct', () => {
const content = `struct User {
name: String,
age: u32,
}`;
const result = extractDeclarationOnly(content);
expect(result).toContain('struct User {');
expect(result).toContain('name: String,');
expect(result).toContain('age: u32,');
});
it('preserves all lines in interface (no method bodies)', () => {
const content = `interface Handler {
handle(event: Event): void;
validate(input: string): boolean;
}`;
const result = extractDeclarationOnly(content);
expect(result).toContain('interface Handler {');
expect(result).toContain('handle(event: Event): void;');
expect(result).toContain('validate(input: string): boolean;');
});
});
describe('truncateDescription', () => {
it('returns short text unchanged', () => {
expect(truncateDescription('short text', 150)).toBe('short text');
});
it('truncates at sentence boundary', () => {
const text = 'First sentence. Second sentence. Third very long sentence that goes on and on.';
const result = truncateDescription(text, 40);
expect(result).toContain('First sentence');
expect(result.length).toBeLessThan(text.length);
});
it('truncates at word boundary when no sentence end', () => {
const text =
'this is a long description without any sentence ending punctuation marks at all';
const result = truncateDescription(text, 30);
expect(result.length).toBeLessThanOrEqual(30);
expect(result.length).toBeLessThan(text.length);
});
});
});