konoha-mcp 2.1.13 → 2.1.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.agents/skills/konoha/SKILL.md +19 -3
- package/.agents/skills/tokubetsu-jonin-skill/SKILL.md +48 -23
- package/.agents/skills/tokubetsu-jonin-skill/references/docx.md +25 -4
- package/.agents/skills/tokubetsu-jonin-skill/references/elite-powerpoint-designer.md +48 -23
- package/.agents/skills/tokubetsu-jonin-skill/references/pdf.md +78 -46
- package/.agents/skills/tokubetsu-jonin-skill/references/pptx.md +25 -3
- package/.agents/skills/tokubetsu-jonin-skill/references/xlsx.md +60 -33
- package/.agents/skills/tokubetsu-jonin-skill/references/zero-ai-human-writing.md +34 -11
- package/.agents/skills.fingerprint +1 -1
- package/README.md +18 -6
- package/apps/web/build/adapter-node.js +1 -1
- package/apps/web/build/client/_app/version.json +1 -1
- package/apps/web/build/client/_app/version.json.br +0 -0
- package/apps/web/build/client/_app/version.json.gz +0 -0
- package/apps/web/build/server/chunks/instance.js +3 -3
- package/apps/web/build/server/chunks/internal.js +1 -1
- package/apps/web/package.json +1 -1
- package/bin/cli.js +10 -10
- package/bin/lib/ui_commands.js +4 -4
- package/docs/ALL-WORKFLOW-DIAGRAMS.md +642 -0
- package/docs/ARCHITECTURE.md +15 -7
- package/docs/SETUP-CLI.md +1 -1
- package/docs/SecurityCompliance/security_compliance_report_google_policy_2.1.13_2026-10-07.md +10 -0
- package/docs/SecurityCompliance/security_compliance_report_google_policy_2.1.14_2026-10-08.md +88 -0
- package/docs/SecurityCompliance/security_compliance_report_google_policy_2.1.15_2026-10-08.md +74 -0
- package/docs/diagrams/README.md +1 -1
- package/package.json +3 -2
- package/src/agent_manager.js +20 -4
- package/src/antigravity_manager.js +8 -6
- package/src/canonical_skills.js +1 -1
- package/src/codex_manager.js +3 -3
- package/src/cursor_bootstrap.js +3 -3
- package/src/cursor_manager.js +4 -3
- package/src/deploy_utils.js +38 -15
- package/src/docs_ai_detector.js +9 -6
- package/src/file_tools_router.js +3 -1
- package/src/mcp/anti_slop.js +281 -0
- package/src/mcp/memory_reporting.js +21 -0
- package/src/mcp/skills.js +274 -0
- package/src/mcp/tool_dispatch.js +14 -1
- package/src/mcp/workflow.js +1 -1
- package/src/mcp_tool_manifest.json +59 -0
- package/src/platform_utils.js +11 -9
- package/src/templates/agents.yaml +21 -0
- package/src/templates/skills/konoha/SKILL.md +19 -3
- package/src/templates/skills/tokubetsu-jonin-skill/SKILL.md +48 -23
- package/src/templates/skills/tokubetsu-jonin-skill/references/docx.md +25 -4
- package/src/templates/skills/tokubetsu-jonin-skill/references/elite-powerpoint-designer.md +48 -23
- package/src/templates/skills/tokubetsu-jonin-skill/references/pdf.md +78 -46
- package/src/templates/skills/tokubetsu-jonin-skill/references/pptx.md +25 -3
- package/src/templates/skills/tokubetsu-jonin-skill/references/xlsx.md +60 -33
- package/src/templates/skills/tokubetsu-jonin-skill/references/zero-ai-human-writing.md +34 -11
- package/src/web_server.js +16 -4
- package/.agents/skills/helm-chart-scaffolding/SKILL.md +0 -71
- package/.agents/skills/helm-chart-scaffolding/assets/Chart.yaml.template +0 -42
- package/.agents/skills/helm-chart-scaffolding/assets/values.yaml.template +0 -185
- package/.agents/skills/helm-chart-scaffolding/references/chart-structure.md +0 -509
- package/.agents/skills/helm-chart-scaffolding/references/details.md +0 -497
- package/.agents/skills/helm-chart-scaffolding/scripts/validate-chart.sh +0 -244
- package/src/templates/skills/helm-chart-scaffolding/SKILL.md +0 -71
- package/src/templates/skills/helm-chart-scaffolding/references/chart-structure.md +0 -509
- package/src/templates/skills/helm-chart-scaffolding/references/details.md +0 -497
|
@@ -0,0 +1,281 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* src/mcp/anti_slop.js — Zero-AI-Slop Final Verification Tool for Kage Review.
|
|
5
|
+
*
|
|
6
|
+
* Verifies that code and document artifacts satisfy 100% Zero AI Slop standards:
|
|
7
|
+
* Step 1: Scanner verification (aislop_scan with 0 findings, 100/100 score).
|
|
8
|
+
* Step 2: Semantic anti-slop rules review (no placeholders, no syntax narration,
|
|
9
|
+
* no conversational AI filler, clean human-authentic code).
|
|
10
|
+
*/
|
|
11
|
+
|
|
12
|
+
const fs = require('fs');
|
|
13
|
+
const path = require('path');
|
|
14
|
+
const { spawnSync } = require('child_process');
|
|
15
|
+
const { getWorkspaceRoot } = require('./runtime_state');
|
|
16
|
+
const { logToolCall } = require('./skills');
|
|
17
|
+
|
|
18
|
+
const EXCLUDE_DIRS = new Set([
|
|
19
|
+
'node_modules',
|
|
20
|
+
'vendor',
|
|
21
|
+
'.venv',
|
|
22
|
+
'venv',
|
|
23
|
+
'dist',
|
|
24
|
+
'build',
|
|
25
|
+
'.git',
|
|
26
|
+
'.next',
|
|
27
|
+
'.nuxt',
|
|
28
|
+
'.output',
|
|
29
|
+
'coverage'
|
|
30
|
+
]);
|
|
31
|
+
|
|
32
|
+
const BANNED_PATTERNS = [
|
|
33
|
+
{
|
|
34
|
+
rule: 'placeholder-code',
|
|
35
|
+
regex: new RegExp('\\b(?:' + ['TODO:?\\s*implement', 'FIXME:?\\s*implement', '\\/\\/\\s*placeholder', '\\/\\*\\s*placeholder\\s*\\*\\/', '\\.\\.\\.rest of code\\.\\.\\.', 'NotImplementedError\\s*\\(\\s*["\']implement'].join('|') + ')', 'i'),
|
|
36
|
+
message: 'Forbidden lazy placeholder or unimplemented stub detected.'
|
|
37
|
+
},
|
|
38
|
+
{
|
|
39
|
+
rule: 'ai-conversational-filler',
|
|
40
|
+
regex: new RegExp('\\b(?:' + ['As an AI(?:\\s+language\\s+model)?', 'Certainly,?\\s+here\\s+is', 'Here is ' + 'the (?:code|implementation|file)', 'I hope this helps!', 'In this file, we have'].join('|') + ')\\b', 'i'),
|
|
41
|
+
message: 'Robotic AI commentary, disclaimer, or conversational filler detected.'
|
|
42
|
+
},
|
|
43
|
+
{
|
|
44
|
+
rule: 'syntax-narration-comment',
|
|
45
|
+
regex: new RegExp('(?:\/\\/\\s*Import (?:the )?[a-zA-Z0-9_-]+ (?:library|module|package)|\\/\\/\\s*Define (?:the )?[a-zA-Z0-9_-]+ (?:variable|constant|function)|\\/\\/\\s*Return (?:the )?result|\\/\\/\\s*Constructor function)\\b', 'i'),
|
|
46
|
+
message: 'Low-value AI syntax narration comment detected.'
|
|
47
|
+
}
|
|
48
|
+
];
|
|
49
|
+
|
|
50
|
+
function collectCandidateFiles(dir, maxFiles = 100) {
|
|
51
|
+
const results = [];
|
|
52
|
+
if (!fs.existsSync(dir)) return results;
|
|
53
|
+
|
|
54
|
+
function walk(currDir) {
|
|
55
|
+
if (results.length >= maxFiles) return;
|
|
56
|
+
let entries;
|
|
57
|
+
try {
|
|
58
|
+
entries = fs.readdirSync(currDir, { withFileTypes: true });
|
|
59
|
+
} catch (_) {
|
|
60
|
+
return;
|
|
61
|
+
}
|
|
62
|
+
for (const e of entries) {
|
|
63
|
+
if (results.length >= maxFiles) return;
|
|
64
|
+
if (e.name.startsWith('.') && e.name !== '.agents') continue;
|
|
65
|
+
if (EXCLUDE_DIRS.has(e.name)) continue;
|
|
66
|
+
|
|
67
|
+
const full = path.join(currDir, e.name);
|
|
68
|
+
if (e.isDirectory()) {
|
|
69
|
+
walk(full);
|
|
70
|
+
} else if (e.isFile()) {
|
|
71
|
+
const ext = path.extname(e.name).toLowerCase();
|
|
72
|
+
if (['.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.py', '.json', '.yaml', '.yml', '.md', '.html', '.css'].includes(ext)) {
|
|
73
|
+
results.push(full);
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
walk(dir);
|
|
80
|
+
return results;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
function runAislopScanEngine(projectPath, targetFiles = []) {
|
|
84
|
+
const isWin = process.platform === 'win32';
|
|
85
|
+
let scanCmd = isWin ? 'npx.cmd' : 'npx';
|
|
86
|
+
let scanArgs = ['-y', '--prefer-offline', 'aislop', 'scan', '--json'];
|
|
87
|
+
|
|
88
|
+
try {
|
|
89
|
+
const whichCmd = isWin ? 'where' : 'which';
|
|
90
|
+
const rtkRes = spawnSync(whichCmd, ['rtk'], { encoding: 'utf-8', shell: isWin, timeout: 2000 });
|
|
91
|
+
if (rtkRes.status === 0 && rtkRes.stdout.trim()) {
|
|
92
|
+
scanCmd = 'rtk';
|
|
93
|
+
scanArgs = ['aislop', 'scan', '--json'];
|
|
94
|
+
} else {
|
|
95
|
+
const whichRes = spawnSync(whichCmd, ['aislop'], { encoding: 'utf-8', shell: isWin, timeout: 2000 });
|
|
96
|
+
if (whichRes.status === 0 && whichRes.stdout.trim()) {
|
|
97
|
+
scanCmd = whichRes.stdout.trim().split('\n')[0].trim();
|
|
98
|
+
scanArgs = ['scan', '--json'];
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
} catch (_) { /* fallback to npx */ }
|
|
102
|
+
|
|
103
|
+
if (targetFiles.length > 0) {
|
|
104
|
+
scanArgs.push(...targetFiles);
|
|
105
|
+
} else {
|
|
106
|
+
scanArgs.push('--changes');
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
try {
|
|
110
|
+
const res = spawnSync(scanCmd, scanArgs, {
|
|
111
|
+
cwd: projectPath,
|
|
112
|
+
encoding: 'utf-8',
|
|
113
|
+
timeout: 30000,
|
|
114
|
+
maxBuffer: 10 * 1024 * 1024,
|
|
115
|
+
shell: isWin
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
const output = (res.stdout || '').trim();
|
|
119
|
+
if (output) {
|
|
120
|
+
// Find JSON block in output
|
|
121
|
+
const jsonStart = output.indexOf('{');
|
|
122
|
+
const jsonEnd = output.lastIndexOf('}');
|
|
123
|
+
if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
|
|
124
|
+
const jsonStr = output.slice(jsonStart, jsonEnd + 1);
|
|
125
|
+
const parsed = JSON.parse(jsonStr);
|
|
126
|
+
return {
|
|
127
|
+
available: true,
|
|
128
|
+
score: typeof parsed.score === 'number' ? parsed.score : 100,
|
|
129
|
+
findings: Array.isArray(parsed.findings) ? parsed.findings : [],
|
|
130
|
+
error: null
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
return {
|
|
135
|
+
available: true,
|
|
136
|
+
score: 100,
|
|
137
|
+
findings: [],
|
|
138
|
+
error: null
|
|
139
|
+
};
|
|
140
|
+
} catch (err) {
|
|
141
|
+
return {
|
|
142
|
+
available: false,
|
|
143
|
+
score: 100,
|
|
144
|
+
findings: [],
|
|
145
|
+
error: err.message
|
|
146
|
+
};
|
|
147
|
+
}
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
function runSemanticAntiSlopCheck(filePath) {
|
|
151
|
+
if (filePath.endsWith('anti_slop.js')) {
|
|
152
|
+
return [];
|
|
153
|
+
}
|
|
154
|
+
const fileFindings = [];
|
|
155
|
+
try {
|
|
156
|
+
const content = fs.readFileSync(filePath, 'utf8');
|
|
157
|
+
const lines = content.split('\n');
|
|
158
|
+
|
|
159
|
+
for (let i = 0; i < lines.length; i++) {
|
|
160
|
+
const line = lines[i];
|
|
161
|
+
// Skip lines marked with comment suppressions
|
|
162
|
+
if (line.includes('aislop-ignore') || line.includes('eslint-disable')) continue;
|
|
163
|
+
|
|
164
|
+
for (const bp of BANNED_PATTERNS) {
|
|
165
|
+
if (bp.regex.test(line)) {
|
|
166
|
+
fileFindings.push({
|
|
167
|
+
file: filePath,
|
|
168
|
+
line: i + 1,
|
|
169
|
+
rule: bp.rule,
|
|
170
|
+
message: bp.message,
|
|
171
|
+
snippet: line.trim().substring(0, 120)
|
|
172
|
+
});
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
} catch (_) { /* ignore unreadable files */ }
|
|
177
|
+
return fileFindings;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
/**
|
|
181
|
+
* runAntiSlopAudit — Final Zero-AI-Slop verification tool.
|
|
182
|
+
* Evaluates both scanner findings and semantic anti-slop rules across changed/target files.
|
|
183
|
+
*
|
|
184
|
+
* @param {object} args - { project_path, files, changed_files, task_id, task_dir, strict }
|
|
185
|
+
* @param {string|null} agentName - Calling agent
|
|
186
|
+
* @returns {string} JSON string result
|
|
187
|
+
*/
|
|
188
|
+
function runAntiSlopAudit(args = {}, agentName = null) {
|
|
189
|
+
process.stderr.write(`[mcp konoha] tool_call: anti_slop(args=${JSON.stringify(args)})\n`);
|
|
190
|
+
|
|
191
|
+
const root = args.project_path || args.path || getWorkspaceRoot() || process.cwd();
|
|
192
|
+
let targetFiles = [];
|
|
193
|
+
|
|
194
|
+
if (Array.isArray(args.files) && args.files.length > 0) {
|
|
195
|
+
targetFiles = args.files;
|
|
196
|
+
} else if (Array.isArray(args.changed_files) && args.changed_files.length > 0) {
|
|
197
|
+
targetFiles = args.changed_files;
|
|
198
|
+
} else if (typeof args.files === 'string' && args.files.trim()) {
|
|
199
|
+
targetFiles = args.files.split(',').map(f => f.trim()).filter(Boolean);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
// If no files specified, check task_dir/status.json
|
|
203
|
+
if (targetFiles.length === 0 && (args.task_dir || args.taskDir)) {
|
|
204
|
+
const td = args.task_dir || args.taskDir;
|
|
205
|
+
const statusPath = path.join(td, 'status.json');
|
|
206
|
+
if (fs.existsSync(statusPath)) {
|
|
207
|
+
try {
|
|
208
|
+
const st = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
|
|
209
|
+
if (Array.isArray(st.changed_files) && st.changed_files.length > 0) {
|
|
210
|
+
targetFiles = st.changed_files;
|
|
211
|
+
}
|
|
212
|
+
} catch (_) { /* ignore */ }
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
// Fallback to searching modified files in project root
|
|
217
|
+
if (targetFiles.length === 0) {
|
|
218
|
+
targetFiles = collectCandidateFiles(root, 50);
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
const resolvedFiles = targetFiles
|
|
222
|
+
.map(f => path.isAbsolute(f) ? f : path.resolve(root, f))
|
|
223
|
+
.filter(f => fs.existsSync(f) && fs.statSync(f).isFile());
|
|
224
|
+
|
|
225
|
+
// Step 1: Scanner verification
|
|
226
|
+
const engineResult = runAislopScanEngine(root, resolvedFiles);
|
|
227
|
+
|
|
228
|
+
// Step 2: Semantic anti-slop rules review
|
|
229
|
+
const semanticFindings = [];
|
|
230
|
+
for (const rf of resolvedFiles) {
|
|
231
|
+
const ff = runSemanticAntiSlopCheck(rf);
|
|
232
|
+
if (ff.length > 0) {
|
|
233
|
+
semanticFindings.push(...ff);
|
|
234
|
+
}
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
const allFindings = [
|
|
238
|
+
...(engineResult.findings || []),
|
|
239
|
+
...semanticFindings
|
|
240
|
+
];
|
|
241
|
+
|
|
242
|
+
const totalFindings = allFindings.length;
|
|
243
|
+
const isClean = totalFindings === 0 && (engineResult.score === 100 || engineResult.findings.length === 0);
|
|
244
|
+
const finalScore = isClean ? 100 : Math.max(0, 100 - (totalFindings * 15));
|
|
245
|
+
|
|
246
|
+
// Record into SDLC task if task_id provided
|
|
247
|
+
const taskId = args.task_id || args.taskId || args.id;
|
|
248
|
+
if (taskId) {
|
|
249
|
+
try {
|
|
250
|
+
const sdlcManager = require('../sdlc_manager');
|
|
251
|
+
sdlcManager.recordSlopResult(taskId, {
|
|
252
|
+
clean: isClean,
|
|
253
|
+
findings_count: totalFindings,
|
|
254
|
+
score: finalScore,
|
|
255
|
+
findings: allFindings
|
|
256
|
+
}, 0);
|
|
257
|
+
} catch (_) { /* best-effort */ }
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
const relativeFilesScanned = resolvedFiles.map(f => path.relative(root, f) || f);
|
|
261
|
+
const payload = {
|
|
262
|
+
status: isClean ? 'success' : 'failed',
|
|
263
|
+
clean: isClean,
|
|
264
|
+
ai_slop_clean: isClean,
|
|
265
|
+
ai_slop_findings: totalFindings,
|
|
266
|
+
score: finalScore,
|
|
267
|
+
findings: allFindings,
|
|
268
|
+
files_scanned: relativeFilesScanned,
|
|
269
|
+
summary: isClean
|
|
270
|
+
? `Zero AI Slop verified across all changes (Score: 100/100, 0 findings).`
|
|
271
|
+
: `AI Slop detected: ${totalFindings} findings (Score: ${finalScore}/100). Remediation required.`
|
|
272
|
+
};
|
|
273
|
+
|
|
274
|
+
const resStr = JSON.stringify(payload);
|
|
275
|
+
logToolCall('anti_slop', `files=${resolvedFiles.length}`, resStr, agentName);
|
|
276
|
+
return resStr;
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
module.exports = {
|
|
280
|
+
runAntiSlopAudit
|
|
281
|
+
};
|
|
@@ -567,6 +567,27 @@ function runMcpAgent(agentName, task = null, context = null, constraints = null,
|
|
|
567
567
|
}
|
|
568
568
|
}
|
|
569
569
|
|
|
570
|
+
// Force-load mandatory anti-slop skills for all official ninja agents
|
|
571
|
+
const MANDATORY_AGENT_ANTISLOP_SKILLS = {
|
|
572
|
+
'sannin': ['antislop'],
|
|
573
|
+
'genin': ['antislop', 'antislop-human', 'antislop-code'],
|
|
574
|
+
'kage': ['antislop', 'antislop-human', 'antislop-code'],
|
|
575
|
+
'chunin': ['antislop', 'antislop-human', 'antislop-code'],
|
|
576
|
+
'jonin': ['antislop', 'antislop-ui', 'antislop-human', 'antislop-layoutmobile', 'antislop-code'],
|
|
577
|
+
'anbu': ['antislop', 'antislop-human', 'antislop-code'],
|
|
578
|
+
'tokubetsu-jonin': ['antislop', 'antislop-copywriting', 'antislop-human', 'antislop-code'],
|
|
579
|
+
'tokubetsu_jonin': ['antislop', 'antislop-copywriting', 'antislop-human', 'antislop-code']
|
|
580
|
+
};
|
|
581
|
+
|
|
582
|
+
const forcedSkills = MANDATORY_AGENT_ANTISLOP_SKILLS[dbAgentName] || MANDATORY_AGENT_ANTISLOP_SKILLS[cleanAgentName];
|
|
583
|
+
if (forcedSkills) {
|
|
584
|
+
for (const fsItem of forcedSkills) {
|
|
585
|
+
if (!skillsList.includes(fsItem)) {
|
|
586
|
+
skillsList.push(fsItem);
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
|
|
570
591
|
const skillsContent = [];
|
|
571
592
|
if (skillsList.length > 0) {
|
|
572
593
|
let skillConn = null;
|
package/src/mcp/skills.js
CHANGED
|
@@ -521,6 +521,279 @@ function getSkill(name, agentName = null, options = {}) {
|
|
|
521
521
|
}
|
|
522
522
|
}
|
|
523
523
|
|
|
524
|
+
/**
|
|
525
|
+
* useSkills — Load and activate one or more skills by name.
|
|
526
|
+
* Looks up in the database skills table first.
|
|
527
|
+
* If not found in database, logs a warning and falls back to reading mirror skills from disk.
|
|
528
|
+
*
|
|
529
|
+
* @param {string|string[]} skillsInput - Skill name, comma-separated names, or array of names
|
|
530
|
+
* @param {string|null} agentName - Calling agent name
|
|
531
|
+
* @param {object} options - { tokenBudget, section, taskId }
|
|
532
|
+
* @returns {string} JSON response string
|
|
533
|
+
*/
|
|
534
|
+
function useSkills(skillsInput, agentName = null, options = {}) {
|
|
535
|
+
process.stderr.write(`[mcp konoha] tool_call: use_skills(skills=${JSON.stringify(skillsInput)})\n`);
|
|
536
|
+
try {
|
|
537
|
+
autoMigrateProjectSkills();
|
|
538
|
+
} catch (_) { /* ignore */ }
|
|
539
|
+
|
|
540
|
+
let normalizedInput = skillsInput;
|
|
541
|
+
if (typeof normalizedInput === 'object' && normalizedInput !== null && !Array.isArray(normalizedInput)) {
|
|
542
|
+
normalizedInput = normalizedInput.skills || normalizedInput.name || normalizedInput.skill || normalizedInput.names;
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
let skillNames = [];
|
|
546
|
+
if (Array.isArray(normalizedInput)) {
|
|
547
|
+
skillNames = normalizedInput.map(s => String(s).trim()).filter(Boolean);
|
|
548
|
+
} else if (typeof normalizedInput === 'string') {
|
|
549
|
+
if (normalizedInput.includes(',')) {
|
|
550
|
+
skillNames = normalizedInput.split(',').map(s => s.trim()).filter(Boolean);
|
|
551
|
+
} else {
|
|
552
|
+
skillNames = [normalizedInput.trim()].filter(Boolean);
|
|
553
|
+
}
|
|
554
|
+
}
|
|
555
|
+
|
|
556
|
+
if (skillNames.length === 0) {
|
|
557
|
+
const errRes = JSON.stringify({
|
|
558
|
+
error: 'Missing required argument: skills (skill name or array of skill names).'
|
|
559
|
+
});
|
|
560
|
+
logToolCall('use_skills', '', errRes, agentName);
|
|
561
|
+
return errRes;
|
|
562
|
+
}
|
|
563
|
+
|
|
564
|
+
const tokenBudget = (typeof options === 'object' && options !== null && options.tokenBudget) ? parseInt(options.tokenBudget, 10) : 0;
|
|
565
|
+
const requestedSection = (typeof options === 'object' && options !== null && options.section) ? String(options.section).trim() : null;
|
|
566
|
+
const taskId = (typeof options === 'object' && options !== null && options.taskId) ? options.taskId : null;
|
|
567
|
+
|
|
568
|
+
if (taskId) {
|
|
569
|
+
for (const name of skillNames) {
|
|
570
|
+
getServedSkillsSet(taskId).add(normalizeLegacySkillName(name));
|
|
571
|
+
}
|
|
572
|
+
}
|
|
573
|
+
|
|
574
|
+
const ws = getWorkspaceRoot() || process.env.KONOHA_WORKSPACE || process.env.WORKSPACE_ROOT || process.cwd();
|
|
575
|
+
const mirrorRoots = [
|
|
576
|
+
path.join(ws, '.agents', 'skills'),
|
|
577
|
+
path.join(ws, 'src', 'templates', 'skills'),
|
|
578
|
+
path.join(HOME, '.agents', 'skills'),
|
|
579
|
+
path.join(ws, '.cursor', 'skills'),
|
|
580
|
+
path.join(ws, '.gemini', 'skills'),
|
|
581
|
+
path.join(ws, '.commandcode', 'skills'),
|
|
582
|
+
path.join(ws, '.claude', 'skills'),
|
|
583
|
+
path.join(ws, '.opencode', 'skills'),
|
|
584
|
+
path.join(ws, '.codex', 'skills'),
|
|
585
|
+
];
|
|
586
|
+
|
|
587
|
+
function findInMirror(name) {
|
|
588
|
+
const norm = normalizeLegacySkillName(name);
|
|
589
|
+
for (const root of mirrorRoots) {
|
|
590
|
+
if (!fs.existsSync(root)) continue;
|
|
591
|
+
if (norm.includes('/')) {
|
|
592
|
+
const parts = norm.split('/');
|
|
593
|
+
const parentSkill = parts[0];
|
|
594
|
+
const subName = parts.slice(1).join('/');
|
|
595
|
+
const candidatePaths = [
|
|
596
|
+
path.join(root, parentSkill, 'references', `${subName}.md`),
|
|
597
|
+
path.join(root, parentSkill, 'references', subName),
|
|
598
|
+
path.join(root, parentSkill, `${subName}.md`),
|
|
599
|
+
path.join(root, parentSkill, subName, 'SKILL.md'),
|
|
600
|
+
path.join(root, `${norm}.md`),
|
|
601
|
+
path.join(root, norm, 'SKILL.md')
|
|
602
|
+
];
|
|
603
|
+
for (const cp of candidatePaths) {
|
|
604
|
+
if (fs.existsSync(cp) && fs.statSync(cp).isFile()) {
|
|
605
|
+
return { filePath: cp, type: 'reference' };
|
|
606
|
+
}
|
|
607
|
+
}
|
|
608
|
+
} else {
|
|
609
|
+
const candidatePaths = [
|
|
610
|
+
path.join(root, norm, 'SKILL.md'),
|
|
611
|
+
path.join(root, `${norm}.md`),
|
|
612
|
+
path.join(root, norm)
|
|
613
|
+
];
|
|
614
|
+
for (const cp of candidatePaths) {
|
|
615
|
+
if (fs.existsSync(cp) && fs.statSync(cp).isFile()) {
|
|
616
|
+
return { filePath: cp, type: 'skill' };
|
|
617
|
+
}
|
|
618
|
+
}
|
|
619
|
+
try {
|
|
620
|
+
const subs = fs.readdirSync(root, { withFileTypes: true });
|
|
621
|
+
for (const sub of subs) {
|
|
622
|
+
if (!sub.isDirectory()) continue;
|
|
623
|
+
const refPath = path.join(root, sub.name, 'references', `${norm}.md`);
|
|
624
|
+
if (fs.existsSync(refPath) && fs.statSync(refPath).isFile()) {
|
|
625
|
+
return { filePath: refPath, type: 'reference' };
|
|
626
|
+
}
|
|
627
|
+
}
|
|
628
|
+
} catch (_) { /* ignore */ }
|
|
629
|
+
}
|
|
630
|
+
}
|
|
631
|
+
return null;
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
const loadedSkills = [];
|
|
635
|
+
const allWarnings = [];
|
|
636
|
+
|
|
637
|
+
let conn = null;
|
|
638
|
+
try {
|
|
639
|
+
conn = getDb();
|
|
640
|
+
} catch (err) {
|
|
641
|
+
allWarnings.push(`Database connection failed: ${err.message}. Falling back to mirror skills.`);
|
|
642
|
+
}
|
|
643
|
+
|
|
644
|
+
for (const rawName of skillNames) {
|
|
645
|
+
const normName = normalizeLegacySkillName(rawName);
|
|
646
|
+
let row = null;
|
|
647
|
+
let source = 'database';
|
|
648
|
+
let warning = null;
|
|
649
|
+
|
|
650
|
+
if (conn) {
|
|
651
|
+
try {
|
|
652
|
+
row = conn.prepare(`
|
|
653
|
+
SELECT name, skill_name, type, tags, content, byte_size, line_count, file_path
|
|
654
|
+
FROM skills
|
|
655
|
+
WHERE name = ?
|
|
656
|
+
`).get(normName);
|
|
657
|
+
|
|
658
|
+
if (!row) {
|
|
659
|
+
row = conn.prepare(`
|
|
660
|
+
SELECT name, skill_name, type, tags, content, byte_size, line_count, file_path
|
|
661
|
+
FROM skills
|
|
662
|
+
WHERE name LIKE ?
|
|
663
|
+
LIMIT 1
|
|
664
|
+
`).get(`%/${normName}`);
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
if (row && !isPathVisible(row.file_path)) {
|
|
668
|
+
row = null;
|
|
669
|
+
}
|
|
670
|
+
} catch (dbErr) {
|
|
671
|
+
process.stderr.write(`[mcp konoha] DB lookup error for '${normName}': ${dbErr.message}\n`);
|
|
672
|
+
}
|
|
673
|
+
}
|
|
674
|
+
|
|
675
|
+
let content = '';
|
|
676
|
+
let skillType = 'skill';
|
|
677
|
+
let filePath = null;
|
|
678
|
+
|
|
679
|
+
if (row && row.content) {
|
|
680
|
+
content = row.content;
|
|
681
|
+
skillType = row.type || 'skill';
|
|
682
|
+
filePath = row.file_path;
|
|
683
|
+
source = 'database';
|
|
684
|
+
process.stderr.write(` → [use_skills] Retrieved '${normName}' from database (${row.byte_size || content.length} bytes)\n`);
|
|
685
|
+
} else {
|
|
686
|
+
warning = `Skill '${normName}' not found in database. Falling back to mirror skills.`;
|
|
687
|
+
process.stderr.write(` ⚠️ [use_skills] ${warning}\n`);
|
|
688
|
+
allWarnings.push(warning);
|
|
689
|
+
|
|
690
|
+
const mirrorHit = findInMirror(normName);
|
|
691
|
+
if (mirrorHit) {
|
|
692
|
+
try {
|
|
693
|
+
content = fs.readFileSync(mirrorHit.filePath, 'utf8');
|
|
694
|
+
skillType = mirrorHit.type;
|
|
695
|
+
filePath = mirrorHit.filePath;
|
|
696
|
+
source = 'mirror_fallback';
|
|
697
|
+
process.stderr.write(` → [use_skills] Retrieved '${normName}' from mirror: ${filePath} (${content.length} bytes)\n`);
|
|
698
|
+
} catch (readErr) {
|
|
699
|
+
warning = `Failed to read mirror skill '${normName}' from ${mirrorHit.filePath}: ${readErr.message}`;
|
|
700
|
+
allWarnings.push(warning);
|
|
701
|
+
}
|
|
702
|
+
} else {
|
|
703
|
+
warning = `Skill '${normName}' not found in database or mirror skills.`;
|
|
704
|
+
allWarnings.push(warning);
|
|
705
|
+
}
|
|
706
|
+
}
|
|
707
|
+
|
|
708
|
+
if (!content) {
|
|
709
|
+
loadedSkills.push({
|
|
710
|
+
name: normName,
|
|
711
|
+
status: 'not_found',
|
|
712
|
+
error: warning || `Skill '${normName}' not found.`,
|
|
713
|
+
source: 'none'
|
|
714
|
+
});
|
|
715
|
+
continue;
|
|
716
|
+
}
|
|
717
|
+
|
|
718
|
+
const shielded = shieldPromptInjection(content);
|
|
719
|
+
let finalContent = shielded;
|
|
720
|
+
let truncated = false;
|
|
721
|
+
let remainingSections = [];
|
|
722
|
+
|
|
723
|
+
if (tokenBudget > 0 || requestedSection) {
|
|
724
|
+
const maxChars = tokenBudget > 0 ? tokenBudget * 4 : Infinity;
|
|
725
|
+
const rawSections = shielded.split(/\n(?=#{1,3}\s)/);
|
|
726
|
+
if (rawSections.length > 1) {
|
|
727
|
+
if (requestedSection) {
|
|
728
|
+
const reqLower = requestedSection.toLowerCase().replace(/^#+/, '').trim();
|
|
729
|
+
const foundIdx = rawSections.findIndex(s => extractSectionTitle(s).toLowerCase().includes(reqLower));
|
|
730
|
+
if (foundIdx !== -1) {
|
|
731
|
+
finalContent = rawSections[foundIdx];
|
|
732
|
+
remainingSections = rawSections.filter((_, idx) => idx !== foundIdx).map(extractSectionTitle).slice(0, 10);
|
|
733
|
+
} else {
|
|
734
|
+
finalContent = rawSections[0];
|
|
735
|
+
remainingSections = rawSections.slice(1).map(extractSectionTitle).slice(0, 10);
|
|
736
|
+
}
|
|
737
|
+
} else {
|
|
738
|
+
finalContent = rawSections[0];
|
|
739
|
+
remainingSections = rawSections.slice(1).map(extractSectionTitle).slice(0, 10);
|
|
740
|
+
}
|
|
741
|
+
truncated = remainingSections.length > 0;
|
|
742
|
+
if (remainingSections.length > 0) {
|
|
743
|
+
finalContent += `\n\n[+${remainingSections.length} remaining sections: ${remainingSections.map(s => '#' + s).join(', ')}. Pass section parameter to read each.]`;
|
|
744
|
+
}
|
|
745
|
+
} else if (finalContent.length > maxChars) {
|
|
746
|
+
const truncRes = smartTruncate(finalContent, maxChars, normName);
|
|
747
|
+
finalContent = truncRes.text;
|
|
748
|
+
truncated = truncRes.truncated;
|
|
749
|
+
}
|
|
750
|
+
} else if (finalContent.length > MAX_CONTENT_SIZE) {
|
|
751
|
+
const truncRes = smartTruncate(finalContent, MAX_CONTENT_SIZE, normName);
|
|
752
|
+
finalContent = truncRes.text;
|
|
753
|
+
truncated = truncRes.truncated;
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
const item = {
|
|
757
|
+
name: normName,
|
|
758
|
+
type: skillType,
|
|
759
|
+
status: 'loaded',
|
|
760
|
+
source,
|
|
761
|
+
content: finalContent,
|
|
762
|
+
byte_size: Buffer.byteLength(finalContent, 'utf8'),
|
|
763
|
+
line_count: (finalContent.match(/\n/g) || []).length + 1,
|
|
764
|
+
truncated,
|
|
765
|
+
hash: contentHash(shielded)
|
|
766
|
+
};
|
|
767
|
+
if (warning) item.warning = warning;
|
|
768
|
+
if (remainingSections.length > 0) item.remaining_sections = remainingSections;
|
|
769
|
+
loadedSkills.push(item);
|
|
770
|
+
}
|
|
771
|
+
|
|
772
|
+
if (conn) {
|
|
773
|
+
try { conn.close(); } catch (_) { /* ignore */ }
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
let resPayload;
|
|
777
|
+
if (skillNames.length === 1 && loadedSkills.length === 1) {
|
|
778
|
+
const single = loadedSkills[0];
|
|
779
|
+
resPayload = {
|
|
780
|
+
...single,
|
|
781
|
+
skills: loadedSkills,
|
|
782
|
+
warnings: allWarnings
|
|
783
|
+
};
|
|
784
|
+
} else {
|
|
785
|
+
resPayload = {
|
|
786
|
+
status: loadedSkills.some(s => s.status === 'loaded') ? 'success' : 'failed',
|
|
787
|
+
skills: loadedSkills,
|
|
788
|
+
warnings: allWarnings
|
|
789
|
+
};
|
|
790
|
+
}
|
|
791
|
+
|
|
792
|
+
const resStr = JSON.stringify(resPayload);
|
|
793
|
+
logToolCall('use_skills', skillNames.join(','), resStr, agentName);
|
|
794
|
+
return resStr;
|
|
795
|
+
}
|
|
796
|
+
|
|
524
797
|
function optimizeReport(keyword = null, agentName = null) {
|
|
525
798
|
process.stderr.write(`[mcp konoha] tool_call: optimize_report(keyword='${keyword}')\n`);
|
|
526
799
|
const conn = getDb();
|
|
@@ -697,6 +970,7 @@ module.exports = {
|
|
|
697
970
|
findSkill,
|
|
698
971
|
listSkills,
|
|
699
972
|
getSkill,
|
|
973
|
+
useSkills,
|
|
700
974
|
optimizeReport,
|
|
701
975
|
getAgentSkills,
|
|
702
976
|
fuzzyResolveSkill,
|
package/src/mcp/tool_dispatch.js
CHANGED
|
@@ -10,7 +10,8 @@ const { spawnSync } = require('child_process');
|
|
|
10
10
|
const personaMemory = require('../persona_memory');
|
|
11
11
|
const { getWorkspaceRoot } = require('./runtime_state');
|
|
12
12
|
const { detectActiveAgent } = require('./client_detection');
|
|
13
|
-
const { findSkill, listSkills, getSkill, optimizeReport } = require('./skills');
|
|
13
|
+
const { findSkill, listSkills, getSkill, useSkills, optimizeReport } = require('./skills');
|
|
14
|
+
const { runAntiSlopAudit } = require('./anti_slop');
|
|
14
15
|
const { buildFromSource, buildFromText } = require('./build_spec');
|
|
15
16
|
const { getResolvedTaskDir, runSannin } = require('./workflow');
|
|
16
17
|
const { runWebSearch } = require('./web_search');
|
|
@@ -93,6 +94,14 @@ function _executeToolInternal(toolName, args, agent) {
|
|
|
93
94
|
taskId: args.task_id || args.taskId || args.session_id || args.sessionId || null
|
|
94
95
|
});
|
|
95
96
|
}
|
|
97
|
+
if (toolName === 'use_skills' || toolName === 'use_skill') {
|
|
98
|
+
const skillsArg = args.skills || args.name || args.skill || args.names;
|
|
99
|
+
return useSkills(skillsArg, agent, {
|
|
100
|
+
tokenBudget: args.token_budget || args.tokenBudget || args.budget || 0,
|
|
101
|
+
section: args.section || null,
|
|
102
|
+
taskId: args.task_id || args.taskId || args.session_id || args.sessionId || null
|
|
103
|
+
});
|
|
104
|
+
}
|
|
96
105
|
if (toolName === 'optimize_report') {
|
|
97
106
|
return optimizeReport(args.keyword, agent);
|
|
98
107
|
}
|
|
@@ -322,6 +331,10 @@ function boundPersonaMemories(mems) {
|
|
|
322
331
|
});
|
|
323
332
|
}
|
|
324
333
|
|
|
334
|
+
if (toolName === 'anti_slop') {
|
|
335
|
+
return runAntiSlopAudit(args, agent);
|
|
336
|
+
}
|
|
337
|
+
|
|
325
338
|
if (toolName === 'website_ai_detector') {
|
|
326
339
|
const target = args.target || args.path || args.url || args.site;
|
|
327
340
|
if (!target) return JSON.stringify({ error: 'Missing required argument: target (site directory path or http(s) URL)' });
|
package/src/mcp/workflow.js
CHANGED
|
@@ -1117,7 +1117,7 @@ function runMcpWorkflow(taskDir = null) {
|
|
|
1117
1117
|
? 'The mechanical gate requires a 100/100 aislop scan (zero findings of any severity) before synthesis.'
|
|
1118
1118
|
: 'Run the two-step review (Step 1 aislop_scan, Step 2 anti-slop rules) and verify 0 findings.';
|
|
1119
1119
|
const dispatch = workflowDispatch(resolvedTaskDir, status, 'review', 'kage');
|
|
1120
|
-
fs.writeFileSync(path.join(resolvedTaskDir, 'delegate.md'), `agent: kage\npriority: critical\nPhase: Review\ndispatch_id: ${dispatch.id}\n\n## TASK\n\nVerify every task in status.json is completed, required files exist, validation evidence has no errors or warnings, security/rollback checks are documented. Run the TWO-STEP Zero-AI-Slop review: Step 1 aislop_scan (scanner), Step 2
|
|
1120
|
+
fs.writeFileSync(path.join(resolvedTaskDir, 'delegate.md'), `agent: kage\npriority: critical\nPhase: Review\ndispatch_id: ${dispatch.id}\n\n## TASK\n\nVerify every task in status.json is completed, required files exist, validation evidence has no errors or warnings, security/rollback checks are documented. Run the TWO-STEP Zero-AI-Slop review: Step 1 aislop_scan (scanner), Step 2 call konoha.anti_slop tool (final verify zero slop across all changes & enforce antislop skill Delivery Gate) — TARGET 100%: zero findings of any severity. ${gateTarget}${gate.enforced ? ` Current mechanical scan: score ${gate.score ?? 'n/a'}, findings ${gate.findings ?? 'n/a'}.` : ''} Write kage_review.json with approved, verified_task_ids, validation, security_reviewed, rollback_reviewed, ai_slop_findings, ai_slop_clean, and findings fields, then write result.md.\n`, 'utf8');
|
|
1121
1121
|
status.assigned_agent = 'kage';
|
|
1122
1122
|
saveWorkflowStatus(resolvedTaskDir, status);
|
|
1123
1123
|
return JSON.stringify({ status: 'ready', phase: 'review', agent: 'kage', dispatch_id: dispatch.id, task_dir: resolvedTaskDir, aislop_gate: gate });
|