110 lines
3.5 KiB
JavaScript
110 lines
3.5 KiB
JavaScript
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const {
|
|
createInstallTargetAdapter,
|
|
createManagedOperation,
|
|
isForeignPlatformPath,
|
|
} = require('./helpers');
|
|
|
|
function readJsonObject(filePath, label) {
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
|
} catch (error) {
|
|
throw new Error(`Failed to parse ${label} at ${filePath}: ${error.message}`);
|
|
}
|
|
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
throw new Error(`Invalid ${label} at ${filePath}: expected a JSON object`);
|
|
}
|
|
|
|
return parsed;
|
|
}
|
|
|
|
function createMcpMergeOperation(moduleId, repoRoot, targetRoot) {
|
|
if (!repoRoot) {
|
|
throw new Error('repoRoot is required to plan Kimi MCP configuration');
|
|
}
|
|
|
|
const sourceRelativePath = '.mcp.json';
|
|
const sourcePath = path.join(repoRoot, sourceRelativePath);
|
|
if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
|
|
return null;
|
|
}
|
|
|
|
return createManagedOperation({
|
|
kind: 'merge-json',
|
|
moduleId,
|
|
sourceRelativePath,
|
|
destinationPath: path.join(targetRoot, 'mcp.json'),
|
|
strategy: 'merge-json',
|
|
scaffoldOnly: false,
|
|
mergePayload: readJsonObject(sourcePath, sourceRelativePath),
|
|
});
|
|
}
|
|
|
|
module.exports = createInstallTargetAdapter({
|
|
id: 'kimi-project',
|
|
target: 'kimi',
|
|
kind: 'project',
|
|
rootSegments: ['.kimi-code'],
|
|
installStatePathSegments: ['ecc-install-state.json'],
|
|
nativeRootRelativePath: '.kimi-code',
|
|
planOperations(input, adapter) {
|
|
const modules = Array.isArray(input.modules)
|
|
? input.modules
|
|
: (input.module ? [input.module] : []);
|
|
const planningInput = {
|
|
repoRoot: input.repoRoot,
|
|
projectRoot: input.projectRoot,
|
|
homeDir: input.homeDir,
|
|
};
|
|
const targetRoot = adapter.resolveRoot(planningInput);
|
|
|
|
return modules.flatMap(module => {
|
|
const paths = Array.isArray(module.paths) ? module.paths : [];
|
|
|
|
return paths
|
|
.filter(sourceRelativePath => !isForeignPlatformPath(sourceRelativePath, adapter.target))
|
|
.flatMap(sourceRelativePath => {
|
|
if (sourceRelativePath === '.kimi') {
|
|
// The repository's compatibility documentation still lives in
|
|
// .kimi/. Sync its children into the current native root without
|
|
// creating that obsolete directory in the destination project.
|
|
return [createManagedOperation({
|
|
moduleId: module.id,
|
|
sourceRelativePath,
|
|
destinationPath: targetRoot,
|
|
strategy: 'sync-root-children',
|
|
})];
|
|
}
|
|
|
|
if (sourceRelativePath === '.agents') {
|
|
const skillsSourcePath = path.join(input.repoRoot || '', '.agents', 'skills');
|
|
if (!input.repoRoot || !fs.existsSync(skillsSourcePath)) {
|
|
return [];
|
|
}
|
|
|
|
return [createManagedOperation({
|
|
moduleId: module.id,
|
|
sourceRelativePath: '.agents/skills',
|
|
destinationPath: path.join(targetRoot, 'skills'),
|
|
strategy: 'preserve-relative-path',
|
|
})];
|
|
}
|
|
|
|
if (sourceRelativePath === 'mcp-configs') {
|
|
const mcpMergeOperation = createMcpMergeOperation(module.id, input.repoRoot, targetRoot);
|
|
return [
|
|
adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput),
|
|
...(mcpMergeOperation ? [mcpMergeOperation] : []),
|
|
];
|
|
}
|
|
|
|
return [adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput)];
|
|
});
|
|
});
|
|
},
|
|
});
|