glm-coding-router 0.1.0

package/dist/project/atomic-write.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Atomic file replacement (spec §22): write tmp → fsync → rename.
+ * On failure the original file is left untouched. Callers translate
+ * filesystem errors into their own actionable errors.
+ */
+export function atomicWriteFile(filePath, content) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${filePath}.glm-tmp-${process.pid}-${Date.now()}`;
+    const fd = fs.openSync(tmp, "w");
+    try {
+        fs.writeFileSync(fd, content, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, filePath);
+}

package/dist/project/managed-block.js

@@ -0,0 +1,100 @@
+import { Errors } from "../core/errors.js";
+export const START_MARKER = "<!-- glm-coding-router:start -->";
+export const END_MARKER = "<!-- glm-coding-router:end -->";
+export class ManagedBlockError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ManagedBlockError";
+    }
+}
+/** Detect the file's dominant EOL; default LF (spec §48). */
+function detectEol(content) {
+    const firstCr = content.indexOf("\r");
+    if (firstCr === -1)
+        return "\n";
+    const firstLf = content.indexOf("\n");
+    if (firstLf === -1)
+        return "\n";
+    return firstCr < firstLf - 1 ? "\n" : "\r\n";
+}
+function convertEol(text, eol) {
+    return eol === "\n" ? text.replace(/\r\n/g, "\n") : text.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n");
+}
+function countOccurrences(content, needle) {
+    return content.split(needle).length - 1;
+}
+/**
+ * Validate marker pairing (spec §48): on a malformed pair the caller must
+ * not modify the file and must surface an actionable error.
+ */
+export function validateMarkers(content, fileName) {
+    const starts = countOccurrences(content, START_MARKER);
+    const ends = countOccurrences(content, END_MARKER);
+    if (starts === 0 && ends === 0)
+        return;
+    if (starts > 1) {
+        throw Errors.managedBlockCorrupt(fileName, "multiple start markers");
+    }
+    if (ends > 1) {
+        throw Errors.managedBlockCorrupt(fileName, "multiple end markers");
+    }
+    if (starts === 1 && ends === 0) {
+        throw Errors.managedBlockCorrupt(fileName, "start marker without end marker");
+    }
+    if (starts === 0 && ends === 1) {
+        throw Errors.managedBlockCorrupt(fileName, "end marker without start marker");
+    }
+    if (content.indexOf(START_MARKER) > content.indexOf(END_MARKER)) {
+        throw Errors.managedBlockCorrupt(fileName, "end marker appears before start marker");
+    }
+}
+export function hasManagedBlock(content) {
+    return content.includes(START_MARKER) || content.includes(END_MARKER);
+}
+/**
+ * Insert or replace the managed block (spec §21):
+ * - absent  → append with a blank-line separator
+ * - present → replace in place, preserving everything outside the markers
+ * Idempotent: never duplicates, preserves the file's EOL style and
+ * trailing-newline state.
+ */
+export function upsertManagedBlock(content, block, fileName) {
+    validateMarkers(content, fileName);
+    const eol = detectEol(content);
+    const blockText = convertEol(block.trim(), eol);
+    if (content.includes(START_MARKER)) {
+        const startIdx = content.indexOf(START_MARKER);
+        const endIdx = content.indexOf(END_MARKER) + END_MARKER.length;
+        const prefix = content.slice(0, startIdx);
+        const suffix = content.slice(endIdx);
+        return prefix + blockText + suffix;
+    }
+    if (content.trim().length === 0) {
+        return blockText + eol;
+    }
+    const base = content.replace(/(?:\r?\n)+$/, "");
+    return base + eol + eol + blockText + eol;
+}
+/**
+ * Remove the managed block, preserving all user content (spec §43).
+ * A file that contained only the block becomes empty (""), letting callers
+ * decide whether to delete a router-created file.
+ */
+export function removeManagedBlock(content, fileName) {
+    validateMarkers(content, fileName);
+    if (!content.includes(START_MARKER)) {
+        return content;
+    }
+    const eol = detectEol(content);
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER) + END_MARKER.length;
+    const prefix = content.slice(0, startIdx).replace(/(?:\r?\n)+$/, "");
+    const suffix = content.slice(endIdx).replace(/^(?:\r?\n)+/, "");
+    if (prefix.length === 0 && suffix.length === 0)
+        return "";
+    if (prefix.length === 0)
+        return suffix;
+    if (suffix.length === 0)
+        return prefix + eol;
+    return prefix + eol + eol + suffix;
+}

package/dist/project/managed-file.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Errors } from "../core/errors.js";
+import { hasManagedBlock, removeManagedBlock, upsertManagedBlock } from "./managed-block.js";
+import { atomicWriteFile } from "./atomic-write.js";
+import { forgetFile, isOwnedFile, recordCreatedFile } from "./ownership.js";
+function toChange(file, created, oldContent, newContent, deleted = false) {
+    return {
+        file,
+        created,
+        changed: oldContent !== newContent || deleted,
+        oldContent,
+        newContent,
+        deleted: deleted,
+    };
+}
+/** Insert or replace the managed block in a file, atomically (spec §21, §22). */
+export function upsertManagedFile(options) {
+    const { file, block, home, dryRun } = options;
+    const fileName = path.basename(file);
+    const existed = fs.existsSync(file);
+    const oldContent = existed ? fs.readFileSync(file, "utf8") : "";
+    const newContent = upsertManagedBlock(oldContent, block, fileName);
+    if (!dryRun && newContent !== oldContent) {
+        try {
+            atomicWriteFile(file, newContent);
+        }
+        catch (cause) {
+            throw Errors.managedFileWriteFailed(file, cause instanceof Error ? cause.message : String(cause));
+        }
+        if (!existed) {
+            recordCreatedFile(file, home);
+        }
+    }
+    return toChange(file, !existed, oldContent, newContent);
+}
+/** Remove the managed block; delete router-created files that become empty (spec §43). */
+export function removeManagedFile(file, home, dryRun = false) {
+    const fileName = path.basename(file);
+    if (!fs.existsSync(file)) {
+        return toChange(file, false, "", "", false);
+    }
+    const oldContent = fs.readFileSync(file, "utf8");
+    if (!hasManagedBlock(oldContent)) {
+        return toChange(file, false, oldContent, oldContent, false);
+    }
+    const newContent = removeManagedBlock(oldContent, fileName);
+    const owned = isOwnedFile(file, home);
+    const emptyAfterRemove = newContent.length === 0;
+    if (dryRun) {
+        return toChange(file, false, oldContent, newContent, owned && emptyAfterRemove);
+    }
+    try {
+        if (emptyAfterRemove && owned) {
+            fs.rmSync(file);
+            forgetFile(file, home);
+            return toChange(file, false, oldContent, newContent, true);
+        }
+        if (newContent !== oldContent) {
+            atomicWriteFile(file, newContent);
+        }
+    }
+    catch (cause) {
+        throw Errors.managedFileWriteFailed(file, cause instanceof Error ? cause.message : String(cause));
+    }
+    return toChange(file, false, oldContent, newContent, false);
+}

package/dist/project/ownership.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ownershipPath } from "../core/paths.js";
+function readRecords(home) {
+    const file = ownershipPath(home);
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (raw && typeof raw.files === "object" && raw.files !== null) {
+            return { files: raw.files };
+        }
+    }
+    catch {
+        // Missing or corrupt metadata is non-fatal: fall back to empty.
+    }
+    return { files: {} };
+}
+function writeRecords(record, home) {
+    const file = ownershipPath(home);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(record, null, 2) + "\n", "utf8");
+    fs.renameSync(tmp, file);
+}
+export function recordCreatedFile(filePath, home) {
+    const normalized = path.resolve(filePath);
+    const records = readRecords(home);
+    if (normalized in records.files)
+        return;
+    records.files[normalized] = { createdAt: new Date().toISOString() };
+    writeRecords(records, home);
+}
+export function isOwnedFile(filePath, home) {
+    return path.resolve(filePath) in readRecords(home).files;
+}
+export function forgetFile(filePath, home) {
+    const normalized = path.resolve(filePath);
+    const records = readRecords(home);
+    if (!(normalized in records.files))
+        return;
+    delete records.files[normalized];
+    writeRecords(records, home);
+}

package/dist/project/project-root.js

@@ -0,0 +1,26 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { logger } from "../core/logging.js";
+/**
+ * Project root detection (spec §19):
+ *   git rev-parse --show-toplevel → cwd
+ */
+export function findProjectRoot(cwd = process.cwd()) {
+    try {
+        const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd,
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const root = output.trim();
+        if (root.length > 0) {
+            // git prints forward slashes on Windows; normalize for the platform.
+            return path.resolve(root);
+        }
+    }
+    catch (error) {
+        logger.debug(`git rev-parse failed (${error instanceof Error ? error.message : "unknown"}); using cwd`);
+    }
+    return cwd;
+}

package/dist/templates/agents-block.js

@@ -0,0 +1,46 @@
+/** Managed block content for AGENTS.md (spec §24). Keep in sync with the spec. */
+export const AGENTS_MANAGED_BLOCK = `<!-- glm-coding-router:start -->
+
+## GLM Worker Delegation
+
+Available commands:
+
+- \`glm-worker "<task>"\`
+- \`glm-review "<task>"\`
+
+Codex is the primary orchestrator.
+
+Delegate:
+- CRUD
+- boilerplate
+- tests
+- documentation
+- mechanical refactoring
+- repository exploration
+- straightforward implementation
+
+Keep in Codex:
+- requirements
+- planning
+- architecture
+- ambiguous business logic
+- complex debugging
+- security decisions
+- integration
+- final review
+
+Before delegation create a task packet:
+
+TASK
+SCOPE
+FILES ALLOWED TO MODIFY
+FILES NOT TO MODIFY
+REQUIREMENTS
+CONSTRAINTS
+ACCEPTANCE CRITERIA
+VALIDATION
+EXPECTED OUTPUT
+
+Never trust a worker's success report without inspecting the resulting changes.
+
+<!-- glm-coding-router:end -->`;

package/dist/templates/claude-block.js

@@ -0,0 +1,49 @@
+/** Managed block content for CLAUDE.md (spec §20). Keep in sync with the spec. */
+export const CLAUDE_MANAGED_BLOCK = `<!-- glm-coding-router:start -->
+
+## GLM Worker Delegation
+
+GLM workers available:
+
+- \`glm-worker "<task>"\`
+- \`glm-review "<task>"\`
+
+Delegate well-scoped, implementation-heavy work to GLM.
+
+Use GLM for:
+- repository exploration
+- CRUD
+- boilerplate
+- tests
+- documentation
+- mechanical refactoring
+- straightforward implementation
+
+Claude remains responsible for:
+- requirements
+- architecture
+- ambiguous business rules
+- security-sensitive decisions
+- complex debugging
+- integration
+- final review
+
+Before delegation, define:
+- task
+- scope
+- allowed files
+- forbidden files
+- requirements
+- constraints
+- acceptance criteria
+- validation command
+- expected output
+
+After worker completion:
+1. inspect the actual diff
+2. validate against requirements
+3. run relevant tests
+4. resolve integration problems
+5. accept only after verification
+
+<!-- glm-coding-router:end -->`;

package/dist/templates/glm-delegation-skill.js

@@ -0,0 +1,68 @@
+/** Codex skill definition (spec §26). Keep in sync with the spec. */
+export const GLM_DELEGATION_SKILL_NAME = "glm-delegation";
+export const GLM_DELEGATION_SKILL_MD = `---
+name: glm-delegation
+description: >
+  Delegate well-scoped implementation, testing,
+  repository exploration, boilerplate, CRUD,
+  documentation, and mechanical refactoring to
+  GLM Coding Plan workers.
+---
+
+# GLM Delegation
+
+Available commands:
+
+glm-worker "<task>"
+glm-review "<task>"
+
+## Use glm-review for
+
+- repository exploration
+- dependency analysis
+- locating implementations
+- call-chain discovery
+- code review
+
+## Use glm-worker for
+
+- CRUD
+- unit tests
+- implementation
+- documentation
+- repetitive changes
+- mechanical refactoring
+
+## Keep in primary Codex agent
+
+- requirements
+- architecture
+- ambiguous rules
+- security-sensitive design
+- difficult debugging
+- integration
+- final acceptance
+
+## Delegation packet
+
+Always provide:
+
+TASK
+SCOPE
+ALLOWED FILES
+FORBIDDEN FILES
+REQUIREMENTS
+CONSTRAINTS
+ACCEPTANCE CRITERIA
+VALIDATION
+EXPECTED OUTPUT
+
+## Verification
+
+After GLM finishes:
+
+- inspect the actual diff
+- independently run relevant validation
+- compare implementation with requirements
+- reject or correct worker output when needed
+`;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "glm-coding-router",
+  "version": "0.1.0",
+  "description": "GLM Coding Plan workers for Claude Code and Codex",
+  "type": "module",
+  "license": "MIT",
+  "author": "hieu9721",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hieu9721/GLM-coding-router.git"
+  },
+  "bin": {
+    "glm-router": "./dist/cli.js",
+    "glm-chat": "./dist/bin/glm-chat.js",
+    "glm-worker": "./dist/bin/glm-worker.js",
+    "glm-review": "./dist/bin/glm-review.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src tests",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "prompts": "^2.4.2",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.3",
+    "@types/prompts": "^2.4.9",
+    "eslint": "^9.39.5",
+    "tsx": "^4.23.13",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^5.0.1"
+  }
+}