triflux 10.3.4 → 10.7.0

package/scripts/__tests__/skill-template.test.mjs

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, it } from "node:test";
-
+import { generateSkillDocs } from "../gen-skill-docs.mjs";
 import {
   buildSkillTemplateContext,
   loadSkillManifest,
@@ -12,7 +12,6 @@ import {
   parseFrontmatterWithManifest,
   renderSkillTemplate,
 } from "../lib/skill-template.mjs";
-import { generateSkillDocs } from "../gen-skill-docs.mjs";
 
 function makeTempDir() {
   return mkdtempSync(join(tmpdir(), "tfx-skill-template-"));
@@ -30,16 +29,20 @@ describe("skill-template engine", () => {
       "name={{SKILL_NAME}}",
     ].join("\n");
 
-    const output = renderSkillTemplate(template, {
-      SKILL_NAME: "tfx-deep-plan",
-      SKILL_DESCRIPTION: "consensus planner",
-      DEEP: true,
-    }, {
-      partials: {
-        base: "desc={{SKILL_DESCRIPTION}}",
-        deep: "deep-enabled",
+    const output = renderSkillTemplate(
+      template,
+      {
+        SKILL_NAME: "tfx-deep-plan",
+        SKILL_DESCRIPTION: "consensus planner",
+        DEEP: true,
       },
-    });
+      {
+        partials: {
+          base: "desc={{SKILL_DESCRIPTION}}",
+          deep: "deep-enabled",
+        },
+      },
+    );
 
     assert.match(output, /desc=consensus planner/);
     assert.match(output, /deep-enabled/);
@@ -48,7 +51,11 @@ describe("skill-template engine", () => {
 
   it("조건부가 false면 블록을 제거한다", () => {
     const template = "start\n{{#if DEEP}}hidden{{/if}}\nend";
-    const output = renderSkillTemplate(template, { DEEP: false }, { partials: {} });
+    const output = renderSkillTemplate(
+      template,
+      { DEEP: false },
+      { partials: {} },
+    );
     assert.equal(output, "start\n\nend");
   });
 
@@ -94,7 +101,11 @@ describe("skill-template engine", () => {
     try {
       mkdirSync(join(root, "nested"), { recursive: true });
       writeFileSync(join(root, "base.md"), "base-partial", "utf8");
-      writeFileSync(join(root, "nested", "telemetry.md"), "telemetry-partial", "utf8");
+      writeFileSync(
+        join(root, "nested", "telemetry.md"),
+        "telemetry-partial",
+        "utf8",
+      );
 
       const partials = loadTemplatePartials(root);
       assert.equal(partials.base, "base-partial");
@@ -108,12 +119,16 @@ describe("skill-template engine", () => {
   it("순환 partial include를 감지한다", () => {
     assert.throws(
       () =>
-        renderSkillTemplate("{{> A}}", {}, {
-          partials: {
-            A: "A -> {{> B}}",
-            B: "B -> {{> A}}",
+        renderSkillTemplate(
+          "{{> A}}",
+          {},
+          {
+            partials: {
+              A: "A -> {{> B}}",
+              B: "B -> {{> A}}",
+            },
           },
-        }),
+        ),
       /Circular partial include: A -> B -> A/,
     );
   });
@@ -125,35 +140,48 @@ describe("skill-template engine", () => {
   });
 
   it("중복 frontmatter 키는 마지막 값을 우선한다", () => {
-    const parsed = parseFrontmatter([
-      "---",
-      "name: first",
-      "name: second",
-      "---",
-      "x",
-    ].join("\n"));
+    const parsed = parseFrontmatter(
+      ["---", "name: first", "name: second", "---", "x"].join("\n"),
+    );
     assert.equal(parsed.data.name, "second");
   });
 
   it("특수문자 변수 키(점/하이픈)를 치환한다", () => {
-    const output = renderSkillTemplate("{{FOO.BAR}}/{{FOO-BAR}}", {
-      "FOO.BAR": "dot",
-      "FOO-BAR": "dash",
-    }, { partials: {} });
+    const output = renderSkillTemplate(
+      "{{FOO.BAR}}/{{FOO-BAR}}",
+      {
+        "FOO.BAR": "dot",
+        "FOO-BAR": "dash",
+      },
+      { partials: {} },
+    );
     assert.equal(output, "dot/dash");
   });
 
   it("중첩 조건 블록을 안쪽 조건값에 따라 렌더링한다", () => {
     const template = "{{#if A}}open-{{#if B}}inner{{/if}}-close{{/if}}";
-    assert.equal(renderSkillTemplate(template, { A: true, B: true }, { partials: {} }), "open-inner-close");
-    assert.equal(renderSkillTemplate(template, { A: true, B: false }, { partials: {} }), "open--close");
-    assert.equal(renderSkillTemplate(template, { A: false, B: true }, { partials: {} }), "");
+    assert.equal(
+      renderSkillTemplate(template, { A: true, B: true }, { partials: {} }),
+      "open-inner-close",
+    );
+    assert.equal(
+      renderSkillTemplate(template, { A: true, B: false }, { partials: {} }),
+      "open--close",
+    );
+    assert.equal(
+      renderSkillTemplate(template, { A: false, B: true }, { partials: {} }),
+      "",
+    );
   });
 
   it("1000줄 이상 대형 템플릿도 렌더링한다", () => {
     const lines = Array.from({ length: 1_200 }, (_v, i) => `line-${i}`);
     const template = `${lines.join("\n")}\nname={{SKILL_NAME}}`;
-    const output = renderSkillTemplate(template, { SKILL_NAME: "big-template" }, { partials: {} });
+    const output = renderSkillTemplate(
+      template,
+      { SKILL_NAME: "big-template" },
+      { partials: {} },
+    );
 
     const renderedLines = output.split("\n");
     assert.equal(renderedLines.length, 1_201);
@@ -166,13 +194,21 @@ describe("skill-template engine", () => {
     try {
       const sharedDir = join(root, "shared");
       mkdirSync(sharedDir, { recursive: true });
-      writeFileSync(join(sharedDir, "telemetry.md"), "TEL={{SKILL_NAME}}", "utf8");
+      writeFileSync(
+        join(sharedDir, "telemetry.md"),
+        "TEL={{SKILL_NAME}}",
+        "utf8",
+      );
 
       const template = "before\n{{#include shared/telemetry.md}}\nafter";
-      const output = renderSkillTemplate(template, { SKILL_NAME: "test-skill" }, {
-        partials: {},
-        includeBaseDir: root,
-      });
+      const output = renderSkillTemplate(
+        template,
+        { SKILL_NAME: "test-skill" },
+        {
+          partials: {},
+          includeBaseDir: root,
+        },
+      );
 
       assert.match(output, /before/);
       assert.match(output, /TEL=test-skill/);
@@ -185,11 +221,15 @@ describe("skill-template engine", () => {
   it("loadSkillManifest는 skill.json이 있으면 파싱한다", () => {
     const root = makeTempDir();
     try {
-      writeFileSync(join(root, "skill.json"), JSON.stringify({
-        name: "tfx-test",
-        description: "test skill",
-        triggers: ["test"],
-      }), "utf8");
+      writeFileSync(
+        join(root, "skill.json"),
+        JSON.stringify({
+          name: "tfx-test",
+          description: "test skill",
+          triggers: ["test"],
+        }),
+        "utf8",
+      );
 
       const manifest = loadSkillManifest(root);
       assert.equal(manifest.name, "tfx-test");
@@ -211,11 +251,15 @@ describe("skill-template engine", () => {
   it("parseFrontmatterWithManifest는 skill.json 우선으로 병합한다", () => {
     const root = makeTempDir();
     try {
-      writeFileSync(join(root, "skill.json"), JSON.stringify({
-        name: "manifest-name",
-        description: "manifest-desc",
-        internal: true,
-      }), "utf8");
+      writeFileSync(
+        join(root, "skill.json"),
+        JSON.stringify({
+          name: "manifest-name",
+          description: "manifest-desc",
+          internal: true,
+        }),
+        "utf8",
+      );
 
       const source = [
         "---",
@@ -258,7 +302,11 @@ describe("skill-template engine", () => {
       mkdirSync(templatesDir, { recursive: true });
       mkdirSync(skillDir, { recursive: true });
 
-      writeFileSync(join(templatesDir, "base.md"), "base={{SKILL_NAME}}", "utf8");
+      writeFileSync(
+        join(templatesDir, "base.md"),
+        "base={{SKILL_NAME}}",
+        "utf8",
+      );
       writeFileSync(
         join(skillDir, "SKILL.md.tmpl"),
         [

package/scripts/__tests__/smoke.test.mjs

@@ -1,5 +1,5 @@
-import { describe, it } from "node:test";
 import assert from "node:assert/strict";
+import { describe, it } from "node:test";
 
 describe("smoke: 주요 모듈 import 검증", () => {
   it("scripts/lib/keyword-rules.mjs — 순수 함수 export", async () => {

package/scripts/__tests__/spawn-trace.test.mjs

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it, mock } from "node:test";
+import { join } from "node:path";
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+const TEST_LOG_DIR = join(tmpdir(), `spawn-trace-test-${Date.now()}`);
+
+describe("spawn-trace", () => {
+  before(() => {
+    mkdirSync(TEST_LOG_DIR, { recursive: true });
+  });
+
+  after(() => {
+    try { rmSync(TEST_LOG_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("exports child_process-compatible API surface", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    assert.equal(typeof mod.spawn, "function");
+    assert.equal(typeof mod.execFile, "function");
+    assert.equal(typeof mod.execFileSync, "function");
+    assert.equal(typeof mod.exec, "function");
+    assert.equal(typeof mod.execSync, "function");
+    assert.equal(typeof mod.fork, "function");
+    assert.equal(typeof mod.spawnSync, "function");
+  });
+
+  it("exports guard constants", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    assert.equal(typeof mod.MAX_WT_TABS, "number");
+    assert.ok(mod.MAX_WT_TABS > 0);
+    assert.equal(typeof mod.MAX_SPAWN_PER_SEC, "number");
+    assert.equal(typeof mod.MAX_TOTAL_DESCENDANTS, "number");
+  });
+
+  it("spawn returns a ChildProcess-like object", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const child = mod.spawn("node", ["-e", "process.exit(0)"], {
+      windowsHide: true,
+    });
+    assert.ok(child);
+    assert.equal(typeof child.pid, "number");
+    assert.equal(typeof child.kill, "function");
+
+    await new Promise((resolve) => child.once("close", resolve));
+  });
+
+  it("execFileSync returns stdout buffer", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const result = mod.execFileSync("node", ["-e", 'process.stdout.write("hello")'], {
+      encoding: "utf8",
+      windowsHide: true,
+    });
+    assert.equal(result.trim(), "hello");
+  });
+
+  it("execFileSync throws on non-zero exit", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    assert.throws(() => {
+      mod.execFileSync("node", ["-e", "process.exit(1)"], {
+        windowsHide: true,
+      });
+    });
+  });
+
+  it("execFile with callback receives stdout", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const result = await new Promise((resolve, reject) => {
+      mod.execFile(
+        "node",
+        ["-e", 'process.stdout.write("world")'],
+        { encoding: "utf8", windowsHide: true },
+        (err, stdout) => {
+          if (err) reject(err);
+          else resolve(stdout);
+        },
+      );
+    });
+    assert.equal(result.trim(), "world");
+  });
+
+  it("strips trace-specific options before passing to child_process", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    // reason and dedupe should not cause child_process to error
+    const result = mod.execFileSync("node", ["-e", 'process.stdout.write("ok")'], {
+      encoding: "utf8",
+      windowsHide: true,
+      reason: "test:strip-options",
+      dedupe: "test-key",
+    });
+    assert.equal(result.trim(), "ok");
+  });
+
+  it("default export includes spawn/execFile/execFileSync", async () => {
+    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    assert.equal(typeof mod.default.spawn, "function");
+    assert.equal(typeof mod.default.execFile, "function");
+    assert.equal(typeof mod.default.execFileSync, "function");
+    assert.equal(typeof mod.default.MAX_WT_TABS, "number");
+  });
+});

package/scripts/__tests__/tfx-doctor-diagnose.test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { after, describe, it } from "node:test";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+describe("doctor-diagnose: 진단 번들 생성", () => {
+  let result;
+
+  it("diagnose() 실행 성공", async () => {
+    const { diagnose } = await import("../../scripts/doctor-diagnose.mjs");
+    result = await diagnose({ json: false });
+    assert.ok(result);
+    assert.equal(result.ok, true);
+  });
+
+  it("zip 파일 생성됨", () => {
+    assert.ok(result.zipPath);
+    assert.ok(existsSync(result.zipPath), `zip not found: ${result.zipPath}`);
+    assert.ok(result.zipPath.endsWith(".zip"));
+  });
+
+  it("stats 필드 포함", () => {
+    assert.equal(typeof result.stats.total, "number");
+    assert.equal(typeof result.stats.peakRatePerSec, "number");
+    assert.equal(typeof result.stats.maxConcurrent, "number");
+    assert.equal(typeof result.stats.blocked, "number");
+  });
+
+  it("sysInfo 필드 포함", () => {
+    assert.equal(typeof result.sysInfo.platform, "string");
+    assert.equal(typeof result.sysInfo.nodeVersion, "string");
+    assert.equal(typeof result.sysInfo.cpuCores, "number");
+    assert.equal(typeof result.sysInfo.totalMemMB, "number");
+  });
+
+  it("traceCount/hookTimingCount 숫자", () => {
+    assert.equal(typeof result.traceCount, "number");
+    assert.equal(typeof result.hookTimingCount, "number");
+  });
+
+  after(() => {
+    // 테스트 생성 zip 정리
+    if (result?.zipPath && existsSync(result.zipPath)) {
+      try { rmSync(result.zipPath); } catch { /* ignore */ }
+    }
+  });
+});

package/scripts/cache-doctor.mjs

@@ -82,7 +82,9 @@ function inspectTarget(target, options = {}) {
 }
 
 export function verifyCaches(options = {}) {
-  const targets = options.targets?.length ? options.targets : Object.keys(CACHE_TARGETS);
+  const targets = options.targets?.length
+    ? options.targets
+    : Object.keys(CACHE_TARGETS);
   const results = targets.map((target) => inspectTarget(target, options));
   const issueCount = results.filter((result) => result.status !== "ok").length;
 
@@ -123,7 +125,9 @@ export async function fixCaches(options = {}) {
 
 function formatVerificationSummary(verification) {
   const label = verification.ok ? "cache-doctor: ok" : "cache-doctor: issues";
-  const details = verification.results.map((result) => `${result.target}:${result.status}`);
+  const details = verification.results.map(
+    (result) => `${result.target}:${result.status}`,
+  );
   return `${label} (${details.join(", ")})`;
 }
 
@@ -138,8 +142,11 @@ async function main() {
   }
 
   const repair = await fixCaches({ verification });
-  const repaired = repair.fixed.length > 0 ? `fixed:${repair.fixed.join(",")}` : "fixed:none";
-  const suffix = repair.summary.results.map((result) => `${result.target}:${result.status}`).join(", ");
+  const repaired =
+    repair.fixed.length > 0 ? `fixed:${repair.fixed.join(",")}` : "fixed:none";
+  const suffix = repair.summary.results
+    .map((result) => `${result.target}:${result.status}`)
+    .join(", ");
   console.log(`cache-doctor: fix (${repaired}${suffix ? `, ${suffix}` : ""})`);
   if (!repair.ok) process.exitCode = 1;
 }