cliper-memory 0.1.0

package/dist/sdk/memoryBuilder.js

@@ -0,0 +1,821 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryBuilder = void 0;
+const path = __importStar(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const memoryDeduplicator_1 = require("./memoryDeduplicator");
+class MemoryBuilder {
+    buildGitMemory(projectName, gitContext) {
+        if (!gitContext.isGitRepo) {
+            return [];
+        }
+        return [{
+                id: "git-context",
+                type: "git",
+                title: "Git Context",
+                content: `
+Project: ${projectName}
+Branch: ${gitContext.branch}
+Latest Commit:
+${gitContext.lastCommit?.message ?? "None"}
+`.trim(),
+                metadata: {
+                    branch: gitContext.branch
+                }
+            }];
+    }
+    extractExports(content) {
+        const exports = new Set();
+        const patterns = [
+            /export\s+(?:async\s+)?function\s+([A-Za-z0-9_]+)/g,
+            /export\s+class\s+([A-Za-z0-9_]+)/g,
+            /export\s+const\s+([A-Za-z0-9_]+)/g,
+            /export\s+interface\s+([A-Za-z0-9_]+)/g,
+            /export\s+type\s+([A-Za-z0-9_]+)/g,
+        ];
+        for (const pattern of patterns) {
+            for (const match of content.matchAll(pattern)) {
+                exports.add(match[1]);
+            }
+        }
+        return [...exports];
+    }
+    inferPurpose(filePath) {
+        const name = path.basename(filePath, path.extname(filePath));
+        if (filePath === "src/index.ts") {
+            return "Entry point for the Cliper CLI";
+        }
+        const purposeMap = {
+            init: "Initialize repository analysis and context generation",
+            sync: "Synchronize repository state",
+            status: "Display repository status information",
+            scope: "Manage repository scope configuration",
+            auth: "Handle authentication workflows",
+            export: "Export repository context",
+            analyze: "Analyze repository structure and intelligence",
+            dependencies: "Build dependency relationships",
+            gitContext: "Collect git repository information",
+            fileTree: "Generate repository file tree",
+            fileContent: "Extract file contents",
+            urlFetcher: "Fetch and resolve external references",
+            detector: "Detect repository gaps and missing information",
+            builder: "Build repository context documents",
+            client: "Communicate with Cognee services",
+        };
+        return (purposeMap[name] ??
+            `Provide functionality related to ${name}`);
+    }
+    inferResponsibilities(file) {
+        const responsibilities = [];
+        const content = file.content;
+        if (content.includes("generateFileTree")) {
+            responsibilities.push("Build repository file tree");
+        }
+        if (content.includes("extractFileContents")) {
+            responsibilities.push("Extract file contents");
+        }
+        if (content.includes("getGitContext")) {
+            responsibilities.push("Collect git metadata");
+        }
+        if (content.includes("detectGaps")) {
+            responsibilities.push("Detect repository gaps");
+        }
+        if (content.includes("buildContextDoc")) {
+            responsibilities.push("Generate repository context");
+        }
+        if (content.includes("rememberContext")) {
+            responsibilities.push("Sync memories to Cognee");
+        }
+        if (content.includes("buildDependencyMap")) {
+            responsibilities.push("Build dependency graph");
+        }
+        return responsibilities;
+    }
+    getFileCategory(filePath) {
+        if (filePath === "src/index.ts") {
+            return "CLI Entry Point";
+        }
+        if (filePath.includes("/commands/")) {
+            return "CLI Command";
+        }
+        if (filePath.includes("/scanner/")) {
+            return "Repository Scanner";
+        }
+        if (filePath.includes("/resolver/")) {
+            return "Reference Resolver";
+        }
+        if (filePath.includes("/scope/")) {
+            return "Scope Management";
+        }
+        if (filePath.includes("/gaps/")) {
+            return "Gap Detection";
+        }
+        if (filePath.includes("/context/")) {
+            return "Context Builder";
+        }
+        if (filePath.includes("/cognee/")) {
+            return "Cognee Integration";
+        }
+        return "Project File";
+    }
+    extractExternalPackages(content) {
+        const packages = new Set();
+        const importRegex = /from\s+["']([^"']+)["']/g;
+        const requireRegex = /require\(["']([^"']+)["']\)/g;
+        for (const match of content.matchAll(importRegex)) {
+            const pkg = match[1];
+            if (!pkg.startsWith(".") &&
+                !pkg.startsWith("/")) {
+                packages.add(pkg);
+            }
+        }
+        for (const match of content.matchAll(requireRegex)) {
+            const pkg = match[1];
+            if (!pkg.startsWith(".") &&
+                !pkg.startsWith("/")) {
+                packages.add(pkg);
+            }
+        }
+        return [...packages];
+    }
+    buildFileSummary(file, dependencyMap) {
+        const imports = dependencyMap.edges
+            .filter(edge => edge.from === file.relativePath)
+            .map(edge => edge.to);
+        return {
+            path: file.relativePath,
+            category: this.getFileCategory(file.relativePath),
+            purpose: this.inferPurpose(file.relativePath),
+            exports: this.extractExports(file.content),
+            imports,
+            responsibilities: this.inferResponsibilities(file),
+            externalPackages: this.extractExternalPackages(file.content)
+        };
+    }
+    async buildCommitSummaries(projectRoot, gitContext) {
+        if (!gitContext.isGitRepo) {
+            return [];
+        }
+        const git = (0, simple_git_1.default)(projectRoot);
+        const commits = [];
+        if (gitContext.lastCommit) {
+            commits.push({
+                hash: gitContext.lastCommit.hash,
+                author: gitContext.lastCommit.author,
+                message: gitContext.lastCommit.message,
+                timeAgo: gitContext.lastCommit.timeAgo,
+                filesChanged: await this.getFilesChangedForCommit(git, gitContext.lastCommit.hash)
+            });
+        }
+        for (const commit of gitContext.recentCommits) {
+            commits.push({
+                hash: commit.hash,
+                author: commit.author,
+                message: commit.message,
+                timeAgo: commit.timeAgo,
+                filesChanged: await this.getFilesChangedForCommit(git, commit.hash)
+            });
+        }
+        return commits;
+    }
+    async buildCommitMemories(projectRoot, gitContext) {
+        const commits = await this.buildCommitSummaries(projectRoot, gitContext);
+        return commits.map(commit => ({
+            id: `commit:${commit.hash}`,
+            type: "commit",
+            title: commit.message,
+            content: `
+Commit:
+${commit.hash}
+
+Author:
+${commit.author}
+
+Message:
+${commit.message}
+
+Files Changed:
+${commit.filesChanged.join("\n")}
+
+Time:
+${commit.timeAgo}
+        `.trim(),
+            metadata: {
+                hash: commit.hash,
+                author: commit.author,
+                timeAgo: commit.timeAgo,
+            },
+            tags: ["git", "commit"],
+            relationships: [
+                "repository",
+                ...commit.filesChanged.map(file => `file:${file}`)
+            ],
+        }));
+    }
+    buildFileMemories(files, dependencyMap, semanticLabels, gitContext) {
+        return files.map(file => {
+            const summary = this.buildFileSummary(file, dependencyMap);
+            const semantic = semanticLabels.find(s => s.file === file.relativePath);
+            console.log(file.relativePath);
+            return {
+                id: `file:${summary.path}`,
+                type: "file",
+                title: summary.path,
+                content: this.buildFileSummaryContent(summary),
+                metadata: {
+                    ...summary,
+                    semantic
+                },
+                tags: [
+                    summary.category,
+                    ...(semantic?.tags ?? [])
+                ],
+                relationships: [
+                    ...summary.imports.map(file => `file:${file}`),
+                    ...gitContext.pullRequests
+                        .filter(pr => pr.changedFiles.includes(summary.path))
+                        .map(pr => `pr:${pr.number}`)
+                ]
+            };
+        });
+    }
+    buildFileSummaryContent(summary) {
+        return `
+        File: ${summary.path}
+
+        Category:
+        ${summary.category}
+
+        Purpose:
+        ${summary.purpose}
+
+        Responsibilities:
+        ${summary.responsibilities.join(", ") || "None"}
+
+        Exports:
+        ${summary.exports.join(", ") || "None"}
+
+        Imports:
+        ${summary.imports.join(", ") || "None"}
+
+        External Packages:
+        ${summary.externalPackages.join(", ") || "None"}
+        `.trim();
+    }
+    buildDependencyMemories(dependencyMap) {
+        return dependencyMap.edges.map(edge => ({
+            id: `${edge.from}->${edge.to}`,
+            type: "dependency",
+            title: `${edge.from} imports ${edge.to}`,
+            content: `
+    ${edge.from}
+    imports
+    ${edge.to}
+    `.trim(),
+            metadata: edge,
+            tags: [
+                "dependency"
+            ],
+            relationships: [
+                edge.from,
+                edge.to
+            ]
+        }));
+    }
+    buildExternalPackageMemories(dependencyMap) {
+        return dependencyMap.externalPackages.map(pkg => ({
+            id: `package:${pkg}`,
+            type: "package",
+            title: pkg,
+            content: `
+        External Package
+
+        ${pkg}
+        `.trim(),
+            metadata: {
+                package: pkg
+            },
+            tags: [
+                "package"
+            ],
+            relationships: []
+        }));
+    }
+    buildGapMemories(gaps) {
+        return gaps.map(gap => ({
+            id: `${gap.file}:${gap.line ?? 0}`,
+            type: "gap",
+            title: gap.description,
+            content: `
+            File:
+            ${gap.file}
+
+            Severity:
+            ${gap.severity}
+
+            Type:
+            ${gap.type}
+
+            Description:
+            ${gap.description}
+
+            Line:
+            ${gap.line ?? "Unknown"}
+        `.trim(),
+            metadata: gap,
+            tags: [
+                "gap",
+                gap.severity,
+                gap.type
+            ],
+            relationships: [
+                gap.file
+            ]
+        }));
+    }
+    buildArchitectureMemories(dependencyMap) {
+        const grouped = new Map();
+        for (const edge of dependencyMap.edges) {
+            if (!grouped.has(edge.from)) {
+                grouped.set(edge.from, new Set());
+            }
+            grouped.get(edge.from).add(edge.to);
+        }
+        return [...grouped.entries()].map(([module, imports]) => ({
+            id: module,
+            type: "architecture",
+            title: module,
+            content: `
+            Module:
+            ${module}
+
+            Depends on:
+            ${[...imports].join("\n")}
+            `.trim(),
+            metadata: {
+                module,
+                imports: [...imports]
+            },
+            tags: ["architecture"],
+            relationships: [...imports]
+        }));
+    }
+    buildResponsibilityMemories(files) {
+        const memories = [];
+        for (const file of files) {
+            const responsibilities = this.inferResponsibilities(file);
+            for (const responsibility of responsibilities) {
+                memories.push({
+                    id: `${file.relativePath}:${responsibility}`,
+                    type: "responsibility",
+                    title: responsibility,
+                    content: `
+Responsibility:
+${responsibility}
+
+Owner:
+${file.relativePath}
+`.trim(),
+                    metadata: {
+                        responsibility,
+                        owner: file.relativePath
+                    },
+                    tags: [
+                        "responsibility"
+                    ],
+                    relationships: [
+                        file.relativePath
+                    ]
+                });
+            }
+        }
+        return memories;
+    }
+    async getFilesChangedForCommit(git, hash) {
+        const output = await git.show([
+            "--name-only",
+            "--pretty=format:",
+            hash,
+        ]);
+        return output
+            .split("\n")
+            .map(line => line.trim())
+            .filter(Boolean);
+    }
+    buildRepositorySummary(options) {
+        const modules = new Set();
+        for (const file of options.files) {
+            const parts = file.relativePath.split("/");
+            if (parts.length > 1) {
+                modules.add(parts[1]);
+            }
+        }
+        return {
+            name: options.projectName,
+            root: options.projectRoot,
+            language: "TypeScript",
+            entryPoint: options.files.find(f => f.relativePath === "src/index.ts")?.relativePath,
+            fileCount: options.files.length,
+            dependencyCount: options.dependencyMap.edges.length,
+            externalPackageCount: options.dependencyMap.externalPackages.length,
+            branch: options.gitContext.branch,
+            modules: [...modules].sort()
+        };
+    }
+    buildRepositoryMemory(options) {
+        const repo = this.buildRepositorySummary(options);
+        return [{
+                id: repo.name,
+                type: "repository",
+                title: repo.name,
+                content: `
+                Repository:
+                ${repo.name}
+
+                Language:
+                ${repo.language}
+
+                Entry Point:
+                ${repo.entryPoint ?? "Unknown"}
+
+                Files:
+                ${repo.fileCount}
+
+                Dependencies:
+                ${repo.dependencyCount}
+
+                External Packages:
+                ${repo.externalPackageCount}
+
+                Branch:
+                ${repo.branch ?? "Unknown"}
+
+                Modules:
+                ${repo.modules.join("\n")}
+                `.trim(),
+                metadata: repo,
+                tags: [
+                    "repository"
+                ],
+                relationships: [
+                    "git-context",
+                    repo.entryPoint ?? "",
+                    "package.json",
+                    "README.md",
+                    "timeline",
+                    "statistics"
+                ].filter(Boolean)
+            }];
+    }
+    async buildReleaseSummaries(projectRoot, gitContext) {
+        if (!gitContext.isGitRepo) {
+            return [];
+        }
+        const git = (0, simple_git_1.default)(projectRoot);
+        const output = await git.raw([
+            "for-each-ref",
+            "--sort=-creatordate",
+            "--format=%(refname:short)|%(objectname)|%(creatordate:iso8601)|%(subject)",
+            "refs/tags"
+        ]);
+        if (!output.trim()) {
+            return [];
+        }
+        return output
+            .trim()
+            .split("\n")
+            .map(line => {
+            const [tag, commit, date, message] = line.split("|");
+            return {
+                tag,
+                commit,
+                date,
+                message
+            };
+        });
+    }
+    async buildReleaseMemories(projectRoot, gitContext) {
+        const releases = await this.buildReleaseSummaries(projectRoot, gitContext);
+        return releases.map(release => ({
+            id: `release:${release.tag}`,
+            type: "release",
+            title: release.tag,
+            content: `
+Release:
+${release.tag}
+
+Commit:
+${release.commit}
+
+Date:
+${release.date}
+
+Message:
+${release.message}
+`.trim(),
+            metadata: release,
+            tags: [
+                "release"
+            ],
+            relationships: [
+                "repository",
+                release.commit
+            ]
+        }));
+    }
+    async buildRepositoryStats(projectRoot, files, dependencyMap, gaps, gitContext) {
+        const releases = await this.buildReleaseSummaries(projectRoot, gitContext);
+        return {
+            files: files.length,
+            commits: 1 + gitContext.recentCommits.length,
+            releases: releases.length,
+            dependencies: dependencyMap.edges.length,
+            externalPackages: dependencyMap.externalPackages.length,
+            architectureModules: new Set(dependencyMap.edges.map(e => e.from)).size,
+            gaps: {
+                high: gaps.filter(g => g.severity === "high").length,
+                medium: gaps.filter(g => g.severity === "medium").length,
+                low: gaps.filter(g => g.severity === "low").length,
+            }
+        };
+    }
+    async buildRepositoryStatisticsMemory(projectRoot, files, dependencyMap, gaps, gitContext) {
+        const stats = await this.buildRepositoryStats(projectRoot, files, dependencyMap, gaps, gitContext);
+        return [{
+                id: "statistics",
+                type: "repository",
+                title: "Repository Statistics",
+                content: `
+                Repository Statistics
+
+                Files:
+                ${stats.files}
+
+                Commits:
+                ${stats.commits}
+
+                Releases:
+                ${stats.releases}
+
+                Dependencies:
+                ${stats.dependencies}
+
+                External Packages:
+                ${stats.externalPackages}
+
+                Architecture Modules:
+                ${stats.architectureModules}
+
+                High Severity Gaps:
+                ${stats.gaps.high}
+
+                Medium Severity Gaps:
+                ${stats.gaps.medium}
+
+                Low Severity Gaps:
+                ${stats.gaps.low}
+                `.trim(),
+                metadata: stats,
+                tags: [
+                    "repository",
+                    "statistics"
+                ],
+                relationships: []
+            }];
+    }
+    async buildTimelineEvents(projectRoot, gitContext) {
+        if (!gitContext.isGitRepo) {
+            return [];
+        }
+        const releases = await this.buildReleaseSummaries(projectRoot, gitContext);
+        const events = [];
+        for (const commit of gitContext.recentCommits) {
+            events.push({
+                date: commit.date,
+                type: "commit",
+                title: commit.message,
+                description: commit.message,
+                relatedId: commit.hash
+            });
+        }
+        if (gitContext.lastCommit) {
+            events.push({
+                date: gitContext.lastCommit.date,
+                type: "commit",
+                title: gitContext.lastCommit.message,
+                description: gitContext.lastCommit.message,
+                relatedId: gitContext.lastCommit.hash
+            });
+        }
+        for (const release of releases) {
+            events.push({
+                date: release.date,
+                type: "release",
+                title: release.tag,
+                description: release.message,
+                relatedId: release.tag
+            });
+        }
+        return events.sort((a, b) => new Date(b.date).getTime() -
+            new Date(a.date).getTime());
+    }
+    async buildTimelineMemories(projectRoot, gitContext) {
+        const events = await this.buildTimelineEvents(projectRoot, gitContext);
+        if (events.length === 0) {
+            return [];
+        }
+        return [{
+                id: "timeline",
+                type: "timeline",
+                title: "Project Timeline",
+                content: `
+Project Timeline
+
+${events.map(event => `
+${event.date}
+
+${event.type.toUpperCase()}
+
+${event.title}
+
+${event.description}
+`).join("\n")}
+`.trim(),
+                metadata: {
+                    eventCount: events.length
+                },
+                tags: [
+                    "timeline"
+                ],
+                relationships: [
+                    "repository",
+                    ...events.map(e => e.relatedId)
+                ]
+            }];
+    }
+    buildIssueMemories(gitContext) {
+        return gitContext.issues.map(issue => ({
+            id: `issue:${issue.number}`,
+            type: "issue",
+            title: `#${issue.number} ${issue.title}`,
+            content: `
+Issue:
+#${issue.number}
+
+Title:
+${issue.title}
+
+State:
+${issue.state}
+
+Author:
+${issue.author}
+
+Labels:
+${issue.labels.join(", ") || "None"}
+
+Created:
+${issue.createdAt}
+
+Updated:
+${issue.updatedAt}
+
+GitHub:
+${issue.url}
+`.trim(),
+            metadata: issue,
+            tags: [
+                "github",
+                "issue",
+                issue.state,
+                ...issue.labels
+            ],
+            relationships: [
+                "repository",
+                ...gitContext.pullRequests
+                    .filter(pr => pr.issues.includes(issue.number))
+                    .map(pr => `pr:${pr.number}`)
+            ]
+        }));
+    }
+    buildPullRequestMemories(gitContext) {
+        return gitContext.pullRequests.map(pr => ({
+            id: `pr:${pr.number}`,
+            type: "pull-request",
+            title: `PR #${pr.number} ${pr.title}`,
+            content: `
+Pull Request:
+#${pr.number}
+
+Title:
+${pr.title}
+
+State:
+${pr.state}
+
+Merged:
+${pr.merged}
+
+Commits:
+${pr.commits.length > 0
+                ? pr.commits.join("\n")
+                : "None"}
+
+Changed Files:
+${pr.changedFiles.length > 0
+                ? pr.changedFiles.join("\n")
+                : "None"}
+
+Author:
+${pr.author}
+
+Base:
+${pr.baseBranch}
+
+Head:
+${pr.headBranch}
+
+Created:
+${pr.createdAt}
+
+Updated:
+${pr.updatedAt}
+
+GitHub:
+${pr.url}
+`.trim(),
+            metadata: pr,
+            tags: [
+                "github",
+                "pull-request",
+                pr.state,
+                ...(pr.merged ? ["merged"] : [])
+            ],
+            relationships: [
+                "repository",
+                `branch:${pr.headBranch}`,
+                `branch:${pr.baseBranch}`,
+                ...pr.commits.map(c => `commit:${c}`),
+                ...pr.issues.map(i => `issue:${i}`),
+                ...pr.changedFiles.map(file => `file:${file}`)
+            ]
+        }));
+    }
+    async build(options) {
+        const memories = [];
+        memories.push(...this.buildGitMemory(options.projectName, options.gitContext));
+        memories.push(...this.buildFileMemories(options.files, options.dependencyMap, options.semanticLabels, options.gitContext));
+        memories.push(...this.buildDependencyMemories(options.dependencyMap));
+        memories.push(...this.buildExternalPackageMemories(options.dependencyMap));
+        memories.push(...await this.buildCommitMemories(options.projectRoot, options.gitContext));
+        memories.push(...this.buildGapMemories(options.gaps));
+        memories.push(...this.buildArchitectureMemories(options.dependencyMap));
+        memories.push(...this.buildResponsibilityMemories(options.files));
+        memories.push(...this.buildRepositoryMemory(options));
+        memories.push(...await this.buildRepositoryStatisticsMemory(options.projectRoot, options.files, options.dependencyMap, options.gaps, options.gitContext));
+        memories.push(...await this.buildReleaseMemories(options.projectRoot, options.gitContext));
+        memories.push(...await this.buildTimelineMemories(options.projectRoot, options.gitContext));
+        memories.push(...this.buildIssueMemories(options.gitContext));
+        memories.push(...this.buildPullRequestMemories(options.gitContext));
+        const deduplicator = new memoryDeduplicator_1.MemoryDeduplicator();
+        return deduplicator.deduplicate(memories);
+    }
+}
+exports.MemoryBuilder = MemoryBuilder;
+//# sourceMappingURL=memoryBuilder.js.map