forge-workflow 0.0.1 → 0.0.3

package/lib/dep-guard/behavior-detector.js

@@ -0,0 +1,98 @@
+const STOP_WORDS = new Set([
+	'the', 'a', 'an', 'and', 'or', 'is', 'in', 'to', 'for', 'of', 'with', 'on',
+	'at', 'by', 'from', 'add', 'fix', 'update', 'implement', 'create', 'remove',
+	'delete', 'make', 'use', 'get', 'set', 'run', 'test', 'check', 'this', 'that',
+	'it', 'be', 'as', 'not', 'no', 'but', 'if', 'do', 'we', 'they', 'are', 'was',
+	'were', 'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should',
+	'may', 'can', 'each', 'every', 'both', 'also', 'into', 'than', 'then', 'when',
+	'where', 'which', 'what', 'how', 'why', 'who', 'its', 'new', 'first', 'last',
+	'same', 'other',
+]);
+
+const BEHAVIOR_TERMS = new Set([
+	'approval', 'behavior', 'confidence', 'default', 'manual', 'ordering',
+	'output', 'policy', 'review', 'rules', 'rule', 'threshold', 'validation',
+	'workflow', 'state',
+]);
+const STRONG_SIGNAL_TERMS = new Set([
+	'approval',
+	'confidence',
+	'manual',
+	'policy',
+	'review',
+	'rule',
+	'rules',
+	'threshold',
+]);
+
+function tokenize(text) {
+	return Array.from(new Set(
+		text
+			.toLowerCase()
+			.split(/[^a-z0-9]+/)
+			.filter((term) => term.length >= 3 && !STOP_WORDS.has(term)),
+	));
+}
+
+function scoreBehavioralDependencies(normalizedInput) {
+	const taskText = normalizedInput.taskContext.tasks
+		.map((task) => task.whatToImplement)
+		.join(' ');
+	const taskTerms = tokenize(taskText).filter((term) => BEHAVIOR_TERMS.has(term));
+
+	if (taskTerms.length === 0) {
+		return {
+			score: 0,
+			findings: [],
+			evidence: [],
+			uncertain: false,
+		};
+	}
+
+	const findings = [];
+	const evidence = [];
+
+	for (const issue of normalizedInput.openIssues) {
+		const issueText = [issue.title, issue.description, issue.notes].filter(Boolean).join(' ');
+		const issueTerms = new Set(tokenize(issueText));
+		const sharedTerms = taskTerms.filter((term) => issueTerms.has(term));
+
+		if (sharedTerms.length < 2) {
+			continue;
+		}
+
+		const strongSignalCount = sharedTerms.filter((term) => STRONG_SIGNAL_TERMS.has(term)).length;
+		const isUncertain = strongSignalCount < 2 || sharedTerms.length < 3;
+		const signal = sharedTerms.some((term) => ['rule', 'rules', 'policy', 'approval'].includes(term))
+			? 'rule-change-overlap'
+			: 'behavior-change-overlap';
+		const issueEvidence = sharedTerms.map((term) => ({
+			type: 'behavior',
+			targetIssueId: issue.id,
+			sharedTerms: sharedTerms,
+			term,
+			scoreContribution: 1,
+		}));
+
+		findings.push({
+			sourceIssueId: normalizedInput.currentIssue.id,
+			targetIssueId: issue.id,
+			score: sharedTerms.length,
+			behavioralSignal: signal,
+			uncertain: isUncertain,
+			evidence: issueEvidence,
+		});
+		evidence.push(...issueEvidence);
+	}
+
+	return {
+		score: findings.reduce((total, finding) => total + finding.score, 0),
+		findings,
+		evidence,
+		uncertain: findings.some((finding) => finding.uncertain),
+	};
+}
+
+module.exports = {
+	scoreBehavioralDependencies,
+};

package/lib/dep-guard/contract-detector.js

@@ -0,0 +1,162 @@
+const { detectContractType, extractTaskContracts } = require('./task-parser.js');
+const { normalizeRepoPath } = require('./path-utils.js');
+
+function isIdentifier(name) {
+	return typeof name === 'string' && /^[A-Za-z_]\w*$/.test(name);
+}
+
+function isCommandContractName(name) {
+	return typeof name === 'string' && /^[A-Za-z_][\w-]*$/.test(name);
+}
+
+function parseContractToken(token) {
+	if (typeof token !== 'string') {
+		return null;
+	}
+
+	const trimmed = token.trim();
+	if (!trimmed) {
+		return null;
+	}
+
+	let annotation = '';
+	let contractTarget = trimmed;
+	const openParenIndex = trimmed.lastIndexOf('(');
+	if (openParenIndex !== -1 && trimmed.endsWith(')')) {
+		annotation = trimmed.slice(openParenIndex + 1, -1);
+		contractTarget = trimmed.slice(0, openParenIndex);
+	}
+
+	const separatorIndex = contractTarget.lastIndexOf(':');
+	if (separatorIndex <= 0 || separatorIndex === contractTarget.length - 1) {
+		return null;
+	}
+
+	const file = normalizeRepoPath(contractTarget.slice(0, separatorIndex));
+	const symbol = contractTarget.slice(separatorIndex + 1);
+	const contractType = detectContractType(symbol, annotation);
+
+	const validSymbol = contractType === 'command-contract'
+		? isCommandContractName(symbol)
+		: isIdentifier(symbol);
+	if (!validSymbol) {
+		return null;
+	}
+
+	return {
+		contract: `${file}:${symbol}(${contractType})`,
+		file,
+		symbol,
+		contractType,
+	};
+}
+
+function parseStoredContractsFromNotes(notes = '') {
+	if (!notes || typeof notes !== 'string') {
+		return [];
+	}
+
+	const contractLines = notes
+		.split(/\r?\n/)
+		.filter((line) => line.startsWith('contracts@') && line.includes(': '));
+	if (contractLines.length === 0) {
+		return [];
+	}
+
+	contractLines.sort((left, right) => left.localeCompare(right));
+	const latestLine = contractLines.at(-1);
+	const latestPayload = latestLine.slice(latestLine.indexOf(': ') + 2);
+
+	return latestPayload
+		.split(/\s+/)
+		.map((token) => token.trim())
+		.filter(Boolean);
+}
+
+function mergeEvidence(evidence) {
+	const seen = new Set();
+	return evidence.filter((item) => {
+		const key = `${item.contract}:${item.storedContract}:${item.targetIssueId}`;
+		if (seen.has(key)) {
+			return false;
+		}
+		seen.add(key);
+		return true;
+	});
+}
+
+function scoreContractDependencies(normalizedInput) {
+	const currentContracts = extractTaskContracts(normalizedInput.taskContext, {
+		repositoryRoot: normalizedInput.repositoryRoot,
+	})
+		.map(parseContractToken)
+		.filter(Boolean);
+
+	if (currentContracts.length === 0) {
+		return {
+			score: 0,
+			findings: [],
+			evidence: [],
+		};
+	}
+
+	const findings = [];
+	const evidence = [];
+
+	for (const issue of normalizedInput.openIssues) {
+		const issueContracts = Array.from(new Set([
+			...issue.contracts,
+			...parseStoredContractsFromNotes(issue.notes),
+		]))
+			.map(parseContractToken)
+			.filter(Boolean);
+
+		const issueEvidence = [];
+		for (const currentContract of currentContracts) {
+			for (const storedContract of issueContracts) {
+				if (
+					currentContract.file !== storedContract.file
+					|| currentContract.symbol !== storedContract.symbol
+					|| currentContract.contractType !== storedContract.contractType
+				) {
+					continue;
+				}
+
+				issueEvidence.push({
+					type: 'contract',
+					sourceIssueId: normalizedInput.currentIssue.id,
+					targetIssueId: issue.id,
+					contract: currentContract.contract,
+					storedContract: storedContract.contract,
+					symbol: currentContract.symbol,
+					contractType: currentContract.contractType,
+					scoreContribution: 1,
+				});
+			}
+		}
+
+		if (issueEvidence.length === 0) {
+			continue;
+		}
+
+		const mergedEvidence = mergeEvidence(issueEvidence);
+		findings.push({
+			sourceIssueId: normalizedInput.currentIssue.id,
+			targetIssueId: issue.id,
+			score: mergedEvidence.length,
+			evidence: mergedEvidence,
+		});
+		evidence.push(...mergedEvidence);
+	}
+
+	return {
+		score: findings.reduce((total, finding) => total + finding.score, 0),
+		findings,
+		evidence: mergeEvidence(evidence),
+	};
+}
+
+module.exports = {
+	parseStoredContractsFromNotes,
+	scoreContractDependencies,
+};