onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/readers/viewpoint-collectors.js

@@ -1,229 +0,0 @@
-/**
- * 6관점별 코드 청크 수집 함수.
- *
- * 각 함수는 ScanResult + OntologyQueryResult의 구조 정보에서
- * 관점별로 관련 코드를 필터링한다. 결정론적이다.
- */
-// ─── Semantics ───
-export function collectSemantics(resolved, max) {
-    const chunks = [];
-    for (const loc of resolved) {
-        if (loc.resolution_method === "unresolved")
-            continue;
-        for (const filePath of loc.resolved_files) {
-            chunks.push({
-                file_path: filePath,
-                viewpoint: "semantics",
-                context: `온톨로지 매칭: ${loc.reference}`,
-            });
-            if (chunks.length >= max)
-                return chunks;
-        }
-    }
-    return chunks;
-}
-// ─── Dependency ───
-export function collectDependency(resolved, depGraph, max) {
-    const resolvedPaths = new Set();
-    for (const loc of resolved) {
-        for (const fp of loc.resolved_files)
-            resolvedPaths.add(fp);
-    }
-    const chunks = [];
-    // 1-hop: resolved 파일을 import하는 파일 (caller)
-    for (const edge of depGraph) {
-        if (resolvedPaths.has(edge.to)) {
-            chunks.push({
-                file_path: edge.from,
-                viewpoint: "dependency",
-                context: `${edge.to}를 import하는 파일 (caller, hop 1)`,
-            });
-        }
-        if (chunks.length >= max)
-            return chunks;
-    }
-    // 1-hop: resolved 파일이 import하는 파일 (callee)
-    for (const edge of depGraph) {
-        if (resolvedPaths.has(edge.from) && !resolvedPaths.has(edge.to)) {
-            chunks.push({
-                file_path: edge.to,
-                viewpoint: "dependency",
-                context: `${edge.from}이 import하는 파일 (callee, hop 1)`,
-            });
-        }
-        if (chunks.length >= max)
-            return chunks;
-    }
-    return chunks;
-}
-// ─── Logic ───
-export function collectLogic(ontologyResult, resolved, max) {
-    const chunks = [];
-    // guard_note/preconditions가 있는 action의 source_code 파일
-    for (const action of ontologyResult.related_actions) {
-        if (!action.guard_note && (!action.preconditions || action.preconditions.length === 0))
-            continue;
-        const parts = [];
-        if (action.guard_note)
-            parts.push(`guard: ${action.guard_note}`);
-        if (action.preconditions && action.preconditions.length > 0) {
-            parts.push(`preconditions: ${action.preconditions.map((p) => p.check).join(", ")}`);
-        }
-        // action의 source_code에서 파일 경로를 resolved에서 찾기
-        const matchedFiles = resolved
-            .filter((r) => r.resolution_method === "filename" && r.reference === action.source_code)
-            .flatMap((r) => r.resolved_files);
-        for (const fp of matchedFiles.length > 0 ? matchedFiles : []) {
-            chunks.push({
-                file_path: fp,
-                viewpoint: "logic",
-                context: `⚠️ 비즈니스 규칙: ${action.display_name} (${action.id}). ${parts.join("; ")}`,
-            });
-            if (chunks.length >= max)
-                return chunks;
-        }
-    }
-    // value_filters로 찾을 수 있는 코드 (값 수준 매핑 단서)
-    for (const vf of ontologyResult.value_filters) {
-        chunks.push({
-            viewpoint: "logic",
-            context: `⚠️ 값 수준 매핑: ${vf.entity}는 ${vf.column}='${vf.value}'로 식별됨. 이 값을 사용하는 코드를 확인하세요.`,
-            search_hint: `grep:${vf.value}`,
-        });
-        if (chunks.length >= max)
-            return chunks;
-    }
-    // resolved 파일 중 validation/guard 패턴이 있을 수 있는 파일
-    for (const loc of resolved) {
-        for (const fp of loc.resolved_files) {
-            if (fp.toLowerCase().includes("gateway") || fp.toLowerCase().includes("validator") || fp.toLowerCase().includes("guard")) {
-                chunks.push({
-                    file_path: fp,
-                    viewpoint: "logic",
-                    context: `⚠️ 검증/게이트웨이 코드: ${loc.reference}. 비즈니스 규칙 조건이 포함될 가능성이 높습니다.`,
-                });
-                if (chunks.length >= max)
-                    return chunks;
-            }
-        }
-    }
-    return chunks;
-}
-// ─── Structure ───
-export function collectStructure(resolved, files, schemas, configs, max) {
-    const chunks = [];
-    const resolvedNames = new Set();
-    for (const loc of resolved) {
-        const className = loc.reference.match(/^([A-Z][A-Za-z0-9]+)/)?.[1];
-        if (className)
-            resolvedNames.add(className.toLowerCase());
-    }
-    // 테스트 파일
-    for (const f of files) {
-        if (f.category !== "test")
-            continue;
-        const pathLower = f.path.toLowerCase();
-        if ([...resolvedNames].some((name) => pathLower.includes(name))) {
-            chunks.push({
-                file_path: f.path,
-                viewpoint: "structure",
-                context: `테스트 파일: 기대 동작이 명시되어 있을 수 있습니다`,
-            });
-            if (chunks.length >= max)
-                return chunks;
-        }
-    }
-    // 스키마 파일
-    for (const f of files) {
-        if (f.category !== "schema")
-            continue;
-        chunks.push({
-            file_path: f.path,
-            viewpoint: "structure",
-            context: `스키마 파일: DB 구조와 제약조건 확인`,
-        });
-        if (chunks.length >= max)
-            return chunks;
-    }
-    // 설정/환경변수 파일
-    for (const config of configs) {
-        chunks.push({
-            file_path: config.file,
-            viewpoint: "structure",
-            context: `설정: ${config.key} (환경변수/설정 파일)`,
-        });
-        if (chunks.length >= max)
-            return chunks;
-    }
-    return chunks;
-}
-// ─── Pragmatics ───
-export function collectPragmatics(matchedEntities, apiPatterns, resolved, max) {
-    const chunks = [];
-    const resolvedPaths = new Set();
-    for (const loc of resolved) {
-        for (const fp of loc.resolved_files)
-            resolvedPaths.add(fp);
-    }
-    // resolved 파일에 위치한 API 엔드포인트
-    for (const api of apiPatterns) {
-        if (resolvedPaths.has(api.file) || [...resolvedPaths].some((p) => api.file.includes(p.split("/").pop().replace(/\.\w+$/, "")))) {
-            chunks.push({
-                file_path: api.file,
-                viewpoint: "pragmatics",
-                context: `${api.method} ${api.path} — 사용자 접점 API 엔드포인트 (${api.line}행)`,
-            });
-            if (chunks.length >= max)
-                return chunks;
-        }
-    }
-    // entity 이름이 경로에 포함된 API
-    const entityLower = matchedEntities.map((e) => e.toLowerCase());
-    for (const api of apiPatterns) {
-        if (entityLower.some((e) => api.path.toLowerCase().includes(e))) {
-            if (!chunks.some((c) => c.file_path === api.file && c.context.includes(api.path))) {
-                chunks.push({
-                    file_path: api.file,
-                    viewpoint: "pragmatics",
-                    context: `${api.method} ${api.path} — 엔티티명이 경로에 포함된 API`,
-                });
-                if (chunks.length >= max)
-                    return chunks;
-            }
-        }
-    }
-    return chunks;
-}
-// ─── Evolution ───
-export function collectEvolution(resolved, files, schemas, max) {
-    const chunks = [];
-    // DB 접두사 세대 혼재 탐지
-    const legacyTables = schemas.filter((s) => s.table.startsWith("GT_") || s.table.startsWith("gt_"));
-    const newTables = schemas.filter((s) => s.table.startsWith("le_") || s.table.startsWith("LE_"));
-    if (legacyTables.length > 0 && newTables.length > 0) {
-        for (const lt of legacyTables.slice(0, 3)) {
-            chunks.push({
-                file_path: lt.file,
-                viewpoint: "evolution",
-                context: `세대 혼재: ${lt.table} (GT_ 레거시 접두사). 신규 le_ 테이블과 공존`,
-            });
-            if (chunks.length >= max)
-                return chunks;
-        }
-    }
-    // resolved 파일 중 v2/Impl 등 버전 패턴
-    for (const loc of resolved) {
-        for (const fp of loc.resolved_files) {
-            if (/[Vv]2|[Vv]3|Impl2|Legacy|Deprecated/i.test(fp)) {
-                chunks.push({
-                    file_path: fp,
-                    viewpoint: "evolution",
-                    context: `버전 패턴: ${fp.split("/").pop()} — 이전 버전과의 호환성 확인 필요`,
-                });
-                if (chunks.length >= max)
-                    return chunks;
-            }
-        }
-    }
-    return chunks;
-}

package/dist/core-runtime/reconstruct/seed-candidate-validation.js

@@ -1,385 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { isTargetMaterialKind, } from "../target-material-kind.js";
-function isoNow() {
-    return new Date().toISOString();
-}
-function normalizeRef(ref) {
-    return path.resolve(ref);
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function violation(args) {
-    return {
-        code: args.code,
-        message: args.message,
-        claim_id: args.claimId ?? null,
-        observation_id: args.observationId ?? null,
-    };
-}
-function malformedShape(message) {
-    return violation({
-        code: "schema_shape_invalid",
-        message,
-    });
-}
-function readEvidenceRef(value, claimId) {
-    const violations = [];
-    if (!isRecord(value)) {
-        return {
-            evidenceRef: null,
-            violations: [
-                violation({
-                    code: "evidence_ref_shape_invalid",
-                    message: "evidence_ref must be an object",
-                    claimId,
-                }),
-            ],
-        };
-    }
-    const observationId = value.observation_id;
-    const targetMaterialKind = value.target_material_kind;
-    const sourceRef = value.source_ref;
-    const location = value.location;
-    if (typeof observationId !== "string" || observationId.trim().length === 0) {
-        violations.push(violation({
-            code: "evidence_ref_shape_invalid",
-            message: "evidence_ref.observation_id is required",
-            claimId,
-        }));
-    }
-    if (typeof targetMaterialKind !== "string" ||
-        !isTargetMaterialKind(targetMaterialKind)) {
-        violations.push(violation({
-            code: "evidence_ref_shape_invalid",
-            message: "evidence_ref.target_material_kind must be a known target_material_kind",
-            claimId,
-            observationId: typeof observationId === "string" ? observationId : null,
-        }));
-    }
-    if (typeof sourceRef !== "string" || sourceRef.trim().length === 0) {
-        violations.push(violation({
-            code: "evidence_ref_shape_invalid",
-            message: "evidence_ref.source_ref is required",
-            claimId,
-            observationId: typeof observationId === "string" ? observationId : null,
-        }));
-    }
-    if (typeof location !== "string" || location.trim().length === 0) {
-        violations.push(violation({
-            code: "evidence_ref_shape_invalid",
-            message: "evidence_ref.location is required",
-            claimId,
-            observationId: typeof observationId === "string" ? observationId : null,
-        }));
-    }
-    if (violations.length > 0) {
-        return {
-            evidenceRef: null,
-            violations,
-        };
-    }
-    return {
-        evidenceRef: {
-            observation_id: observationId,
-            target_material_kind: targetMaterialKind,
-            source_ref: sourceRef,
-            location: location,
-        },
-        violations,
-    };
-}
-function isGenericClaimName(name, groupName) {
-    const normalized = name.trim().toLowerCase().replace(/[_\s-]+/g, "_");
-    const singularGroup = groupName.endsWith("ies")
-        ? groupName.slice(0, -3) + "y"
-        : groupName.endsWith("s")
-            ? groupName.slice(0, -1)
-            : groupName;
-    const normalizedGroup = singularGroup.toLowerCase().replace(/[_\s-]+/g, "_");
-    return new RegExp(`^${normalizedGroup}_?\\d+$`).test(normalized);
-}
-function readClaim(value, groupName) {
-    const violations = [];
-    if (!isRecord(value)) {
-        return {
-            claim: null,
-            violations: [malformedShape(`${groupName} claim must be an object`)],
-        };
-    }
-    const rawClaimId = value.claim_id;
-    const claimId = typeof rawClaimId === "string" && rawClaimId.trim().length > 0
-        ? rawClaimId
-        : null;
-    if (!claimId) {
-        violations.push(violation({
-            code: "claim_id_missing",
-            message: `${groupName} claim_id is required`,
-        }));
-    }
-    const rawName = value.name;
-    const name = typeof rawName === "string" && rawName.trim().length > 0
-        ? rawName.trim()
-        : null;
-    if (!name) {
-        violations.push(violation({
-            code: "claim_name_missing",
-            message: `${groupName} name is required`,
-            claimId,
-        }));
-    }
-    else if (isGenericClaimName(name, groupName)) {
-        violations.push(violation({
-            code: "claim_name_generic",
-            message: `${groupName} name must be a meaningful user-facing label, not a numbered placeholder`,
-            claimId,
-        }));
-    }
-    const rawStatement = value.statement;
-    const statement = typeof rawStatement === "string" ? rawStatement : "";
-    const rawEvidenceRefs = value.evidence_refs;
-    const evidenceRefs = [];
-    if (Array.isArray(rawEvidenceRefs)) {
-        for (const evidenceRefValue of rawEvidenceRefs) {
-            const parsed = readEvidenceRef(evidenceRefValue, claimId);
-            violations.push(...parsed.violations);
-            if (parsed.evidenceRef) {
-                evidenceRefs.push(parsed.evidenceRef);
-            }
-        }
-    }
-    return {
-        claim: {
-            claim_id: claimId ?? `${groupName}:missing-claim-id`,
-            name: name ?? "",
-            statement,
-            evidence_refs: evidenceRefs,
-        },
-        violations,
-    };
-}
-function collectClaims(seedCandidate) {
-    const claims = [];
-    const violations = [];
-    const raw = seedCandidate;
-    if (!isRecord(raw)) {
-        return {
-            claims,
-            violations: [malformedShape("SeedCandidateDirective must be an object")],
-        };
-    }
-    const purpose = readClaim(raw.purpose, "purpose");
-    violations.push(...purpose.violations);
-    if (purpose.claim)
-        claims.push(purpose.claim);
-    const arrayGroups = [
-        "non_goals",
-        "entities",
-        "relations",
-        "actions",
-        "properties",
-        "rules",
-    ];
-    for (const groupName of arrayGroups) {
-        const value = raw[groupName];
-        if (!Array.isArray(value)) {
-            violations.push(malformedShape(`${groupName} must be an array`));
-            continue;
-        }
-        for (const claimValue of value) {
-            const parsed = readClaim(claimValue, groupName);
-            violations.push(...parsed.violations);
-            if (parsed.claim)
-                claims.push(parsed.claim);
-        }
-    }
-    return { claims, violations };
-}
-function validateEvidenceRef(args) {
-    const violations = [];
-    const { claim, evidenceRef, observation, selectedObservationIds } = args;
-    if (!observation) {
-        violations.push(violation({
-            code: "unknown_observation_ref",
-            message: `evidence observation does not exist: ${evidenceRef.observation_id}`,
-            claimId: claim.claim_id,
-            observationId: evidenceRef.observation_id,
-        }));
-        return violations;
-    }
-    if (selectedObservationIds &&
-        !selectedObservationIds.has(evidenceRef.observation_id)) {
-        violations.push(violation({
-            code: "unselected_observation_ref",
-            message: `evidence observation was not selected by SourceObservationDirective: ${evidenceRef.observation_id}`,
-            claimId: claim.claim_id,
-            observationId: evidenceRef.observation_id,
-        }));
-    }
-    if (evidenceRef.target_material_kind !== observation.target_material_kind) {
-        violations.push(violation({
-            code: "material_kind_mismatch",
-            message: `evidence material kind ${evidenceRef.target_material_kind} does not match observation material kind ${observation.target_material_kind}`,
-            claimId: claim.claim_id,
-            observationId: evidenceRef.observation_id,
-        }));
-    }
-    if (normalizeRef(evidenceRef.source_ref) !== normalizeRef(observation.source_ref)) {
-        violations.push(violation({
-            code: "source_ref_mismatch",
-            message: "evidence source_ref does not match observation source_ref",
-            claimId: claim.claim_id,
-            observationId: evidenceRef.observation_id,
-        }));
-    }
-    if (evidenceRef.location !== observation.location) {
-        violations.push(violation({
-            code: "location_mismatch",
-            message: "evidence location does not match observation location",
-            claimId: claim.claim_id,
-            observationId: evidenceRef.observation_id,
-        }));
-    }
-    return violations;
-}
-export function validateSeedCandidate(params) {
-    const violations = [];
-    const { seedCandidate, sourceObservations, sourceObservationDirective, sourceObservationDirectiveValidation, } = params;
-    const seedCandidateSessionId = typeof seedCandidate.session_id === "string"
-        ? seedCandidate.session_id
-        : "";
-    if (seedCandidateSessionId.length === 0) {
-        violations.push(malformedShape("SeedCandidateDirective.session_id is required"));
-    }
-    if (seedCandidateSessionId !== sourceObservations.session_id) {
-        violations.push(violation({
-            code: "session_id_mismatch",
-            message: `seed candidate session_id ${seedCandidateSessionId} does not match source observations session_id ${sourceObservations.session_id}`,
-        }));
-    }
-    if (sourceObservationDirective &&
-        seedCandidateSessionId !== sourceObservationDirective.session_id) {
-        violations.push(violation({
-            code: "session_id_mismatch",
-            message: `seed candidate session_id ${seedCandidateSessionId} does not match source observation directive session_id ${sourceObservationDirective.session_id}`,
-        }));
-    }
-    if (sourceObservationDirectiveValidation &&
-        seedCandidateSessionId !== sourceObservationDirectiveValidation.session_id) {
-        violations.push(violation({
-            code: "session_id_mismatch",
-            message: `seed candidate session_id ${seedCandidateSessionId} does not match source observation directive validation session_id ${sourceObservationDirectiveValidation.session_id}`,
-        }));
-    }
-    if (sourceObservationDirectiveValidation &&
-        sourceObservationDirectiveValidation.validation_status !== "valid") {
-        violations.push(violation({
-            code: "prior_observation_directive_invalid",
-            message: "SourceObservationDirective validation must be valid before SeedCandidate validation",
-        }));
-    }
-    const observationsById = new Map(sourceObservations.observations.map((observation) => [
-        observation.observation_id,
-        observation,
-    ]));
-    let selectedObservationIds = null;
-    if (sourceObservationDirective) {
-        const selectedObservations = sourceObservationDirective.selected_observations;
-        if (!Array.isArray(selectedObservations)) {
-            violations.push(malformedShape("SourceObservationDirective.selected_observations must be an array when supplied"));
-        }
-        else {
-            selectedObservationIds = new Set(selectedObservations
-                .filter((selection) => isRecord(selection) && typeof selection.observation_id === "string")
-                .map((selection) => selection.observation_id));
-        }
-    }
-    const seenClaimIds = new Set();
-    const collectedClaims = collectClaims(seedCandidate);
-    violations.push(...collectedClaims.violations);
-    const claims = collectedClaims.claims;
-    let evidenceRefCount = 0;
-    for (const claim of claims) {
-        if (seenClaimIds.has(claim.claim_id)) {
-            violations.push(violation({
-                code: "duplicate_claim_id",
-                message: `duplicate semantic claim id: ${claim.claim_id}`,
-                claimId: claim.claim_id,
-            }));
-        }
-        seenClaimIds.add(claim.claim_id);
-        if (claim.statement.trim().length === 0) {
-            violations.push(violation({
-                code: "claim_statement_missing",
-                message: "claim statement is required",
-                claimId: claim.claim_id,
-            }));
-        }
-        if (claim.evidence_refs.length === 0) {
-            violations.push(violation({
-                code: "claim_evidence_missing",
-                message: "every semantic claim must cite at least one evidence ref",
-                claimId: claim.claim_id,
-            }));
-            continue;
-        }
-        for (const evidenceRef of claim.evidence_refs) {
-            evidenceRefCount += 1;
-            violations.push(...validateEvidenceRef({
-                claim,
-                evidenceRef,
-                observation: observationsById.get(evidenceRef.observation_id),
-                selectedObservationIds,
-            }));
-        }
-    }
-    return {
-        schema_version: "1",
-        session_id: seedCandidateSessionId,
-        created_at: isoNow(),
-        seed_candidate_ref: params.seedCandidateRef ?? null,
-        source_observations_ref: params.sourceObservationsRef ?? null,
-        source_observation_directive_ref: params.sourceObservationDirectiveRef ?? null,
-        source_observation_directive_validation_ref: params.sourceObservationDirectiveValidationRef ?? null,
-        validation_status: violations.length === 0 ? "valid" : "invalid",
-        semantic_claim_count: claims.length,
-        evidence_ref_count: evidenceRefCount,
-        validation_results: violations.length === 0
-            ? ["seed_candidate_evidence_valid"]
-            : ["seed_candidate_evidence_invalid"],
-        violations,
-    };
-}
-export async function writeSeedCandidateValidationArtifact(args) {
-    const [seedCandidateText, sourceObservationsText] = await Promise.all([
-        fs.readFile(args.seedCandidatePath, "utf8"),
-        fs.readFile(args.sourceObservationsPath, "utf8"),
-    ]);
-    const seedCandidate = parseYaml(seedCandidateText);
-    const sourceObservations = parseYaml(sourceObservationsText);
-    const sourceObservationDirective = args.sourceObservationDirectivePath
-        ? parseYaml(await fs.readFile(args.sourceObservationDirectivePath, "utf8"))
-        : null;
-    const sourceObservationDirectiveValidation = args.sourceObservationDirectiveValidationPath
-        ? parseYaml(await fs.readFile(args.sourceObservationDirectiveValidationPath, "utf8"))
-        : null;
-    const validation = validateSeedCandidate({
-        seedCandidate,
-        sourceObservations,
-        sourceObservationDirective,
-        sourceObservationDirectiveValidation,
-        seedCandidateRef: path.resolve(args.seedCandidatePath),
-        sourceObservationsRef: path.resolve(args.sourceObservationsPath),
-        sourceObservationDirectiveRef: args.sourceObservationDirectivePath
-            ? path.resolve(args.sourceObservationDirectivePath)
-            : null,
-        sourceObservationDirectiveValidationRef: args.sourceObservationDirectiveValidationPath
-            ? path.resolve(args.sourceObservationDirectiveValidationPath)
-            : null,
-    });
-    await fs.mkdir(path.dirname(args.outputPath), { recursive: true });
-    await fs.writeFile(args.outputPath, stringifyYaml(validation), "utf8");
-    return validation;
-}