project-tiny-context-harness 0.2.39

package/dist/commands/init.js

@@ -0,0 +1,108 @@
+import { stdin as input, stdout as output } from "node:process";
+import * as readline from "node:readline/promises";
+import { runInit } from "../lib/init.js";
+import { normalizeHarnessFolderName, readHarnessRootConfig } from "../lib/harness-root.js";
+import { writePackageHarnessRoot } from "../lib/package-json-config.js";
+import { DEFAULT_HARNESS_ROOT } from "../lib/paths.js";
+const AGENT_HARNESS_OPTIONS = [
+    { key: "codex", label: "Codex", harnessFolderName: ".codex" },
+    { key: "claude", label: "Claude Code", harnessFolderName: ".claude" },
+    { key: "cursor", label: "Cursor", harnessFolderName: ".cursor" },
+    { key: "cline", label: "Cline", harnessFolderName: ".cline" },
+    { key: "roo", label: "Roo Code", harnessFolderName: ".roo" },
+    { key: "gemini", label: "Gemini CLI", harnessFolderName: ".gemini" },
+    { key: "other", label: "Other" }
+];
+export async function init(args) {
+    const adopt = args.includes("--adopt");
+    const force = args.includes("--force");
+    const projectRoot = process.cwd();
+    const configuredRoot = await resolveInitHarnessRoot(projectRoot, args);
+    if (configuredRoot) {
+        await writePackageHarnessRoot(projectRoot, configuredRoot);
+        console.log(`configured package.json sdlcHarness.harnessFolderName=${JSON.stringify(configuredRoot)}`);
+    }
+    const report = await runInit(projectRoot, { adopt, force });
+    for (const line of report) {
+        console.log(line);
+    }
+}
+export async function resolveInitHarnessRoot(projectRoot, args) {
+    const argRoot = valueForArg(args, "--harness-folder") ?? valueForArg(args, "--harnessFolderName");
+    if (argRoot) {
+        return normalizeHarnessFolderName(argRoot);
+    }
+    const current = await readHarnessRootConfig(projectRoot);
+    if (current.source !== "default") {
+        return undefined;
+    }
+    return promptAgentHarnessRoot();
+}
+async function promptAgentHarnessRoot() {
+    if (!input.isTTY || !output.isTTY) {
+        return resolveAgentHarnessFolderName("");
+    }
+    const rl = readline.createInterface({ input, output });
+    try {
+        const agent = await questionUntilValid(rl, `${formatAgentChoices()}\nTarget agent (default 1 Codex): `);
+        const option = agentOptionForAnswer(agent);
+        if (option?.harnessFolderName) {
+            return normalizeHarnessFolderName(option.harnessFolderName);
+        }
+        const folder = await rl.question(`Harness folder name (default ${DEFAULT_HARNESS_ROOT}; press Enter to use default): `);
+        return normalizeHarnessFolderName(folder.trim() || DEFAULT_HARNESS_ROOT);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function questionUntilValid(rl, query) {
+    while (true) {
+        const answer = await rl.question(query);
+        if (agentOptionForAnswer(answer)) {
+            return answer;
+        }
+        console.log("Unknown agent choice. Enter a number, agent name, or Other.");
+    }
+}
+function formatAgentChoices() {
+    const lines = ["Choose target agent:"];
+    AGENT_HARNESS_OPTIONS.forEach((option, index) => {
+        const folder = option.harnessFolderName ? ` -> ${option.harnessFolderName}` : "";
+        lines.push(`${index + 1}) ${option.label}${folder}`);
+    });
+    return lines.join("\n");
+}
+export function resolveAgentHarnessFolderName(agentAnswer, customFolderAnswer = "") {
+    const option = agentOptionForAnswer(agentAnswer);
+    if (!option) {
+        throw new Error("Unknown agent choice");
+    }
+    return normalizeHarnessFolderName(option.harnessFolderName ?? (customFolderAnswer.trim() || DEFAULT_HARNESS_ROOT));
+}
+function agentOptionForAnswer(answer) {
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized) {
+        return AGENT_HARNESS_OPTIONS[0];
+    }
+    const index = Number.parseInt(normalized, 10);
+    if (Number.isInteger(index) && String(index) === normalized) {
+        return AGENT_HARNESS_OPTIONS[index - 1];
+    }
+    return AGENT_HARNESS_OPTIONS.find((option) => {
+        const label = option.label.toLowerCase();
+        return option.key === normalized || label === normalized || label.replace(/\s+/g, "-") === normalized;
+    });
+}
+function valueForArg(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg) => arg.startsWith(prefix));
+    if (inline) {
+        return inline.slice(prefix.length);
+    }
+    const index = args.indexOf(name);
+    if (index >= 0) {
+        return args[index + 1];
+    }
+    return undefined;
+}

package/dist/commands/package-source.d.ts

@@ -0,0 +1 @@
+export declare function packageSource(args: string[]): Promise<void>;

package/dist/commands/package-source.js

@@ -0,0 +1,24 @@
+import { checkSource, syncSource } from "../lib/package-source.js";
+export async function packageSource(args) {
+    const subcommand = args[0] ?? "help";
+    if (subcommand === "sync-source") {
+        const report = await syncSource(process.cwd());
+        console.log(`package sync-source changed=${report.changed.length}`);
+        return;
+    }
+    if (subcommand === "check-source") {
+        const report = await checkSource(process.cwd());
+        if (report.drift.length > 0) {
+            for (const item of report.drift) {
+                console.error(`drift: ${item}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        console.log("package source OK");
+        return;
+    }
+    console.log(`sdlc-harness package commands:
+  sync-source    Update package canonical assets from this source workspace
+  check-source   Verify package canonical assets match this source workspace`);
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1 @@
+export declare function sync(): Promise<void>;

package/dist/commands/sync.js

@@ -0,0 +1,14 @@
+import { runSync } from "../lib/sync-engine.js";
+export async function sync() {
+    const report = await runSync(process.cwd());
+    console.log(`sync changed=${report.changed.length} skipped=${report.skipped.length} blocked=${report.blocked.length}`);
+    for (const skipped of report.skipped.filter((line) => line.includes("customized"))) {
+        console.log(`skipped: ${skipped}`);
+    }
+    for (const blocked of report.blocked) {
+        console.error(`blocked: ${blocked}`);
+    }
+    if (report.blocked.length > 0) {
+        process.exitCode = 1;
+    }
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1 @@
+export declare function upgrade(): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,7 @@
+import { runUpgrade } from "../lib/upgrade.js";
+export async function upgrade() {
+    const report = await runUpgrade(process.cwd());
+    for (const line of report) {
+        console.log(line);
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1 @@
+export declare function validate(args: string[]): Promise<void>;

package/dist/commands/validate.js

@@ -0,0 +1,14 @@
+import { runValidator } from "../lib/validators.js";
+export async function validate(args) {
+    const gate = args[0] ?? "validate-harness";
+    const report = await runValidator(process.cwd(), gate);
+    for (const line of report.info) {
+        console.log(line);
+    }
+    for (const error of report.errors) {
+        console.error(`error: ${error}`);
+    }
+    if (report.errors.length > 0) {
+        process.exitCode = 1;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { commands } from "./commands/index.js";
+export type { HarnessConfig, ManagedFile, SourceMapping } from "./lib/types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { commands } from "./commands/index.js";

package/dist/lib/config.d.ts

@@ -0,0 +1,5 @@
+import type { HarnessConfig } from "./types.js";
+export declare function defaultConfig(root: string): HarnessConfig;
+export declare function readConfig(projectRoot: string): Promise<HarnessConfig>;
+export declare function writeConfigIfMissing(projectRoot: string): Promise<boolean>;
+export declare function normalizeConfig(value: Partial<HarnessConfig>, root?: string): HarnessConfig;

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+import path from "node:path";
+import { CANONICAL_CORE_PACKAGE, CURRENT_SCHEMA_VERSION } from "./constants.js";
+import { harnessConfigPath, harnessPath, harnessRoot } from "./harness-root.js";
+import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { parseYaml, stringifyYaml } from "./yaml.js";
+export function defaultConfig(root) {
+    return {
+        core: {
+            package: CANONICAL_CORE_PACKAGE,
+            schema_version: CURRENT_SCHEMA_VERSION
+        },
+        managed_files: [
+            { path: "AGENTS.md", strategy: "merge-block" },
+            { path: "Makefile", strategy: "merge-block" },
+            { path: harnessPath(root, "skills"), strategy: "managed" },
+            { path: harnessPath(root, "pjsdlc_managed", "context_templates"), strategy: "managed" },
+            { path: harnessPath(root, "pjsdlc_managed", "make", "sdlc-harness.mk"), strategy: "managed" },
+            { path: "tools", strategy: "managed" },
+            { path: ".github/workflows/harness.yml", strategy: "create-if-missing" }
+        ],
+        never_overwrite: ["project_context/**", "DESIGN.md", "src/**", "tests/**"]
+    };
+}
+export async function readConfig(projectRoot) {
+    const root = await harnessRoot(projectRoot);
+    const configPath = path.join(projectRoot, await harnessConfigPath(projectRoot));
+    if (!(await pathExists(configPath))) {
+        return defaultConfig(root);
+    }
+    const parsed = parseYaml(await readText(configPath));
+    return normalizeConfig(parsed, root);
+}
+export async function writeConfigIfMissing(projectRoot) {
+    const root = await harnessRoot(projectRoot);
+    const configPath = path.join(projectRoot, await harnessConfigPath(projectRoot));
+    if (await pathExists(configPath)) {
+        return false;
+    }
+    await writeTextIfChanged(configPath, stringifyYaml(defaultConfig(root)));
+    return true;
+}
+export function normalizeConfig(value, root = ".agent") {
+    const fallback = defaultConfig(root);
+    return {
+        core: {
+            package: value.core?.package ?? fallback.core.package,
+            schema_version: value.core?.schema_version ?? fallback.core.schema_version
+        },
+        managed_files: value.managed_files ?? fallback.managed_files,
+        never_overwrite: value.never_overwrite ?? fallback.never_overwrite
+    };
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const CANONICAL_CORE_PACKAGE = "project-tiny-context-harness";
+export declare const CURRENT_SCHEMA_VERSION = "4";
+export declare const CANONICAL_NPX_COMMAND = "npx --yes --package project-tiny-context-harness@latest sdlc-harness";

package/dist/lib/constants.js

@@ -0,0 +1,3 @@
+export const CANONICAL_CORE_PACKAGE = "project-tiny-context-harness";
+export const CURRENT_SCHEMA_VERSION = "4";
+export const CANONICAL_NPX_COMMAND = `npx --yes --package ${CANONICAL_CORE_PACKAGE}@latest sdlc-harness`;

package/dist/lib/context-export.d.ts

@@ -0,0 +1,21 @@
+export type ExportContextMode = "full" | "code";
+export interface ExportContextOptions {
+    full?: boolean;
+    code?: boolean;
+    output?: string;
+    check?: boolean;
+    now?: Date;
+}
+export interface ExportContextReport {
+    mode: ExportContextMode;
+    outputPath: string;
+    outputRelativePath: string;
+    sourceFiles: string[];
+    sourceContextCount: number;
+    sourceCodeCount?: number;
+    totalLines?: number;
+    totalCharacters?: number;
+    warnings: string[];
+    wrote: boolean;
+}
+export declare function runExportContext(projectRoot: string, options?: ExportContextOptions): Promise<ExportContextReport>;