@veewo/gitnexus 1.5.6 → 1.5.8

package/dist/cli/scope-manifest-config.js

@@ -1,37 +0,0 @@
-import { normalizeScopeRules, normalizeScopedPath } from '../core/ingestion/scope-filter.js';
-const SUPPORTED_DIRECTIVES = new Set(['extensions', 'repoalias', 'embeddings']);
-export function parseScopeManifestConfig(raw) {
-    const scopeRules = [];
-    const directives = {};
-    const lines = raw.split(/\r?\n/);
-    for (const [index, line] of lines.entries()) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        if (trimmed.startsWith('@')) {
-            const separatorIndex = trimmed.indexOf('=');
-            if (separatorIndex <= 1) {
-                throw new Error(`Invalid manifest directive at line ${index + 1}: ${trimmed}`);
-            }
-            const key = trimmed.slice(1, separatorIndex).trim().toLowerCase();
-            const value = trimmed.slice(separatorIndex + 1).trim();
-            if (!SUPPORTED_DIRECTIVES.has(key)) {
-                throw new Error(`Unknown manifest directive: @${key}`);
-            }
-            if (key === 'extensions')
-                directives.extensions = value;
-            else if (key === 'repoalias')
-                directives.repoAlias = value;
-            else if (key === 'embeddings')
-                directives.embeddings = value;
-            continue;
-        }
-        const normalized = normalizeScopedPath(trimmed);
-        if (normalized)
-            scopeRules.push(normalized);
-    }
-    return {
-        scopeRules: normalizeScopeRules(scopeRules),
-        directives,
-    };
-}

package/dist/cli/sync-manifest.d.ts

@@ -1,27 +0,0 @@
-export interface SyncManifestScopeOptions {
-    scopeManifest?: string;
-    scopePrefix?: string[] | string;
-}
-export type SyncManifestPolicy = 'ask' | 'update' | 'keep' | 'error';
-export interface SyncManifestDiffEntry {
-    directive: 'extensions' | 'repoAlias' | 'embeddings';
-    manifestValue?: string;
-    cliValue: string;
-}
-export interface EnforceSyncManifestConsistencyInput {
-    manifestPath?: string;
-    extensions?: string;
-    repoAlias?: string;
-    embeddings?: boolean;
-    policy?: SyncManifestPolicy;
-    stdinIsTTY?: boolean;
-    prompt?: (message: string) => Promise<'update' | 'keep'>;
-}
-export interface EnforceSyncManifestConsistencyResult {
-    decision: 'none' | 'update' | 'keep';
-    diff: SyncManifestDiffEntry[];
-}
-export declare function resolveDefaultSyncManifestPath(repoPath: string): string;
-export declare function shouldAutoUseSyncManifest(options?: SyncManifestScopeOptions): boolean;
-export declare function resolveScopeManifestForAnalyze(repoPath: string, options?: SyncManifestScopeOptions, pathExists?: (candidatePath: string) => Promise<boolean>): Promise<string | undefined>;
-export declare function enforceSyncManifestConsistency(input: EnforceSyncManifestConsistencyInput): Promise<EnforceSyncManifestConsistencyResult>;

package/dist/cli/sync-manifest.js

@@ -1,200 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { parseScopeManifestConfig } from './scope-manifest-config.js';
-import { normalizeRepoAlias, parseExtensionList } from './analyze-options.js';
-export function resolveDefaultSyncManifestPath(repoPath) {
-    return path.join(repoPath, '.gitnexus', 'sync-manifest.txt');
-}
-export function shouldAutoUseSyncManifest(options) {
-    if (options?.scopeManifest)
-        return false;
-    return parseScopePrefixCount(options?.scopePrefix) === 0;
-}
-export async function resolveScopeManifestForAnalyze(repoPath, options, pathExists = fileExists) {
-    if (options?.scopeManifest) {
-        return options.scopeManifest;
-    }
-    if (!shouldAutoUseSyncManifest(options)) {
-        return undefined;
-    }
-    const defaultManifestPath = resolveDefaultSyncManifestPath(repoPath);
-    if (await pathExists(defaultManifestPath)) {
-        return defaultManifestPath;
-    }
-    return undefined;
-}
-export async function enforceSyncManifestConsistency(input) {
-    if (!input.manifestPath) {
-        return { decision: 'none', diff: [] };
-    }
-    ensureConcreteManifestPath(input.manifestPath);
-    const raw = await fs.readFile(input.manifestPath, 'utf-8');
-    const parsed = parseScopeManifestConfig(raw);
-    const normalizedDirectives = normalizeManifestDirectives(parsed.directives);
-    const diff = computeDiff(normalizedDirectives, input);
-    const policy = normalizePolicy(input.policy);
-    if (diff.length === 0) {
-        if (policy === 'update') {
-            throw new Error('Sync manifest rewrite requires non-empty diff entries.');
-        }
-        return { decision: 'none', diff };
-    }
-    const decision = await resolveDecision(policy, input.manifestPath, diff, input.stdinIsTTY, input.prompt);
-    if (decision === 'update') {
-        const nextDirectives = mergeDirectivesForUpdate(normalizedDirectives, input);
-        const rewritten = renderSyncManifest(parsed.scopeRules, nextDirectives);
-        await fs.writeFile(input.manifestPath, rewritten, 'utf-8');
-    }
-    return {
-        decision,
-        diff,
-    };
-}
-function parseScopePrefixCount(scopePrefix) {
-    if (Array.isArray(scopePrefix))
-        return scopePrefix.length;
-    if (typeof scopePrefix === 'string')
-        return scopePrefix.trim() ? 1 : 0;
-    return 0;
-}
-async function fileExists(candidatePath) {
-    try {
-        await fs.stat(candidatePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function normalizePolicy(raw) {
-    if (!raw)
-        return 'ask';
-    if (raw === 'ask' || raw === 'update' || raw === 'keep' || raw === 'error')
-        return raw;
-    throw new Error(`Invalid --sync-manifest-policy value: ${raw}. Use ask|update|keep|error.`);
-}
-function normalizeManifestDirectives(directives) {
-    return {
-        extensions: normalizeExtensions(directives.extensions),
-        repoAlias: normalizeAlias(directives.repoAlias),
-        embeddings: normalizeEmbeddings(directives.embeddings),
-    };
-}
-function computeDiff(manifest, input) {
-    const diff = [];
-    if (input.extensions !== undefined) {
-        const cliValue = normalizeExtensions(input.extensions);
-        if (cliValue !== manifest.extensions) {
-            diff.push({ directive: 'extensions', manifestValue: manifest.extensions, cliValue: cliValue || '' });
-        }
-    }
-    if (input.repoAlias !== undefined) {
-        const cliValue = normalizeAlias(input.repoAlias);
-        if (cliValue !== manifest.repoAlias) {
-            diff.push({ directive: 'repoAlias', manifestValue: manifest.repoAlias, cliValue: cliValue || '' });
-        }
-    }
-    if (input.embeddings !== undefined) {
-        const cliValue = input.embeddings ? 'true' : 'false';
-        if (cliValue !== manifest.embeddings) {
-            diff.push({ directive: 'embeddings', manifestValue: manifest.embeddings, cliValue });
-        }
-    }
-    return diff;
-}
-async function resolveDecision(policy, manifestPath, diff, stdinIsTTY, prompt) {
-    if (policy === 'update' || policy === 'keep')
-        return policy;
-    if (policy === 'error') {
-        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}`);
-    }
-    if (stdinIsTTY === undefined) {
-        throw new Error('TTY prompt branch requires concrete stdin.isTTY evidence.');
-    }
-    const interactive = stdinIsTTY;
-    if (!interactive) {
-        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}\n` +
-            'Non-interactive mode requires --sync-manifest-policy ask|update|keep|error.');
-    }
-    const promptFn = prompt || defaultPrompt;
-    return promptFn([
-        formatMismatchHeader(manifestPath),
-        formatDiff(diff),
-        'Choose: update (rewrite sync-manifest) or keep (continue without rewrite).',
-    ].join('\n'));
-}
-function mergeDirectivesForUpdate(manifest, input) {
-    const merged = { ...manifest };
-    if (input.extensions !== undefined) {
-        merged.extensions = normalizeExtensions(input.extensions);
-    }
-    if (input.repoAlias !== undefined) {
-        merged.repoAlias = normalizeAlias(input.repoAlias);
-    }
-    if (input.embeddings !== undefined) {
-        merged.embeddings = input.embeddings ? 'true' : 'false';
-    }
-    return merged;
-}
-function renderSyncManifest(scopeRules, directives) {
-    const lines = [...scopeRules];
-    if (directives.extensions)
-        lines.push(`@extensions=${directives.extensions}`);
-    if (directives.repoAlias)
-        lines.push(`@repoAlias=${directives.repoAlias}`);
-    if (directives.embeddings)
-        lines.push(`@embeddings=${directives.embeddings}`);
-    return `${lines.join('\n')}\n`;
-}
-function normalizeExtensions(raw) {
-    if (raw === undefined)
-        return undefined;
-    const parsed = parseExtensionList(raw);
-    return parsed.length > 0 ? parsed.join(',') : undefined;
-}
-function normalizeAlias(raw) {
-    if (raw === undefined)
-        return undefined;
-    return normalizeRepoAlias(raw);
-}
-function normalizeEmbeddings(raw) {
-    if (raw === undefined)
-        return undefined;
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === 'true')
-        return 'true';
-    if (normalized === 'false')
-        return 'false';
-    throw new Error(`Invalid @embeddings directive value: ${raw}. Expected true or false.`);
-}
-function formatMismatchHeader(manifestPath) {
-    return `Explicit analyze options differ from sync manifest directives: ${manifestPath}`;
-}
-function formatDiff(diff) {
-    return diff
-        .map((entry) => `- @${entry.directive}: ${entry.manifestValue ?? '<unset>'} -> ${entry.cliValue}`)
-        .join('\n');
-}
-async function defaultPrompt(message) {
-    const rl = readline.createInterface({ input, output });
-    try {
-        const answer = await rl.question(`${message}\nUpdate sync-manifest now? [y/N] `);
-        return /^y(es)?$/i.test(answer.trim()) ? 'update' : 'keep';
-    }
-    finally {
-        rl.close();
-    }
-}
-function ensureConcreteManifestPath(manifestPath) {
-    const normalized = manifestPath.trim();
-    if (!normalized) {
-        throw new Error('Invalid placeholder manifest path: empty value.');
-    }
-    if (/placeholder/i.test(normalized) ||
-        /<\s*path\s*>/i.test(normalized) ||
-        /todo/i.test(normalized)) {
-        throw new Error(`Invalid placeholder manifest path: ${manifestPath}`);
-    }
-}

package/dist/cli/sync-manifest.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/sync-manifest.test.js

@@ -1,88 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { enforceSyncManifestConsistency } from './sync-manifest.js';
-async function writeManifest(filePath, content) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content, 'utf-8');
-}
-test('when explicit CLI values differ from manifest, TTY mode asks whether to update manifest', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
-    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    let promptMessage = '';
-    const result = await enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.ts',
-        policy: 'ask',
-        stdinIsTTY: true,
-        prompt: async (message) => {
-            promptMessage = message;
-            return 'keep';
-        },
-    });
-    assert.equal(result.decision, 'keep');
-    assert.match(promptMessage, /@extensions/i);
-    assert.match(promptMessage, /sync-manifest\.txt/i);
-    assert.match(promptMessage, /update/i);
-    assert.match(promptMessage, /keep/i);
-});
-test('non-TTY without explicit policy exits with actionable error', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
-    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    await assert.rejects(enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.ts',
-        stdinIsTTY: false,
-    }), /--sync-manifest-policy/i);
-});
-test('policy=update rewrites manifest with normalized directives', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
-    await writeManifest(manifestPath, ['Assets/', 'Packages/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    const result = await enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.ts,.tsx',
-        embeddings: true,
-        policy: 'update',
-    });
-    const rewritten = await fs.readFile(manifestPath, 'utf-8');
-    assert.equal(result.decision, 'update');
-    assert.equal(rewritten, ['Assets', 'Packages', '@extensions=.ts,.tsx', '@repoAlias=demo-repo', '@embeddings=true', ''].join('\n'));
-});
-test('rejects placeholder manifest path values', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-placeholder-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest-placeholder.txt');
-    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    await assert.rejects(enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.ts',
-        policy: 'keep',
-    }), /placeholder manifest path/i);
-});
-test('TTY prompt branch requires concrete stdin.isTTY evidence', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-tty-evidence-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
-    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    await assert.rejects(enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.ts',
-        policy: 'ask',
-        prompt: async () => 'keep',
-    }), /stdin\.isTTY evidence/i);
-});
-test('manifest rewrite requires non-empty diff entries', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-noop-'));
-    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
-    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
-    await assert.rejects(enforceSyncManifestConsistency({
-        manifestPath,
-        extensions: '.cs,.meta',
-        repoAlias: 'demo-repo',
-        embeddings: false,
-        policy: 'update',
-    }), /non-empty diff/i);
-});

package/dist/core/ingestion/unity-runtime-binding-rules.d.ts

@@ -1,26 +0,0 @@
-import type { KnowledgeGraph } from '../graph/types.js';
-import type { RuntimeClaimRule } from '../../mcp/local/runtime-claim-rule-registry.js';
-import type { UnityConfig } from '../config/unity-config.js';
-export interface UnityRuntimeBindingResult {
-    edgesInjected: number;
-    ruleResults: Array<{
-        ruleId: string;
-        edgesInjected: number;
-    }>;
-    diagnostics: UnityRuntimeBindingDiagnostics;
-}
-export interface UnityRuntimeBindingDiagnostics {
-    rulesEvaluated: number;
-    bindingsEvaluated: number;
-    bindingsByKind: Record<string, number>;
-    methodLookupCalls: number;
-    methodLookupCacheHits: number;
-    sceneRuntimeTraversalCalls: number;
-    sceneRuntimeTraversalCacheHits: number;
-    sceneRuntimeResourcesVisited: number;
-    anomalies: string[];
-    shouldAgentReport: boolean;
-    agentReportReason: string;
-    summary: string[];
-}
-export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], config: UnityConfig): UnityRuntimeBindingResult;