forge-workflow 0.0.4 → 0.0.6

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

@@ -1,98 +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,
-};
+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

@@ -1,162 +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,
-};
+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,
+};