project-tiny-context-harness 0.2.84 → 0.6.0

package/dist/lib/sync-engine.js

@@ -2,15 +2,17 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { readConfig } from "./config.js";
 import { harnessPath, harnessRoot } from "./harness-root.js";
-import { copyTree, listFiles, pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_START, MAKEFILE_BLOCK_END, MAKEFILE_BLOCK_MARKERS, MAKEFILE_BLOCK_START, MANAGED_BLOCK_END, MANAGED_BLOCK_START } from "./managed-file.js";
+import { copyTree, listFiles, pathExists, readText, writeTextIfChanged, } from "./fs.js";
+import { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_START, MAKEFILE_BLOCK_END, MAKEFILE_BLOCK_MARKERS, MAKEFILE_BLOCK_START, MANAGED_BLOCK_END, MANAGED_BLOCK_START, } from "./managed-file.js";
 import { packageAssetPath } from "./paths.js";
 import { assertSupportedSchema } from "./schema-guard.js";
+import { installLongTaskHooks, uninstallLongTaskHooks, } from "./long-task-hook-install.js";
+import { enabledManagedSkillNames, isProfileEnabled } from "./profiles.js";
 export function emptySyncReport() {
     return {
         changed: [],
         skipped: [],
-        blocked: []
+        blocked: [],
     };
 }
 export async function runSync(projectRoot) {
@@ -23,11 +25,17 @@ export async function runSync(projectRoot) {
         return report;
     }
     for (const managedFile of config.managed_files) {
-        await syncManagedFile(projectRoot, root, managedFile, report);
+        await syncManagedFile(projectRoot, root, managedFile, report, config);
+    }
+    if (isProfileEnabled(config, "long-task")) {
+        await installLongTaskHooks(projectRoot, report);
+    }
+    else {
+        await uninstallLongTaskHooks(projectRoot, report);
     }
     return report;
 }
-async function syncManagedFile(projectRoot, root, managedFile, report) {
+async function syncManagedFile(projectRoot, root, managedFile, report, config) {
     const destination = path.join(projectRoot, managedFile.path);
     if (managedFile.path === "AGENTS.md") {
         await syncAgentsBlock(destination, root, report);
@@ -38,7 +46,7 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         return;
     }
     if (isSkillsManagedPath(managedFile.path, root)) {
-        await syncSkillsTree(packageAssetPath("skills"), path.join(projectRoot, root, "skills"), report);
+        await syncSkillsTree(packageAssetPath("skills"), path.join(projectRoot, root, "skills"), report, enabledManagedSkillNames(config));
         return;
     }
     const managedPath = normalizeManagedPath(managedFile.path);
@@ -47,14 +55,17 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         return;
     }
     if (managedPath === harnessPath(root, "ty-context-managed", "context_templates")) {
-        await syncTree(packageAssetPath("context_templates"), destination, report, { prune: true });
+        await syncTree(packageAssetPath("context_templates"), destination, report, {
+            prune: true,
+        });
         return;
     }
     if (managedPath === harnessPath(root, "ty-context-managed", "policies")) {
         await syncTree(packageAssetPath("policies"), destination, report);
         return;
     }
-    if (managedPath === harnessPath(root, "ty-context-managed", "make", "ty-context.mk")) {
+    if (managedPath ===
+        harnessPath(root, "ty-context-managed", "make", "ty-context.mk")) {
         await syncFile(packageAssetPath("make", "ty-context.mk"), destination, report, "skip-if-missing");
         return;
     }
@@ -85,14 +96,16 @@ async function syncAgentsBlock(destination, root, report) {
     }
     const core = renderAgentsCore(await readText(corePath), root);
     const block = `${MANAGED_BLOCK_START}\n${core.trim()}\n${MANAGED_BLOCK_END}`;
-    const existing = (await pathExists(destination)) ? await readText(destination) : "";
+    const existing = (await pathExists(destination))
+        ? await readText(destination)
+        : "";
     const next = mergeManagedBlock({
         existing,
         block,
         markers: AGENTS_BLOCK_MARKERS,
         pathLabel: "AGENTS.md",
         insert: "append",
-        report
+        report,
     });
     if (!next) {
         return;
@@ -108,14 +121,16 @@ function renderAgentsCore(content, root) {
     return content.replaceAll(".agent", root).replaceAll(".codex", root);
 }
 async function syncMakefileInclude(destination, root, report) {
-    const existing = (await pathExists(destination)) ? await readText(destination) : "";
+    const existing = (await pathExists(destination))
+        ? await readText(destination)
+        : "";
     const resetDefaultGoal = shouldResetMakeDefaultGoal(existing);
     const includePath = `${root.replace(/\\/g, "/")}/ty-context-managed/make/ty-context.mk`;
     const blockLines = [
         MAKEFILE_BLOCK_START,
         "# Included before project targets so project recipes win on name conflicts.",
         `-include ${includePath}`,
-        MAKEFILE_BLOCK_END
+        MAKEFILE_BLOCK_END,
     ];
     if (resetDefaultGoal) {
         blockLines.splice(3, 0, ".DEFAULT_GOAL :=");
@@ -127,7 +142,7 @@ async function syncMakefileInclude(destination, root, report) {
         markers: MAKEFILE_BLOCK_MARKERS,
         pathLabel: "Makefile",
         insert: "prepend",
-        report
+        report,
     });
     if (!next) {
         return;
@@ -194,9 +209,14 @@ function findManagedBlock(existing, markersList) {
         matches.push({ markers, startIndex, endIndex });
     }
     if (matches.length > 1) {
-        return { status: "invalid", reason: "conflicting managed block marker namespaces" };
-    }
-    return matches[0] ? { status: "found", ...matches[0] } : { status: "missing" };
+        return {
+            status: "invalid",
+            reason: "conflicting managed block marker namespaces",
+        };
+    }
+    return matches[0]
+        ? { status: "found", ...matches[0] }
+        : { status: "missing" };
 }
 async function syncTree(source, destination, report, options = {}) {
     if (!(await pathExists(source))) {
@@ -224,7 +244,10 @@ async function removeStaleManagedFiles(source, destination) {
         .map((file) => path.relative(source, file).split(path.sep).join("/")));
     const removed = [];
     for (const destinationFile of await listFiles(destination)) {
-        const relative = path.relative(destination, destinationFile).split(path.sep).join("/");
+        const relative = path
+            .relative(destination, destinationFile)
+            .split(path.sep)
+            .join("/");
         if (sourceFiles.has(relative)) {
             continue;
         }
@@ -233,13 +256,18 @@ async function removeStaleManagedFiles(source, destination) {
     }
     return removed;
 }
-async function syncSkillsTree(source, destination, report) {
+async function syncSkillsTree(source, destination, report, enabledSkillNames) {
     if (!(await pathExists(source))) {
         report.skipped.push(path.basename(destination));
         return;
     }
     const files = await listFiles(source);
-    const realFiles = files.filter((file) => !file.endsWith(".gitkeep"));
+    const allManagedSkillNames = new Set(files
+        .map((file) => path.relative(source, file).split(path.sep)[0])
+        .filter(Boolean));
+    const realFiles = files
+        .filter((file) => !file.endsWith(".gitkeep"))
+        .filter((file) => enabledSkillNames.has(path.relative(source, file).split(path.sep)[0]));
     if (realFiles.length === 0) {
         report.skipped.push(path.basename(destination));
         return;
@@ -254,6 +282,21 @@ async function syncSkillsTree(source, destination, report) {
             report.skipped.push(destinationFile);
         }
     }
+    const managedSkillNames = new Set(realFiles
+        .map((file) => path.relative(source, file).split(path.sep)[0])
+        .filter(Boolean));
+    for (const skillName of managedSkillNames) {
+        report.changed.push(...(await removeStaleManagedFiles(path.join(source, skillName), path.join(destination, skillName))));
+    }
+    for (const skillName of allManagedSkillNames) {
+        if (enabledSkillNames.has(skillName))
+            continue;
+        const disabled = path.join(destination, skillName);
+        if (!(await pathExists(disabled)))
+            continue;
+        await fs.rm(disabled, { recursive: true, force: true });
+        report.changed.push(disabled);
+    }
 }
 async function blockDeprecatedSkillOverrides(projectRoot, root, report) {
     for (const overrideRoot of skillOverrideRoots(projectRoot, root)) {
@@ -274,12 +317,18 @@ function skillOverrideRoots(projectRoot, root) {
     return [
         {
             absolute: path.join(projectRoot, root, "ty-context-managed", "override_skills"),
-            relative: path.join(root, "ty-context-managed", "override_skills").split(path.sep).join("/")
+            relative: path
+                .join(root, "ty-context-managed", "override_skills")
+                .split(path.sep)
+                .join("/"),
         },
         {
             absolute: path.join(projectRoot, root, "pjsdlc_managed", "override_skills"),
-            relative: path.join(root, "pjsdlc_managed", "override_skills").split(path.sep).join("/")
-        }
+            relative: path
+                .join(root, "pjsdlc_managed", "override_skills")
+                .split(path.sep)
+                .join("/"),
+        },
     ];
 }
 async function syncFile(source, destination, report, missingMode) {
@@ -320,7 +369,9 @@ async function syncGithubWorkflow(source, destination, relativePath, report) {
         report.blocked.push(`${relativePath}: incomplete managed workflow markers`);
         return;
     }
-    if (markerState === "managed" || normalizeWorkflow(existing) === normalizeWorkflow(stripWorkflowMarkers(sourceContent))) {
+    if (markerState === "managed" ||
+        normalizeWorkflow(existing) ===
+            normalizeWorkflow(stripWorkflowMarkers(sourceContent))) {
         if (await writeTextIfChanged(destination, sourceContent)) {
             report.changed.push(relativePath);
         }
@@ -344,7 +395,8 @@ function workflowMarkerState(content) {
 function stripWorkflowMarkers(content) {
     return content
         .split(/\r?\n/)
-        .filter((line) => line.trim() !== GITHUB_WORKFLOW_BLOCK_START && line.trim() !== GITHUB_WORKFLOW_BLOCK_END)
+        .filter((line) => line.trim() !== GITHUB_WORKFLOW_BLOCK_START &&
+        line.trim() !== GITHUB_WORKFLOW_BLOCK_END)
         .join("\n");
 }
 function normalizeWorkflow(content) {

package/dist/lib/types.d.ts

@@ -3,10 +3,14 @@ export interface HarnessConfig {
         package: string;
         schema_version: string;
     };
+    profiles: {
+        enabled: HarnessProfile[];
+    };
     modularity?: HarnessModularityConfig;
     managed_files: ManagedFile[];
     never_overwrite: string[];
 }
+export type HarnessProfile = "core-portable" | "workflow-default" | "long-task";
 export interface HarnessModularityConfig {
     limit?: number;
     policy?: "scoped_waivers" | "strict_except_generated";
@@ -15,8 +19,11 @@ export interface HarnessModularityConfig {
 export interface ModularityWaiverConfig {
     path?: string;
     category?: string;
+    owner?: string;
+    introduced_at?: string;
     reason?: string;
-    future_split_boundary?: string;
+    tracking_issue?: string;
+    expiry_condition?: string;
 }
 export interface ManagedFile {
     path: string;

package/dist/lib/upgrade.js

@@ -1,5 +1,5 @@
 import { runDoctor } from "./doctor.js";
-import { createUpgradePlan, formatUpgradePlan, runMigrations } from "./migrations.js";
+import { createUpgradePlan, formatUpgradePlan, runMigrations, } from "./migrations.js";
 import { assertSupportedSchema } from "./schema-guard.js";
 import { runSync } from "./sync-engine.js";
 export class UpgradeBlockedError extends Error {
@@ -29,11 +29,12 @@ export async function runUpgradeReport(projectRoot) {
     }
     const migrationReport = await runMigrations(projectRoot, plan);
     lines.push(`migrations changed=${migrationReport.changed.length} skipped=${migrationReport.skipped.length} manual_required=${migrationReport.manualRequired.length} blocked=${migrationReport.blocked.length}`);
-    if (migrationReport.manualRequired.length > 0 || migrationReport.blocked.length > 0) {
+    if (migrationReport.manualRequired.length > 0 ||
+        migrationReport.blocked.length > 0) {
         lines.push(...formatUpgradePlan({
             safe_pending: [],
             manual_required: migrationReport.manualRequired,
-            blocked: migrationReport.blocked
+            blocked: migrationReport.blocked,
         }).slice(1));
     }
     const syncReport = await runSync(projectRoot);