@elvis1513/auto-coding-skill 3.0.0 → 3.0.1
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/README.md +111 -54
- package/cli/assets/agents/browser-debugger.toml +5 -7
- package/cli/assets/agents/docs-researcher.toml +3 -5
- package/cli/assets/agents/explorer.toml +5 -10
- package/cli/assets/agents/fixer.toml +19 -17
- package/cli/assets/agents/reviewer.toml +14 -10
- package/cli/assets/skill/SKILL.md +111 -49
- package/cli/assets/skill/data/contracts/orchestration-v1.schema.json +475 -0
- package/cli/assets/skill/data/templates/ENGINEERING.md +164 -82
- package/cli/assets/skill/data/templates/bridges/AGENTS.md +4 -4
- package/cli/assets/skill/data/templates/docs/tasks/closure-log.md +7 -6
- package/cli/assets/skill/data/templates/docs/tasks/taskbook.md +11 -4
- package/cli/assets/skill/scripts/ap.py +1000 -563
- package/cli/src/index.js +399 -51
- package/cli/tests/ap_concurrency_test.py +396 -75
- package/cli/tests/ap_profiles_test.py +242 -99
- package/cli/tests/index.test.js +409 -15
- package/package.json +3 -3
package/cli/src/index.js
CHANGED
|
@@ -2,6 +2,8 @@
|
|
|
2
2
|
import fs from "node:fs";
|
|
3
3
|
import path from "node:path";
|
|
4
4
|
import os from "node:os";
|
|
5
|
+
import crypto from "node:crypto";
|
|
6
|
+
import { execFileSync } from "node:child_process";
|
|
5
7
|
import { fileURLToPath } from "node:url";
|
|
6
8
|
|
|
7
9
|
function die(msg){
|
|
@@ -25,6 +27,7 @@ function parseArgs(argv){
|
|
|
25
27
|
dryRun: false,
|
|
26
28
|
json: false,
|
|
27
29
|
resetAgentModels: false,
|
|
30
|
+
components: "all",
|
|
28
31
|
projects: [],
|
|
29
32
|
provided: new Set(),
|
|
30
33
|
};
|
|
@@ -64,6 +67,11 @@ function parseArgs(argv){
|
|
|
64
67
|
args.resetAgentModels = true;
|
|
65
68
|
args.provided.add("resetAgentModels");
|
|
66
69
|
}
|
|
70
|
+
else if (a === "--components") {
|
|
71
|
+
args.components = takeValue(rest, i, a).trim().toLowerCase();
|
|
72
|
+
args.provided.add("components");
|
|
73
|
+
i += 1;
|
|
74
|
+
}
|
|
67
75
|
else if (a === "--force") {
|
|
68
76
|
args.force = true;
|
|
69
77
|
args.provided.add("force");
|
|
@@ -86,13 +94,14 @@ const ARG_FLAGS = {
|
|
|
86
94
|
dryRun: "--dry-run",
|
|
87
95
|
json: "--json",
|
|
88
96
|
resetAgentModels: "--reset-agent-models",
|
|
97
|
+
components: "--components",
|
|
89
98
|
projects: "--projects/positional project",
|
|
90
99
|
};
|
|
91
100
|
|
|
92
101
|
const COMMAND_ARGS = {
|
|
93
102
|
init: new Set(["ai", "mode", "dest", "force", "resetAgentModels"]),
|
|
94
103
|
status: new Set(["projects", "json"]),
|
|
95
|
-
sync: new Set(["projects", "dryRun", "json", "resetAgentModels"]),
|
|
104
|
+
sync: new Set(["projects", "dryRun", "json", "resetAgentModels", "components"]),
|
|
96
105
|
};
|
|
97
106
|
|
|
98
107
|
function validateCommandArgs(args){
|
|
@@ -102,6 +111,12 @@ function validateCommandArgs(args){
|
|
|
102
111
|
if (invalid.length) {
|
|
103
112
|
die(`${invalid.map(name => ARG_FLAGS[name] || name).join(", ")} not valid for '${args.cmd}'`);
|
|
104
113
|
}
|
|
114
|
+
if (args.cmd === "sync" && !["all", "skill"].includes(args.components)) {
|
|
115
|
+
die("--components must be 'all' or 'skill'");
|
|
116
|
+
}
|
|
117
|
+
if (args.cmd === "sync" && args.components === "skill" && args.resetAgentModels) {
|
|
118
|
+
die("--reset-agent-models cannot be used with --components skill");
|
|
119
|
+
}
|
|
105
120
|
}
|
|
106
121
|
|
|
107
122
|
function exists(p){ try { fs.accessSync(p); return true; } catch { return false; } }
|
|
@@ -364,19 +379,9 @@ function inferredGateCommands(project){
|
|
|
364
379
|
const parsed = JSON.parse(fs.readFileSync(pkg, "utf8"));
|
|
365
380
|
const scripts = parsed?.scripts;
|
|
366
381
|
if (!scripts || typeof scripts !== "object") return {};
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
? "npm run test:changed"
|
|
371
|
-
: "npm test";
|
|
372
|
-
inferred.gate_standard = typeof scripts["test:standard"] === "string" && scripts["test:standard"].trim()
|
|
373
|
-
? "npm run test:standard"
|
|
374
|
-
: "npm test";
|
|
375
|
-
}
|
|
376
|
-
if (typeof scripts["test:full"] === "string" && scripts["test:full"].trim()) {
|
|
377
|
-
inferred.gate_full = "npm run test:full";
|
|
378
|
-
}
|
|
379
|
-
return inferred;
|
|
382
|
+
return typeof scripts["test:changed"] === "string" && scripts["test:changed"].trim()
|
|
383
|
+
? { gate_changed: "npm run test:changed" }
|
|
384
|
+
: {};
|
|
380
385
|
} catch {
|
|
381
386
|
return {};
|
|
382
387
|
}
|
|
@@ -388,11 +393,179 @@ function renderEngineeringTemplate(templateText, project){
|
|
|
388
393
|
`project:\n name: ${JSON.stringify(path.basename(path.resolve(project)))}`,
|
|
389
394
|
);
|
|
390
395
|
for (const [key, gate] of Object.entries(inferredGateCommands(project))) {
|
|
391
|
-
rendered = rendered.replace(` ${key}: ""`, ` ${key}: ${JSON.stringify(gate)}`);
|
|
396
|
+
rendered = rendered.replace(` ${key}: "git diff --check"`, ` ${key}: ${JSON.stringify(gate)}`);
|
|
392
397
|
}
|
|
393
398
|
return rendered;
|
|
394
399
|
}
|
|
395
400
|
|
|
401
|
+
const MANAGED_WORKFLOW_START_TOKEN = "auto-coding-skill:managed-workflow:start";
|
|
402
|
+
const MANAGED_WORKFLOW_END_TOKEN = "auto-coding-skill:managed-workflow:end";
|
|
403
|
+
const MANAGED_WORKFLOW_START_RE = /<!--\s*auto-coding-skill:managed-workflow:start\s+version=([0-9]+\.[0-9]+\.[0-9]+)\s*-->/g;
|
|
404
|
+
const MANAGED_WORKFLOW_END_RE = /<!--\s*auto-coding-skill:managed-workflow:end\s*-->/g;
|
|
405
|
+
const KNOWN_OFFICIAL_LEGACY_BODY_HASHES = new Set([
|
|
406
|
+
// v2.2.0, v3.0.0, and origin/dev@c532734 respectively. Frontmatter is excluded.
|
|
407
|
+
"d1306cc626e8baf8c83c953b760fd771066de2bf125168eca3a7b7d6ff2b87a2",
|
|
408
|
+
"305931c6edef770033a4f1970b00e5fb1c1728351856a173dbfa497daf563021",
|
|
409
|
+
"198d675361337bc272880154266b3eb1f50e3f82f3c6ab04b2e559cd18d8c7b4",
|
|
410
|
+
]);
|
|
411
|
+
|
|
412
|
+
function tokenCount(text, token){
|
|
413
|
+
return text.split(token).length - 1;
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
function inspectManagedWorkflow(text){
|
|
417
|
+
const rawStarts = tokenCount(text, MANAGED_WORKFLOW_START_TOKEN);
|
|
418
|
+
const rawEnds = tokenCount(text, MANAGED_WORKFLOW_END_TOKEN);
|
|
419
|
+
if (rawStarts === 0 && rawEnds === 0) return { state: "absent" };
|
|
420
|
+
|
|
421
|
+
const starts = [...text.matchAll(MANAGED_WORKFLOW_START_RE)];
|
|
422
|
+
const ends = [...text.matchAll(MANAGED_WORKFLOW_END_RE)];
|
|
423
|
+
if (rawStarts !== starts.length || rawEnds !== ends.length) {
|
|
424
|
+
return { state: "invalid", detail: "managed workflow marker is malformed" };
|
|
425
|
+
}
|
|
426
|
+
if (starts.length !== 1 || ends.length !== 1) {
|
|
427
|
+
return { state: "invalid", detail: "managed workflow markers must contain exactly one start/end pair" };
|
|
428
|
+
}
|
|
429
|
+
const start = starts[0].index;
|
|
430
|
+
const end = ends[0].index;
|
|
431
|
+
if (start >= end) {
|
|
432
|
+
return { state: "invalid", detail: "managed workflow markers are out of order or nested" };
|
|
433
|
+
}
|
|
434
|
+
const endExclusive = end + ends[0][0].length;
|
|
435
|
+
return {
|
|
436
|
+
state: "present",
|
|
437
|
+
version: starts[0][1],
|
|
438
|
+
start,
|
|
439
|
+
endExclusive,
|
|
440
|
+
block: text.slice(start, endExclusive),
|
|
441
|
+
};
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
function splitEngineeringDocument(text){
|
|
445
|
+
const frontmatter = text.match(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/);
|
|
446
|
+
const bodyStart = frontmatter ? frontmatter[0].length : 0;
|
|
447
|
+
return { frontmatter: text.slice(0, bodyStart), body: text.slice(bodyStart) };
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
function engineeringBodyHash(body){
|
|
451
|
+
return crypto.createHash("sha256").update(body.replace(/\r\n/g, "\n")).digest("hex");
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
function insertManagedWorkflow(text, block){
|
|
455
|
+
const { frontmatter } = splitEngineeringDocument(text);
|
|
456
|
+
const bodyStart = frontmatter.length;
|
|
457
|
+
const body = text.slice(bodyStart);
|
|
458
|
+
const heading = /^# Engineering Workflow[^\r\n]*(?:\r?\n|$)/m.exec(body);
|
|
459
|
+
const insertion = heading ? bodyStart + heading.index + heading[0].length : bodyStart;
|
|
460
|
+
const before = text.slice(0, insertion);
|
|
461
|
+
const after = text.slice(insertion);
|
|
462
|
+
return `${before}${block}${after}`;
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
function planEngineeringSync(project, assetSkill){
|
|
466
|
+
const root = path.resolve(project);
|
|
467
|
+
const engineering = path.join(root, "docs", "ENGINEERING.md");
|
|
468
|
+
const templatePath = path.join(assetSkill, "data", "templates", "ENGINEERING.md");
|
|
469
|
+
const renderedTemplate = renderEngineeringTemplate(fs.readFileSync(templatePath, "utf8"), root);
|
|
470
|
+
const templateRegion = inspectManagedWorkflow(renderedTemplate);
|
|
471
|
+
if (templateRegion.state !== "present") {
|
|
472
|
+
return { state: "invalid", detail: `packaged ENGINEERING template: ${templateRegion.detail || "managed workflow markers are missing"}` };
|
|
473
|
+
}
|
|
474
|
+
if (!exists(engineering)) {
|
|
475
|
+
return { state: "missing", version: templateRegion.version, output: renderedTemplate, engineering };
|
|
476
|
+
}
|
|
477
|
+
|
|
478
|
+
const current = fs.readFileSync(engineering, "utf8");
|
|
479
|
+
const currentRegion = inspectManagedWorkflow(current);
|
|
480
|
+
if (currentRegion.state === "invalid") return { ...currentRegion, engineering };
|
|
481
|
+
if (currentRegion.state === "absent") {
|
|
482
|
+
const currentParts = splitEngineeringDocument(current);
|
|
483
|
+
const templateParts = splitEngineeringDocument(renderedTemplate);
|
|
484
|
+
const legacyHash = engineeringBodyHash(currentParts.body);
|
|
485
|
+
if (KNOWN_OFFICIAL_LEGACY_BODY_HASHES.has(legacyHash)) {
|
|
486
|
+
return {
|
|
487
|
+
state: "legacy-official",
|
|
488
|
+
version: templateRegion.version,
|
|
489
|
+
previousBodyHash: legacyHash,
|
|
490
|
+
output: `${currentParts.frontmatter}${templateParts.body}`,
|
|
491
|
+
engineering,
|
|
492
|
+
};
|
|
493
|
+
}
|
|
494
|
+
return {
|
|
495
|
+
state: "legacy-custom",
|
|
496
|
+
version: templateRegion.version,
|
|
497
|
+
preservedCustom: true,
|
|
498
|
+
output: insertManagedWorkflow(current, templateRegion.block),
|
|
499
|
+
engineering,
|
|
500
|
+
};
|
|
501
|
+
}
|
|
502
|
+
if (currentRegion.block === templateRegion.block) {
|
|
503
|
+
return { state: "current", version: templateRegion.version, output: current, engineering };
|
|
504
|
+
}
|
|
505
|
+
return {
|
|
506
|
+
state: "stale",
|
|
507
|
+
version: templateRegion.version,
|
|
508
|
+
previousVersion: currentRegion.version,
|
|
509
|
+
output: `${current.slice(0, currentRegion.start)}${templateRegion.block}${current.slice(currentRegion.endExclusive)}`,
|
|
510
|
+
engineering,
|
|
511
|
+
};
|
|
512
|
+
}
|
|
513
|
+
|
|
514
|
+
function publicEngineeringPlan(plan){
|
|
515
|
+
return {
|
|
516
|
+
state: plan.state,
|
|
517
|
+
version: plan.version || "unknown",
|
|
518
|
+
...(plan.previousVersion ? { previousVersion: plan.previousVersion } : {}),
|
|
519
|
+
...(plan.previousBodyHash ? { previousBodyHash: plan.previousBodyHash } : {}),
|
|
520
|
+
...(plan.preservedCustom ? { preservedCustom: true } : {}),
|
|
521
|
+
...(plan.detail ? { detail: plan.detail } : {}),
|
|
522
|
+
};
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
function registeredLegacyTasks(project){
|
|
526
|
+
const root = path.resolve(project);
|
|
527
|
+
let commonDir;
|
|
528
|
+
try {
|
|
529
|
+
const raw = execFileSync("git", ["-C", root, "rev-parse", "--git-common-dir"], {
|
|
530
|
+
encoding: "utf8",
|
|
531
|
+
stdio: ["ignore", "pipe", "ignore"],
|
|
532
|
+
}).trim();
|
|
533
|
+
commonDir = path.resolve(root, raw);
|
|
534
|
+
} catch {
|
|
535
|
+
return [];
|
|
536
|
+
}
|
|
537
|
+
const tasksDir = path.join(commonDir, "auto-coding-skill", "tasks");
|
|
538
|
+
if (!exists(tasksDir)) return [];
|
|
539
|
+
const legacy = [];
|
|
540
|
+
for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
|
|
541
|
+
if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
|
|
542
|
+
const manifestPath = path.join(tasksDir, entry.name);
|
|
543
|
+
let manifest;
|
|
544
|
+
try {
|
|
545
|
+
manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
|
|
546
|
+
} catch {
|
|
547
|
+
legacy.push({ project: root, manifest: entry.name, schema: "invalid" });
|
|
548
|
+
continue;
|
|
549
|
+
}
|
|
550
|
+
const schema = Number(manifest?.schema ?? 0);
|
|
551
|
+
if (!Number.isFinite(schema) || schema < 2) {
|
|
552
|
+
legacy.push({ project: root, manifest: entry.name, schema: Number.isFinite(schema) ? schema : "invalid" });
|
|
553
|
+
}
|
|
554
|
+
}
|
|
555
|
+
return legacy;
|
|
556
|
+
}
|
|
557
|
+
|
|
558
|
+
function assertNoLegacyRegisteredTasks(projects){
|
|
559
|
+
const legacy = projects.flatMap(project => registeredLegacyTasks(project));
|
|
560
|
+
if (!legacy.length) return;
|
|
561
|
+
const locations = legacy.map(item => `${item.project}:${item.manifest}(schema=${item.schema})`).join(", ");
|
|
562
|
+
die(
|
|
563
|
+
"refusing the entire sync batch because registered auto-coding tasks use schema < 2: "
|
|
564
|
+
+ `${locations}\nFinish, integrate, and clean these tasks with the currently installed 3.0.0 runtime before upgrading. `
|
|
565
|
+
+ "sync will not infer or auto-claim owned paths for legacy tasks.",
|
|
566
|
+
);
|
|
567
|
+
}
|
|
568
|
+
|
|
396
569
|
function readPackageVersion(){
|
|
397
570
|
const here = path.dirname(fileURLToPath(import.meta.url));
|
|
398
571
|
const pkgPath = path.resolve(here, "..", "..", "package.json");
|
|
@@ -408,14 +581,14 @@ function extractFrontmatter(text){
|
|
|
408
581
|
return match ? match[1] : "";
|
|
409
582
|
}
|
|
410
583
|
|
|
411
|
-
function
|
|
584
|
+
function frontmatterPathState(text, keyPath){
|
|
412
585
|
const frontmatter = extractFrontmatter(text);
|
|
413
|
-
if (!frontmatter) return false;
|
|
586
|
+
if (!frontmatter) return { present: false, value: "" };
|
|
414
587
|
|
|
415
588
|
const stack = [];
|
|
416
589
|
for (const rawLine of frontmatter.split(/\r?\n/)) {
|
|
417
590
|
if (!rawLine.trim() || rawLine.trim().startsWith("#")) continue;
|
|
418
|
-
const match = rawLine.match(/^(\s*)(["']?[^:"']+["']?)\s
|
|
591
|
+
const match = rawLine.match(/^(\s*)(["']?[^:"']+["']?)\s*:(.*)$/);
|
|
419
592
|
if (!match) continue;
|
|
420
593
|
|
|
421
594
|
const indent = match[1].replace(/\t/g, " ").length;
|
|
@@ -423,11 +596,97 @@ function frontmatterHasPath(text, keyPath){
|
|
|
423
596
|
while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
|
|
424
597
|
const currentPath = [...stack.map(item => item.key), key];
|
|
425
598
|
if (currentPath.length === keyPath.length && currentPath.every((part, index) => part === keyPath[index])) {
|
|
426
|
-
return true;
|
|
599
|
+
return { present: true, value: match[3].trim() };
|
|
427
600
|
}
|
|
428
601
|
stack.push({ indent, key });
|
|
429
602
|
}
|
|
430
|
-
return false;
|
|
603
|
+
return { present: false, value: "" };
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
function frontmatterValueIsFilled(raw){
|
|
607
|
+
const source = String(raw || "");
|
|
608
|
+
let quote = "";
|
|
609
|
+
let escaped = false;
|
|
610
|
+
let commentAt = -1;
|
|
611
|
+
for (let index = 0; index < source.length; index += 1) {
|
|
612
|
+
const char = source[index];
|
|
613
|
+
if (quote === '"' && char === "\\" && !escaped) {
|
|
614
|
+
escaped = true;
|
|
615
|
+
continue;
|
|
616
|
+
}
|
|
617
|
+
if ((char === '"' || char === "'") && !escaped) {
|
|
618
|
+
quote = quote === char ? "" : (quote || char);
|
|
619
|
+
} else if (char === "#" && !quote && (index === 0 || /\s/.test(source[index - 1]))) {
|
|
620
|
+
commentAt = index;
|
|
621
|
+
break;
|
|
622
|
+
}
|
|
623
|
+
escaped = false;
|
|
624
|
+
}
|
|
625
|
+
const value = (commentAt >= 0 ? source.slice(0, commentAt) : source).trim();
|
|
626
|
+
if (!value || value.startsWith("#")) return false;
|
|
627
|
+
const quoted = (
|
|
628
|
+
(value.startsWith('"') && value.endsWith('"'))
|
|
629
|
+
|| (value.startsWith("'") && value.endsWith("'"))
|
|
630
|
+
);
|
|
631
|
+
const unquoted = quoted ? value.slice(1, -1).trim() : value;
|
|
632
|
+
let semanticValue = unquoted;
|
|
633
|
+
if (value.startsWith('"') && value.endsWith('"')) {
|
|
634
|
+
try {
|
|
635
|
+
semanticValue = JSON.parse(value).trim();
|
|
636
|
+
} catch {
|
|
637
|
+
// Be conservative for YAML-only escape sequences that this fast parser
|
|
638
|
+
// cannot decode consistently with PyYAML. Single quotes remain available
|
|
639
|
+
// for literal backslashes.
|
|
640
|
+
return false;
|
|
641
|
+
}
|
|
642
|
+
} else if (value.startsWith("'") && value.endsWith("'")) {
|
|
643
|
+
semanticValue = unquoted.replace(/''/g, "'").trim();
|
|
644
|
+
}
|
|
645
|
+
if (!semanticValue) return false;
|
|
646
|
+
if (!quoted && (
|
|
647
|
+
/^(?:null|true|false|yes|no|on|off|~)$/i.test(semanticValue)
|
|
648
|
+
|| /^(?:\[|\{|\||>|&|\*|!)/.test(semanticValue)
|
|
649
|
+
|| /^[+-]?(?:0b[01_]+|0o[0-7_]+|0x[\da-f_]+|\d[\d_]*(?:\.\d*)?(?:e[+-]?\d+)?|\.\d+(?:e[+-]?\d+)?|\.inf|\.nan)$/i.test(semanticValue)
|
|
650
|
+
|| /^\d{4}-\d{1,2}-\d{1,2}(?:[Tt ]|$)/.test(semanticValue)
|
|
651
|
+
|| /^\d+(?::\d+)+(?:\.\d+)?$/.test(semanticValue)
|
|
652
|
+
)) return false;
|
|
653
|
+
const upper = semanticValue.toUpperCase();
|
|
654
|
+
return ![
|
|
655
|
+
"N/A", "TODO", "TBD", "CHANGEME", "CHANGE_ME", "FILL_ME", "FILL-ME",
|
|
656
|
+
"PLACEHOLDER", "XXX", "NULL", "~",
|
|
657
|
+
].includes(upper)
|
|
658
|
+
&& !(semanticValue.startsWith("<") && semanticValue.endsWith(">"))
|
|
659
|
+
&& !upper.startsWith("REPLACE_")
|
|
660
|
+
&& !upper.startsWith("YOUR_");
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
function frontmatterScalarValue(raw){
|
|
664
|
+
const source = String(raw || "");
|
|
665
|
+
let quote = "";
|
|
666
|
+
let escaped = false;
|
|
667
|
+
let commentAt = -1;
|
|
668
|
+
for (let index = 0; index < source.length; index += 1) {
|
|
669
|
+
const char = source[index];
|
|
670
|
+
if (quote === '"' && char === "\\" && !escaped) {
|
|
671
|
+
escaped = true;
|
|
672
|
+
continue;
|
|
673
|
+
}
|
|
674
|
+
if ((char === '"' || char === "'") && !escaped) {
|
|
675
|
+
quote = quote === char ? "" : (quote || char);
|
|
676
|
+
} else if (char === "#" && !quote && (index === 0 || /\s/.test(source[index - 1]))) {
|
|
677
|
+
commentAt = index;
|
|
678
|
+
break;
|
|
679
|
+
}
|
|
680
|
+
escaped = false;
|
|
681
|
+
}
|
|
682
|
+
const value = (commentAt >= 0 ? source.slice(0, commentAt) : source).trim();
|
|
683
|
+
if (value.startsWith('"') && value.endsWith('"')) {
|
|
684
|
+
try { return JSON.parse(value).trim(); } catch { return ""; }
|
|
685
|
+
}
|
|
686
|
+
if (value.startsWith("'") && value.endsWith("'")) {
|
|
687
|
+
return value.slice(1, -1).replace(/''/g, "'").trim();
|
|
688
|
+
}
|
|
689
|
+
return value;
|
|
431
690
|
}
|
|
432
691
|
|
|
433
692
|
function projectStatus(project, assetSkill, assetAgents){
|
|
@@ -437,9 +696,12 @@ function projectStatus(project, assetSkill, assetAgents){
|
|
|
437
696
|
const toolDir = path.join(root, "docs", "tools", "autopipeline");
|
|
438
697
|
const engineering = path.join(root, "docs", "ENGINEERING.md");
|
|
439
698
|
const engineeringMissing = !exists(engineering);
|
|
699
|
+
const engineeringPlan = planEngineeringSync(root, assetSkill);
|
|
700
|
+
const managedWorkflow = publicEngineeringPlan(engineeringPlan);
|
|
440
701
|
const requiredConfigPaths = [
|
|
441
702
|
{ label: "workflow.mode", path: ["workflow", "mode"] },
|
|
442
703
|
{ label: "workflow.profile", path: ["workflow", "profile"] },
|
|
704
|
+
{ label: "workflow.completion", path: ["workflow", "completion"] },
|
|
443
705
|
{ label: "concurrency.isolation", path: ["concurrency", "isolation"] },
|
|
444
706
|
{ label: "concurrency.base_ref", path: ["concurrency", "base_ref"] },
|
|
445
707
|
{ label: "concurrency.target_branch", path: ["concurrency", "target_branch"] },
|
|
@@ -448,22 +710,47 @@ function projectStatus(project, assetSkill, assetAgents){
|
|
|
448
710
|
{ label: "concurrency.cleanup_merged", path: ["concurrency", "cleanup_merged"] },
|
|
449
711
|
{ label: "concurrency.delete_remote_branch", path: ["concurrency", "delete_remote_branch"] },
|
|
450
712
|
{ label: "concurrency.disposable_ignored", path: ["concurrency", "disposable_ignored"] },
|
|
451
|
-
{ label: "project.name", path: ["project", "name"] },
|
|
452
|
-
{ label: "
|
|
453
|
-
{ label: "
|
|
713
|
+
{ label: "project.name", path: ["project", "name"], filled: true },
|
|
714
|
+
{ label: "access.project.frontend.url", path: ["access", "project", "frontend", "url"], filled: true },
|
|
715
|
+
{ label: "access.project.frontend.username", path: ["access", "project", "frontend", "username"], filled: true },
|
|
716
|
+
{ label: "access.project.frontend.password", path: ["access", "project", "frontend", "password"], filled: true },
|
|
717
|
+
{ label: "access.project.backend.url", path: ["access", "project", "backend", "url"], filled: true },
|
|
718
|
+
{ label: "access.project.backend.username", path: ["access", "project", "backend", "username"], filled: true },
|
|
719
|
+
{ label: "access.project.backend.password", path: ["access", "project", "backend", "password"], filled: true },
|
|
720
|
+
{ label: "access.jenkins.frontend.url", path: ["access", "jenkins", "frontend", "url"], filled: true },
|
|
721
|
+
{ label: "access.jenkins.frontend.username", path: ["access", "jenkins", "frontend", "username"], filled: true },
|
|
722
|
+
{ label: "access.jenkins.frontend.password", path: ["access", "jenkins", "frontend", "password"], filled: true },
|
|
723
|
+
{ label: "access.jenkins.backend.url", path: ["access", "jenkins", "backend", "url"], filled: true },
|
|
724
|
+
{ label: "access.jenkins.backend.username", path: ["access", "jenkins", "backend", "username"], filled: true },
|
|
725
|
+
{ label: "access.jenkins.backend.password", path: ["access", "jenkins", "backend", "password"], filled: true },
|
|
726
|
+
{ label: "access.gitlab.url", path: ["access", "gitlab", "url"], filled: true },
|
|
727
|
+
{ label: "access.gitlab.username", path: ["access", "gitlab", "username"], filled: true },
|
|
728
|
+
{ label: "access.gitlab.password", path: ["access", "gitlab", "password"], filled: true },
|
|
729
|
+
{ label: "access.nexus.frontend.url", path: ["access", "nexus", "frontend", "url"], filled: true },
|
|
730
|
+
{ label: "access.nexus.frontend.username", path: ["access", "nexus", "frontend", "username"], filled: true },
|
|
731
|
+
{ label: "access.nexus.frontend.password", path: ["access", "nexus", "frontend", "password"], filled: true },
|
|
454
732
|
{ label: "docs.taskbook", path: ["docs", "taskbook"] },
|
|
455
733
|
{ label: "docs.closure_log", path: ["docs", "closure_log"] },
|
|
456
734
|
{ label: "docs.active_task_dir", path: ["docs", "active_task_dir"] },
|
|
457
735
|
{ label: "docs.task_closure_dir", path: ["docs", "task_closure_dir"] },
|
|
458
736
|
{ label: "docs.task_evidence_dir", path: ["docs", "task_evidence_dir"] },
|
|
459
737
|
];
|
|
460
|
-
let
|
|
738
|
+
let missingConfigPaths = requiredConfigPaths.map(item => item.label);
|
|
739
|
+
let unfilledConfigTokens = [];
|
|
740
|
+
let invalidConfigTokens = [];
|
|
461
741
|
if (!engineeringMissing) {
|
|
462
742
|
const text = fs.readFileSync(engineering, "utf8");
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
743
|
+
const states = requiredConfigPaths.map(item => ({ item, state: frontmatterPathState(text, item.path) }));
|
|
744
|
+
missingConfigPaths = states.filter(({ state }) => !state.present).map(({ item }) => item.label);
|
|
745
|
+
unfilledConfigTokens = states
|
|
746
|
+
.filter(({ item, state }) => state.present && item.filled === true && !frontmatterValueIsFilled(state.value))
|
|
747
|
+
.map(({ item }) => item.label);
|
|
748
|
+
const isolationState = frontmatterPathState(text, ["concurrency", "isolation"]);
|
|
749
|
+
if (isolationState.present && frontmatterScalarValue(isolationState.value).toLowerCase() !== "worktree") {
|
|
750
|
+
invalidConfigTokens = ["concurrency.isolation (must be worktree)"];
|
|
751
|
+
}
|
|
466
752
|
}
|
|
753
|
+
const missingConfigTokens = [...missingConfigPaths, ...unfilledConfigTokens, ...invalidConfigTokens];
|
|
467
754
|
const scriptDiffs = [];
|
|
468
755
|
const launcherSrc = path.join(assetSkill, "data", "templates", "tools", "ap.py");
|
|
469
756
|
const launcherDst = path.join(toolDir, "ap.py");
|
|
@@ -481,16 +768,20 @@ function projectStatus(project, assetSkill, assetAgents){
|
|
|
481
768
|
? compareManagedAgents(assetAgents, agentsDir)
|
|
482
769
|
: { diffs: [{ path: ".agents/agents", status: "missing" }], bindings: [] };
|
|
483
770
|
const agentDiffs = agentStatus.diffs;
|
|
484
|
-
const ok = skillDiffs.length === 0 && agentDiffs.length === 0 && scriptDiffs.length === 0 && missingDocs.length === 0 && missingConfigTokens.length === 0;
|
|
771
|
+
const ok = skillDiffs.length === 0 && agentDiffs.length === 0 && scriptDiffs.length === 0 && missingDocs.length === 0 && missingConfigTokens.length === 0 && managedWorkflow.state === "current";
|
|
485
772
|
let next = "";
|
|
486
773
|
if (!exists(skillDir) || !exists(agentsDir)) {
|
|
487
774
|
next = "run autocoding init --force";
|
|
488
775
|
} else if (skillDiffs.length || agentDiffs.length) {
|
|
489
776
|
next = "run autocoding sync --projects <repo>";
|
|
490
|
-
} else if (engineeringMissing || scriptDiffs.length || missingDocs.length) {
|
|
777
|
+
} else if (engineeringMissing || managedWorkflow.state !== "current" || scriptDiffs.length || missingDocs.length) {
|
|
491
778
|
next = "run autocoding sync --projects <repo> or python3 .agents/skills/auto-coding-skill/scripts/ap.py --repo . install";
|
|
492
|
-
} else if (
|
|
493
|
-
next = "run project-local ap.py upgrade --write to merge docs/ENGINEERING.md
|
|
779
|
+
} else if (missingConfigPaths.length) {
|
|
780
|
+
next = "run project-local ap.py upgrade --write to merge missing paths, fill every required value in docs/ENGINEERING.md, then run doctor";
|
|
781
|
+
} else if (invalidConfigTokens.length) {
|
|
782
|
+
next = "run project-local ap.py upgrade --write to migrate concurrency.isolation to worktree, then run doctor";
|
|
783
|
+
} else if (unfilledConfigTokens.length) {
|
|
784
|
+
next = "fill every required value in docs/ENGINEERING.md, then run project-local ap.py doctor";
|
|
494
785
|
}
|
|
495
786
|
return {
|
|
496
787
|
project: root,
|
|
@@ -501,6 +792,10 @@ function projectStatus(project, assetSkill, assetAgents){
|
|
|
501
792
|
scriptDiffs,
|
|
502
793
|
missingDocs,
|
|
503
794
|
missingConfigTokens,
|
|
795
|
+
missingConfigPaths,
|
|
796
|
+
unfilledConfigTokens,
|
|
797
|
+
invalidConfigTokens,
|
|
798
|
+
managedWorkflow,
|
|
504
799
|
next,
|
|
505
800
|
};
|
|
506
801
|
}
|
|
@@ -516,44 +811,64 @@ function printProjectStatus(result){
|
|
|
516
811
|
}
|
|
517
812
|
for (const item of result.missingDocs) console.log(`[autocoding] doc missing: ${item}`);
|
|
518
813
|
for (const item of result.missingConfigTokens) console.log(`[autocoding] config missing path: ${item}`);
|
|
814
|
+
if (result.managedWorkflow?.state !== "current") {
|
|
815
|
+
const detail = result.managedWorkflow?.detail ? ` - ${result.managedWorkflow.detail}` : "";
|
|
816
|
+
console.log(`[autocoding] engineering managed-workflow: ${result.managedWorkflow?.state || "unknown"} target=${result.managedWorkflow?.version || "unknown"}${detail}`);
|
|
817
|
+
}
|
|
519
818
|
for (const item of result.agentBindings || []) console.log(`[autocoding] agent model: ${item.agent} -> ${item.model}`);
|
|
520
819
|
if (result.next) console.log(`[autocoding] next: ${result.next}`);
|
|
521
820
|
}
|
|
522
821
|
|
|
523
|
-
function
|
|
822
|
+
function engineeringPlanDetail(plan){
|
|
823
|
+
if (plan.state === "legacy-custom") return `managed workflow preserved-custom -> ${plan.version}`;
|
|
824
|
+
if (plan.state === "legacy-official") return `managed workflow official-legacy -> ${plan.version}`;
|
|
825
|
+
return `managed workflow ${plan.state} -> ${plan.version}`;
|
|
826
|
+
}
|
|
827
|
+
|
|
828
|
+
function syncProject(project, assetSkill, assetAgents, dryRun, resetAgentModels = false, components = "all", engineeringPlan = null){
|
|
524
829
|
const root = path.resolve(project);
|
|
525
830
|
const actions = [];
|
|
526
831
|
const skillDir = path.join(root, ".agents", "skills", "auto-coding-skill");
|
|
832
|
+
const skillOnly = components === "skill";
|
|
833
|
+
actions.push({ action: dryRun ? "would-sync" : "sync", path: path.relative(root, skillDir) });
|
|
834
|
+
if (!dryRun) {
|
|
835
|
+
rmrf(skillDir);
|
|
836
|
+
copyDir(assetSkill, skillDir);
|
|
837
|
+
}
|
|
838
|
+
if (skillOnly) return { project: root, dryRun, components, actions };
|
|
839
|
+
|
|
527
840
|
const agentsDir = path.join(root, ".agents", "agents");
|
|
528
841
|
const toolDir = path.join(root, "docs", "tools", "autopipeline");
|
|
529
|
-
const
|
|
530
|
-
const engineeringWasMissing = !exists(engineering);
|
|
531
|
-
const templateEngineering = path.join(assetSkill, "data", "templates", "ENGINEERING.md");
|
|
532
|
-
actions.push({ action: dryRun ? "would-sync" : "sync", path: path.relative(root, skillDir) });
|
|
842
|
+
const plan = engineeringPlan || planEngineeringSync(root, assetSkill);
|
|
533
843
|
actions.push({ action: dryRun ? "would-sync" : "sync", path: path.relative(root, agentsDir) });
|
|
534
844
|
actions.push({ action: dryRun ? "would-sync" : "sync", path: "docs/tools/autopipeline/ap.py" });
|
|
535
845
|
if (!dryRun) {
|
|
536
|
-
rmrf(skillDir);
|
|
537
|
-
copyDir(assetSkill, skillDir);
|
|
538
846
|
syncManagedAgents(assetAgents, agentsDir, { resetModel: resetAgentModels });
|
|
539
847
|
fs.mkdirSync(toolDir, { recursive: true });
|
|
540
848
|
fs.copyFileSync(path.join(assetSkill, "data", "templates", "tools", "ap.py"), path.join(toolDir, "ap.py"));
|
|
541
849
|
for (const copied of copyMissingDocs(assetSkill, root)) actions.push({ action: "create", path: copied });
|
|
542
|
-
if (
|
|
543
|
-
fs.mkdirSync(path.dirname(engineering), { recursive: true });
|
|
544
|
-
fs.writeFileSync(engineering,
|
|
545
|
-
actions.push({
|
|
850
|
+
if (plan.state !== "current") {
|
|
851
|
+
fs.mkdirSync(path.dirname(plan.engineering), { recursive: true });
|
|
852
|
+
fs.writeFileSync(plan.engineering, plan.output);
|
|
853
|
+
actions.push({
|
|
854
|
+
action: plan.state === "missing" ? "create" : "update",
|
|
855
|
+
path: path.join("docs", "ENGINEERING.md"),
|
|
856
|
+
detail: engineeringPlanDetail(plan),
|
|
857
|
+
});
|
|
546
858
|
}
|
|
547
859
|
} else {
|
|
548
860
|
for (const rel of CORE_DOCS) {
|
|
549
861
|
if (!exists(path.join(root, "docs", rel))) actions.push({ action: "would-create", path: path.join("docs", rel) });
|
|
550
862
|
}
|
|
551
|
-
if (
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
863
|
+
if (plan.state !== "current") {
|
|
864
|
+
actions.push({
|
|
865
|
+
action: plan.state === "missing" ? "would-create" : "would-update",
|
|
866
|
+
path: path.join("docs", "ENGINEERING.md"),
|
|
867
|
+
detail: engineeringPlanDetail(plan),
|
|
868
|
+
});
|
|
869
|
+
}
|
|
555
870
|
}
|
|
556
|
-
return { project: root, dryRun, actions };
|
|
871
|
+
return { project: root, dryRun, components, managedWorkflow: publicEngineeringPlan(plan), actions };
|
|
557
872
|
}
|
|
558
873
|
|
|
559
874
|
function projectRoot(){ return process.cwd(); }
|
|
@@ -612,12 +927,13 @@ autocoding - install auto-coding-skill into generic .agents paths
|
|
|
612
927
|
Usage:
|
|
613
928
|
autocoding init [--mode project|global] [--dest <repo-root|.agents-dir|skill-dir>] [--force] [--reset-agent-models]
|
|
614
929
|
autocoding status --projects <path[,path...]> [--json]
|
|
615
|
-
autocoding sync --projects <path[,path...]> [--dry-run] [--json] [--reset-agent-models]
|
|
930
|
+
autocoding sync --projects <path[,path...]> [--components all|skill] [--dry-run] [--json] [--reset-agent-models]
|
|
616
931
|
|
|
617
932
|
Examples:
|
|
618
933
|
autocoding init
|
|
619
934
|
autocoding status --projects /Users/elvis/Product/xjmate,/Users/elvis/Product/geesight
|
|
620
935
|
autocoding sync --projects /Users/elvis/Product/xjmate --dry-run
|
|
936
|
+
autocoding sync --projects /Users/elvis/Product/geesight --components skill
|
|
621
937
|
|
|
622
938
|
Compatibility:
|
|
623
939
|
--ai <value> is accepted for old scripts and ignored.
|
|
@@ -629,8 +945,13 @@ Compatibility:
|
|
|
629
945
|
validateCommandArgs(args);
|
|
630
946
|
|
|
631
947
|
const here = path.dirname(fileURLToPath(import.meta.url));
|
|
632
|
-
const
|
|
633
|
-
const
|
|
948
|
+
const packagedAssetSkill = path.resolve(here, "..", "assets", "skill");
|
|
949
|
+
const packagedAssetAgents = path.resolve(here, "..", "assets", "agents");
|
|
950
|
+
const sourceAssetSkill = path.resolve(here, "..", "..", "src", "auto-coding-skill");
|
|
951
|
+
const sourceAssetAgents = path.resolve(here, "..", "..", "src", "agents");
|
|
952
|
+
const useSourceAssets = exists(sourceAssetSkill) && exists(sourceAssetAgents);
|
|
953
|
+
const assetSkill = useSourceAssets ? sourceAssetSkill : packagedAssetSkill;
|
|
954
|
+
const assetAgents = useSourceAssets ? sourceAssetAgents : packagedAssetAgents;
|
|
634
955
|
if (!exists(assetSkill)) die(`missing assets at ${assetSkill}`);
|
|
635
956
|
if (!exists(assetAgents)) die(`missing assets at ${assetAgents}`);
|
|
636
957
|
|
|
@@ -647,13 +968,37 @@ Compatibility:
|
|
|
647
968
|
|
|
648
969
|
if (args.cmd === "sync") {
|
|
649
970
|
const projects = args.projects.length ? args.projects : [projectRoot()];
|
|
650
|
-
|
|
971
|
+
assertNoLegacyRegisteredTasks(projects);
|
|
972
|
+
const engineeringPlans = new Map();
|
|
973
|
+
if (args.components === "all") {
|
|
974
|
+
for (const project of projects) {
|
|
975
|
+
const root = path.resolve(project);
|
|
976
|
+
const plan = planEngineeringSync(root, assetSkill);
|
|
977
|
+
if (plan.state === "invalid") {
|
|
978
|
+
die(`refusing to sync ${root}: ${plan.detail}`);
|
|
979
|
+
}
|
|
980
|
+
engineeringPlans.set(root, plan);
|
|
981
|
+
}
|
|
982
|
+
}
|
|
983
|
+
const results = projects.map(project => {
|
|
984
|
+
const root = path.resolve(project);
|
|
985
|
+
return syncProject(
|
|
986
|
+
root,
|
|
987
|
+
assetSkill,
|
|
988
|
+
assetAgents,
|
|
989
|
+
args.dryRun,
|
|
990
|
+
args.resetAgentModels,
|
|
991
|
+
args.components,
|
|
992
|
+
engineeringPlans.get(root) || null,
|
|
993
|
+
);
|
|
994
|
+
});
|
|
651
995
|
if (args.json) console.log(JSON.stringify({ version: readPackageVersion(), results }, null, 2));
|
|
652
996
|
else {
|
|
653
997
|
console.log(`[autocoding] version=${readPackageVersion()}`);
|
|
654
998
|
for (const result of results) {
|
|
655
999
|
console.log(`[autocoding] project=${result.project}`);
|
|
656
1000
|
console.log(`[autocoding] dryRun=${result.dryRun}`);
|
|
1001
|
+
console.log(`[autocoding] components=${result.components}`);
|
|
657
1002
|
for (const item of result.actions) {
|
|
658
1003
|
const detail = item.detail ? ` - ${item.detail}` : "";
|
|
659
1004
|
console.log(`[autocoding] ${item.action}: ${item.path}${detail}`);
|
|
@@ -681,6 +1026,9 @@ Compatibility:
|
|
|
681
1026
|
syncManagedAgents(assetAgents, agentsDir, { resetModel: args.resetAgentModels });
|
|
682
1027
|
console.log(`[autocoding] installed agents to: ${agentsDir}`);
|
|
683
1028
|
|
|
1029
|
+
if (args.mode === "project") {
|
|
1030
|
+
console.log("[autocoding] next: run autocoding sync --projects ., fill every access.* field in docs/ENGINEERING.md, then run doctor.");
|
|
1031
|
+
}
|
|
684
1032
|
console.log("[autocoding] done.");
|
|
685
1033
|
}
|
|
686
1034
|
|