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.
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

470 lines
13 KiB
TypeScript

/**
* Ruby scope-resolution integration tests (U8).
*
* These tests exercise the scope-based resolution path. They validate
* class methods, module mixins,
* singleton methods, require_relative imports, constructor inference,
* block scope, class inheritance, and super resolution.
*/
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import path from 'path';
import fs from 'node:fs';
import os from 'node:os';
import {
getRelationships,
getNodesByLabel,
runPipelineFromRepo,
type PipelineResult,
} from './helpers.js';
function writeFixtureRepo(root: string, files: Record<string, string>): void {
for (const [rel, content] of Object.entries(files)) {
const abs = path.join(root, rel);
fs.mkdirSync(path.dirname(abs), { recursive: true });
fs.writeFileSync(abs, content, 'utf8');
}
}
// ---------------------------------------------------------------------------
// 1. Basic class method resolution
// ---------------------------------------------------------------------------
describe('Ruby scope: basic class method resolution', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-basic-'));
writeFixtureRepo(tmpDir, {
'models/user.rb': `
class User
def save
true
end
def greet
"hello"
end
end
`,
'app.rb': `
require_relative 'models/user'
def main
u = User.new
u.save
u.greet
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects User class', () => {
expect(getNodesByLabel(result, 'Class')).toContain('User');
});
it('detects save and greet as Method nodes', () => {
const methods = getNodesByLabel(result, 'Method');
expect(methods).toContain('save');
expect(methods).toContain('greet');
});
it('emits HAS_METHOD edges from User to save and greet', () => {
const edges = getRelationships(result, 'HAS_METHOD');
const userSave = edges.find((e) => e.source === 'User' && e.target === 'save');
const userGreet = edges.find((e) => e.source === 'User' && e.target === 'greet');
expect(userSave).toBeDefined();
expect(userGreet).toBeDefined();
});
it('resolves main → u.save() as CALLS edge', () => {
const calls = getRelationships(result, 'CALLS');
const saveCall = calls.find(
(c) => c.target === 'save' && c.source === 'main' && c.targetFilePath?.includes('user.rb'),
);
expect(saveCall).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 2. Module mixin with include
// ---------------------------------------------------------------------------
describe('Ruby scope: module mixin with include', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-mixin-'));
writeFixtureRepo(tmpDir, {
'serializable.rb': `
module Serializable
def serialize
to_json
end
end
`,
'user.rb': `
require_relative 'serializable'
class User
include Serializable
def save
serialize
end
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects User as Class and Serializable as Trait', () => {
expect(getNodesByLabel(result, 'Class')).toContain('User');
expect(getNodesByLabel(result, 'Trait')).toContain('Serializable');
});
it('emits IMPLEMENTS edge from User to Serializable', () => {
const impls = getRelationships(result, 'IMPLEMENTS');
const edge = impls.find((e) => e.source === 'User' && e.target === 'Serializable');
expect(edge).toBeDefined();
});
it('resolves save → serialize as CALLS edge', () => {
const calls = getRelationships(result, 'CALLS');
const serializeCall = calls.find((c) => c.target === 'serialize' && c.source === 'save');
expect(serializeCall).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 3. Singleton method (def self.foo)
// ---------------------------------------------------------------------------
describe('Ruby scope: singleton method (def self.foo)', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-singleton-'));
writeFixtureRepo(tmpDir, {
'config.rb': `
class Config
def self.load
new
end
def validate
true
end
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects Config class', () => {
expect(getNodesByLabel(result, 'Class')).toContain('Config');
});
it('detects load (singleton) and validate (instance) as Method nodes', () => {
const methods = getNodesByLabel(result, 'Method');
expect(methods).toContain('load');
expect(methods).toContain('validate');
});
it('emits HAS_METHOD edges from Config to both methods', () => {
const edges = getRelationships(result, 'HAS_METHOD');
const configLoad = edges.find((e) => e.source === 'Config' && e.target === 'load');
const configValidate = edges.find((e) => e.source === 'Config' && e.target === 'validate');
expect(configLoad).toBeDefined();
expect(configValidate).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 4. Require/require_relative import resolution
// ---------------------------------------------------------------------------
describe('Ruby scope: require_relative import resolution', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-imports-'));
writeFixtureRepo(tmpDir, {
'lib/utils.rb': `
class Utils
def format(text)
text.strip
end
end
`,
'app.rb': `
require_relative 'lib/utils'
def run
u = Utils.new
u.format("hello")
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('emits IMPORTS edge from app.rb to lib/utils.rb', () => {
const imports = getRelationships(result, 'IMPORTS');
const imp = imports.find(
(e) => e.sourceFilePath?.includes('app.rb') && e.targetFilePath?.includes('utils.rb'),
);
expect(imp).toBeDefined();
});
it('resolves run → u.format() as CALLS edge to utils.rb', () => {
const calls = getRelationships(result, 'CALLS');
const formatCall = calls.find(
(c) => c.target === 'format' && c.source === 'run' && c.targetFilePath?.includes('utils.rb'),
);
expect(formatCall).toBeDefined();
});
it('detects Utils class and format method', () => {
expect(getNodesByLabel(result, 'Class')).toContain('Utils');
expect(getNodesByLabel(result, 'Method')).toContain('format');
});
});
// ---------------------------------------------------------------------------
// 5. Constructor inference (User.new)
// ---------------------------------------------------------------------------
describe('Ruby scope: constructor inference via .new', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-ctor-'));
writeFixtureRepo(tmpDir, {
'formatter.rb': `
class Formatter
def format(text)
text.upcase
end
end
def main
f = Formatter.new
f.format("hello")
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects Formatter class and format method', () => {
expect(getNodesByLabel(result, 'Class')).toContain('Formatter');
expect(getNodesByLabel(result, 'Method')).toContain('format');
});
it('emits HAS_METHOD edge from Formatter to format', () => {
const edges = getRelationships(result, 'HAS_METHOD');
const fmtEdge = edges.find((e) => e.source === 'Formatter' && e.target === 'format');
expect(fmtEdge).toBeDefined();
});
it('resolves main → f.format() to Formatter#format via constructor inference', () => {
const calls = getRelationships(result, 'CALLS');
const formatCall = calls.find(
(c) =>
c.target === 'format' && c.source === 'main' && c.targetFilePath?.includes('formatter.rb'),
);
expect(formatCall).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 6. Block scope (do...end with params)
// ---------------------------------------------------------------------------
describe('Ruby scope: block scope with do...end', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-block-'));
writeFixtureRepo(tmpDir, {
'processor.rb': `
class Processor
def run
items = [1, 2, 3]
items.each do |item|
process(item)
end
end
def process(x)
x * 2
end
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects Processor class', () => {
expect(getNodesByLabel(result, 'Class')).toContain('Processor');
});
it('detects run and process as Method nodes on Processor', () => {
const methods = getNodesByLabel(result, 'Method');
expect(methods).toContain('run');
expect(methods).toContain('process');
});
it('emits HAS_METHOD edges from Processor to run and process', () => {
const edges = getRelationships(result, 'HAS_METHOD');
const procRun = edges.find((e) => e.source === 'Processor' && e.target === 'run');
const procProcess = edges.find((e) => e.source === 'Processor' && e.target === 'process');
expect(procRun).toBeDefined();
expect(procProcess).toBeDefined();
});
it('resolves run → process() as CALLS edge inside block scope', () => {
const calls = getRelationships(result, 'CALLS');
const processCall = calls.find((c) => c.target === 'process' && c.source === 'run');
expect(processCall).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 7. Class inheritance (EXTENDS)
// ---------------------------------------------------------------------------
describe('Ruby scope: class inheritance via <', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-inherit-'));
writeFixtureRepo(tmpDir, {
'animals.rb': `
class Animal
def speak
"..."
end
end
class Dog < Animal
def bark
speak
end
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects Animal and Dog as Class nodes', () => {
const classes = getNodesByLabel(result, 'Class');
expect(classes).toContain('Animal');
expect(classes).toContain('Dog');
});
it('emits EXTENDS edge from Dog to Animal', () => {
const extends_ = getRelationships(result, 'EXTENDS');
const edge = extends_.find((e) => e.source === 'Dog' && e.target === 'Animal');
expect(edge).toBeDefined();
});
it('resolves bark → speak as CALLS edge', () => {
const calls = getRelationships(result, 'CALLS');
const speakCall = calls.find((c) => c.target === 'speak' && c.source === 'bark');
expect(speakCall).toBeDefined();
});
});
// ---------------------------------------------------------------------------
// 8. Super resolution
// ---------------------------------------------------------------------------
describe('Ruby scope: super resolution in subclass', () => {
let result: PipelineResult;
let tmpDir: string;
beforeAll(async () => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruby-scope-super-'));
writeFixtureRepo(tmpDir, {
'hierarchy.rb': `
class Base
def greet
"hello"
end
end
class Child < Base
def greet
super
end
end
def main
c = Child.new
c.greet
end
`,
});
result = await runPipelineFromRepo(tmpDir, () => {});
}, 60000);
afterAll(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('detects Base and Child as Class nodes', () => {
const classes = getNodesByLabel(result, 'Class');
expect(classes).toContain('Base');
expect(classes).toContain('Child');
});
it('emits EXTENDS edge from Child to Base', () => {
const extends_ = getRelationships(result, 'EXTENDS');
const edge = extends_.find((e) => e.source === 'Child' && e.target === 'Base');
expect(edge).toBeDefined();
});
it('resolves main → c.greet() as CALLS edge', () => {
const calls = getRelationships(result, 'CALLS');
const greetCall = calls.find((c) => c.target === 'greet' && c.source === 'main');
expect(greetCall).toBeDefined();
});
});