@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/research/services/citation.js

@@ -0,0 +1,279 @@
+/**
+ * Citation service for formatting and validating citations
+ *
+ * @module research/services/citation
+ */
+import { promises as fs } from 'fs';
+/**
+ * Citation service for managing citations and networks
+ */
+export class CitationService {
+    corpusPath;
+    claimsIndexPath;
+    constructor(config = {}) {
+        this.corpusPath = config.corpusPath || '.aiwg/research/sources';
+        this.claimsIndexPath = config.claimsIndexPath || '.aiwg/research/claims-index.json';
+    }
+    /**
+     * Format citation in specified style
+     */
+    formatCitation(paper, style = 'apa') {
+        switch (style) {
+            case 'apa':
+                return this.formatAPA(paper);
+            case 'bibtex':
+                return this.formatBibTeX(paper);
+            case 'chicago':
+                return this.formatChicago(paper);
+            case 'mla':
+                return this.formatMLA(paper);
+            case 'ieee':
+                return this.formatIEEE(paper);
+            default:
+                return this.formatAPA(paper);
+        }
+    }
+    /**
+     * Validate that a citation exists in corpus
+     */
+    async validateCitation(refId, corpusPath) {
+        const path = corpusPath || this.corpusPath;
+        try {
+            const files = await fs.readdir(path);
+            return files.some((file) => file.startsWith(refId));
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Build citation network from papers
+     */
+    buildNetwork(papers) {
+        const nodes = papers.map((paper) => ({
+            refId: paper.id,
+            title: paper.title,
+            year: paper.year,
+            citationCount: paper.citationCount || 0,
+        }));
+        // For now, return empty edges (full implementation would extract references)
+        const edges = [];
+        // Calculate simple metrics
+        const sortedByCitations = [...nodes].sort((a, b) => b.citationCount - a.citationCount);
+        const mostCitedPapers = sortedByCitations.slice(0, 5).map((n) => n.refId);
+        return {
+            nodes,
+            edges,
+            metrics: {
+                mostCitedPapers,
+                mostInfluentialPapers: mostCitedPapers, // Simplified
+                clusterCenters: [], // Would require clustering algorithm
+            },
+        };
+    }
+    /**
+     * Update claims index with new claim
+     */
+    async updateClaimsIndex(claim, sources) {
+        let index = {};
+        // Load existing index
+        try {
+            const data = await fs.readFile(this.claimsIndexPath, 'utf-8');
+            index = JSON.parse(data);
+        }
+        catch (error) {
+            // Index doesn't exist yet
+        }
+        // Update or create claim entry
+        if (index[claim]) {
+            // Merge sources, remove duplicates
+            const merged = [...new Set([...index[claim], ...sources])];
+            index[claim] = merged;
+        }
+        else {
+            index[claim] = sources;
+        }
+        // Write back
+        await fs.writeFile(this.claimsIndexPath, JSON.stringify(index, null, 2), 'utf-8');
+    }
+    /**
+     * Format citation in APA style
+     */
+    formatAPA(paper) {
+        const authors = this.formatAuthorsAPA(paper.authors.map((a) => a.name));
+        const year = paper.year || 'n.d.';
+        const title = paper.title;
+        const venue = paper.venue || '';
+        const doi = paper.doi ? `https://doi.org/${paper.doi}` : '';
+        let citation = `${authors} (${year}). ${title}.`;
+        if (venue) {
+            citation += ` ${venue}.`;
+        }
+        if (doi) {
+            citation += ` ${doi}`;
+        }
+        return citation;
+    }
+    /**
+     * Format citation in BibTeX style
+     */
+    formatBibTeX(paper) {
+        const id = this.generateBibTeXId(paper);
+        const authors = paper.authors.map((a) => a.name).join(' and ');
+        const year = paper.year || '';
+        const title = paper.title;
+        const venue = paper.venue || '';
+        const doi = paper.doi || '';
+        const entryType = paper.type === 'journal' ? 'article' : 'inproceedings';
+        let bibtex = `@${entryType}{${id},\n`;
+        bibtex += `  author = {${authors}},\n`;
+        bibtex += `  title = {${title}},\n`;
+        bibtex += `  year = {${year}},\n`;
+        if (venue) {
+            const field = entryType === 'article' ? 'journal' : 'booktitle';
+            bibtex += `  ${field} = {${venue}},\n`;
+        }
+        if (doi) {
+            bibtex += `  doi = {${doi}},\n`;
+        }
+        bibtex += `}`;
+        return bibtex;
+    }
+    /**
+     * Format citation in Chicago style
+     */
+    formatChicago(paper) {
+        const authors = this.formatAuthorsChicago(paper.authors.map((a) => a.name));
+        const year = paper.year || 'n.d.';
+        const title = `"${paper.title}"`;
+        const venue = paper.venue || '';
+        const doi = paper.doi ? `https://doi.org/${paper.doi}` : '';
+        let citation = `${authors}. ${year}. ${title}.`;
+        if (venue) {
+            citation += ` ${venue}.`;
+        }
+        if (doi) {
+            citation += ` ${doi}`;
+        }
+        return citation;
+    }
+    /**
+     * Format citation in MLA style
+     */
+    formatMLA(paper) {
+        const authors = this.formatAuthorsMLA(paper.authors.map((a) => a.name));
+        const title = `"${paper.title}"`;
+        const venue = paper.venue || '';
+        const year = paper.year || 'n.d.';
+        let citation = `${authors}. ${title}.`;
+        if (venue) {
+            citation += ` ${venue},`;
+        }
+        citation += ` ${year}.`;
+        return citation;
+    }
+    /**
+     * Format citation in IEEE style
+     */
+    formatIEEE(paper) {
+        const authors = this.formatAuthorsIEEE(paper.authors.map((a) => a.name));
+        const title = `"${paper.title}"`;
+        const venue = paper.venue ? `, ${paper.venue}` : '';
+        const year = paper.year || 'n.d.';
+        return `${authors}, ${title}${venue}, ${year}.`;
+    }
+    /**
+     * Format authors in APA style
+     */
+    formatAuthorsAPA(authors) {
+        if (authors.length === 0)
+            return 'Unknown';
+        if (authors.length === 1)
+            return authors[0];
+        if (authors.length === 2)
+            return `${authors[0]} & ${authors[1]}`;
+        const lastAuthor = authors[authors.length - 1];
+        const otherAuthors = authors.slice(0, -1).join(', ');
+        return `${otherAuthors}, & ${lastAuthor}`;
+    }
+    /**
+     * Format authors in Chicago style
+     */
+    formatAuthorsChicago(authors) {
+        if (authors.length === 0)
+            return 'Unknown';
+        if (authors.length === 1)
+            return this.reverseAuthorName(authors[0]);
+        if (authors.length === 2) {
+            return `${this.reverseAuthorName(authors[0])} and ${authors[1]}`;
+        }
+        const firstAuthor = this.reverseAuthorName(authors[0]);
+        const otherAuthors = authors.slice(1).join(', ');
+        return `${firstAuthor}, ${otherAuthors}`;
+    }
+    /**
+     * Format authors in MLA style
+     */
+    formatAuthorsMLA(authors) {
+        if (authors.length === 0)
+            return 'Unknown';
+        if (authors.length === 1)
+            return this.reverseAuthorName(authors[0]);
+        if (authors.length === 2) {
+            return `${this.reverseAuthorName(authors[0])}, and ${authors[1]}`;
+        }
+        const firstAuthor = this.reverseAuthorName(authors[0]);
+        return `${firstAuthor}, et al.`;
+    }
+    /**
+     * Format authors in IEEE style
+     */
+    formatAuthorsIEEE(authors) {
+        if (authors.length === 0)
+            return 'Unknown';
+        const initials = authors.map((name) => {
+            const parts = name.split(' ');
+            if (parts.length === 1)
+                return name;
+            const lastName = parts[parts.length - 1];
+            const firstInitials = parts
+                .slice(0, -1)
+                .map((p) => p.charAt(0) + '.')
+                .join(' ');
+            return `${firstInitials} ${lastName}`;
+        });
+        if (initials.length === 1)
+            return initials[0];
+        if (initials.length === 2)
+            return `${initials[0]} and ${initials[1]}`;
+        const lastAuthor = initials[initials.length - 1];
+        const otherAuthors = initials.slice(0, -1).join(', ');
+        return `${otherAuthors}, and ${lastAuthor}`;
+    }
+    /**
+     * Reverse author name (First Last -> Last, First)
+     */
+    reverseAuthorName(name) {
+        const parts = name.split(' ');
+        if (parts.length === 1)
+            return name;
+        const lastName = parts[parts.length - 1];
+        const firstName = parts.slice(0, -1).join(' ');
+        return `${lastName}, ${firstName}`;
+    }
+    /**
+     * Generate BibTeX citation ID
+     */
+    generateBibTeXId(paper) {
+        const author = paper.authors.length > 0
+            ? paper.authors[0].name.split(' ').pop()?.toLowerCase()
+            : 'unknown';
+        const year = paper.year || 'unknown';
+        const titleWord = paper.title
+            .toLowerCase()
+            .replace(/[^\w\s]/g, '')
+            .split(/\s+/)[0];
+        return `${author}${year}${titleWord}`;
+    }
+}
+//# sourceMappingURL=citation.js.map

package/dist/src/research/services/discovery.js

@@ -0,0 +1,243 @@
+/**
+ * Discovery service for unified research paper search
+ *
+ * @module research/services/discovery
+ */
+import { SemanticScholarClient } from '../clients/semantic-scholar.js';
+import { CrossRefClient } from '../clients/crossref.js';
+import { ArxivClient } from '../clients/arxiv.js';
+import { CacheManager } from '../cache/manager.js';
+/**
+ * Discovery service for unified search across API clients
+ */
+export class DiscoveryService {
+    semanticScholar;
+    crossref;
+    arxiv;
+    cache;
+    constructor(config = {}) {
+        this.semanticScholar = config.semanticScholar || new SemanticScholarClient();
+        this.crossref = config.crossref || new CrossRefClient();
+        this.arxiv = config.arxiv || new ArxivClient();
+        this.cache = config.cache || new CacheManager();
+    }
+    /**
+     * Search across all configured API clients
+     */
+    async search(query, options = {}) {
+        const { limit = 10, offset = 0, useCache = true, minYear, maxYear, relevanceThreshold = 0.0, deduplicate = true, } = options;
+        // Check cache
+        if (useCache) {
+            const cacheKey = this.cache.generateKey('discovery:search', {
+                query,
+                limit,
+                offset,
+                minYear,
+                maxYear,
+            });
+            const cached = await this.cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        // Search all APIs in parallel
+        const [ssResults, crResults, arxivResults] = await Promise.allSettled([
+            this.searchSemanticScholar(query, limit, offset),
+            this.searchCrossRef(query, limit, offset),
+            this.searchArxiv(query, limit, offset),
+        ]);
+        // Collect successful results
+        const allPapers = [];
+        if (ssResults.status === 'fulfilled') {
+            allPapers.push(...ssResults.value);
+        }
+        if (crResults.status === 'fulfilled') {
+            allPapers.push(...crResults.value);
+        }
+        if (arxivResults.status === 'fulfilled') {
+            allPapers.push(...arxivResults.value);
+        }
+        // Filter by year range
+        let filtered = allPapers;
+        if (minYear !== undefined) {
+            filtered = filtered.filter((p) => p.year >= minYear);
+        }
+        if (maxYear !== undefined) {
+            filtered = filtered.filter((p) => p.year <= maxYear);
+        }
+        // Deduplicate by DOI/arXiv ID/title
+        if (deduplicate) {
+            filtered = this.deduplicatePapers(filtered);
+        }
+        // Rank by relevance
+        const ranked = this.rankByRelevance(filtered, query);
+        // Filter by relevance threshold
+        const thresholded = ranked.filter((p) => this.calculateRelevance(p, query) >= relevanceThreshold);
+        // Apply limit
+        const results = thresholded.slice(0, limit);
+        // Cache results
+        if (useCache) {
+            const cacheKey = this.cache.generateKey('discovery:search', {
+                query,
+                limit,
+                offset,
+                minYear,
+                maxYear,
+            });
+            await this.cache.set(cacheKey, results, 'semantic-scholar');
+        }
+        return results;
+    }
+    /**
+     * Analyze gaps in research corpus
+     */
+    async analyzeGaps(_corpusRefIds) {
+        // For now, return a basic report structure
+        // In a full implementation, this would analyze corpus metadata
+        return {
+            underrepresentedTopics: [],
+            yearGaps: [],
+            sourceTypeDistribution: {},
+            recommendations: [
+                'Corpus gap analysis requires corpus metadata',
+                'Consider adding more recent publications',
+                'Balance source types (journal vs conference vs preprint)',
+            ],
+        };
+    }
+    /**
+     * Follow citation network starting from a paper
+     */
+    async followCitations(paperId, depth = 1) {
+        const results = [];
+        const visited = new Set();
+        await this.followCitationsRecursive(paperId, depth, visited, results);
+        return results;
+    }
+    /**
+     * Search Semantic Scholar
+     */
+    async searchSemanticScholar(query, limit, offset) {
+        try {
+            const result = await this.semanticScholar.search(query, {
+                limit,
+                offset,
+            });
+            return result.papers;
+        }
+        catch (error) {
+            console.warn('Semantic Scholar search failed:', error);
+            return [];
+        }
+    }
+    /**
+     * Search CrossRef
+     */
+    async searchCrossRef(query, limit, offset) {
+        try {
+            const result = await this.crossref.search(query, { limit, offset });
+            return result.papers;
+        }
+        catch (error) {
+            console.warn('CrossRef search failed:', error);
+            return [];
+        }
+    }
+    /**
+     * Search arXiv
+     */
+    async searchArxiv(query, limit, offset) {
+        try {
+            const result = await this.arxiv.search(query, { limit, offset });
+            return result.papers;
+        }
+        catch (error) {
+            console.warn('arXiv search failed:', error);
+            return [];
+        }
+    }
+    /**
+     * Deduplicate papers by DOI, arXiv ID, or title similarity
+     */
+    deduplicatePapers(papers) {
+        const seen = new Map();
+        for (const paper of papers) {
+            // Use DOI as primary key
+            if (paper.doi) {
+                const key = `doi:${paper.doi.toLowerCase()}`;
+                if (!seen.has(key)) {
+                    seen.set(key, paper);
+                }
+                continue;
+            }
+            // Use arXiv ID as secondary key
+            if (paper.arxivId) {
+                const key = `arxiv:${paper.arxivId.toLowerCase()}`;
+                if (!seen.has(key)) {
+                    seen.set(key, paper);
+                }
+                continue;
+            }
+            // Use normalized title as fallback
+            const normalizedTitle = paper.title
+                .toLowerCase()
+                .replace(/[^\w\s]/g, '')
+                .replace(/\s+/g, ' ')
+                .trim();
+            const key = `title:${normalizedTitle}`;
+            if (!seen.has(key)) {
+                seen.set(key, paper);
+            }
+        }
+        return Array.from(seen.values());
+    }
+    /**
+     * Rank papers by relevance to query
+     */
+    rankByRelevance(papers, query) {
+        const scored = papers.map((paper) => ({
+            paper,
+            relevance: this.calculateRelevance(paper, query),
+        }));
+        scored.sort((a, b) => b.relevance - a.relevance);
+        return scored.map((s) => s.paper);
+    }
+    /**
+     * Calculate relevance score (0-1) for a paper
+     */
+    calculateRelevance(paper, query) {
+        const queryLower = query.toLowerCase();
+        const queryTerms = queryLower.split(/\s+/);
+        let score = 0;
+        // Title match (weight: 0.5)
+        const titleLower = paper.title.toLowerCase();
+        const titleMatches = queryTerms.filter((term) => titleLower.includes(term)).length;
+        score += (titleMatches / queryTerms.length) * 0.5;
+        // Abstract match (weight: 0.3)
+        if (paper.abstract) {
+            const abstractLower = paper.abstract.toLowerCase();
+            const abstractMatches = queryTerms.filter((term) => abstractLower.includes(term)).length;
+            score += (abstractMatches / queryTerms.length) * 0.3;
+        }
+        // Citation count bonus (weight: 0.2)
+        if (paper.citationCount) {
+            // Normalize citation count (log scale)
+            const citationScore = Math.log10(paper.citationCount + 1) / 3; // Max ~3 for 1000 citations
+            score += Math.min(citationScore, 1.0) * 0.2;
+        }
+        return Math.min(score, 1.0);
+    }
+    /**
+     * Recursively follow citations
+     */
+    async followCitationsRecursive(paperId, remainingDepth, visited, _results) {
+        if (remainingDepth === 0 || visited.has(paperId)) {
+            return;
+        }
+        visited.add(paperId);
+        // For now, just stub - full implementation would query Semantic Scholar
+        // citation graph API endpoint
+        // This would require additional API calls to get references/citations
+    }
+}
+//# sourceMappingURL=discovery.js.map