@meetless/mla 0.1.4

package/dist/lib/workspace.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkerMissingWorkspaceIdError = exports.NotActivatedError = void 0;
+exports.findWorkspaceContext = findWorkspaceContext;
+exports.resolveWorkspaceContext = resolveWorkspaceContext;
+exports.resolveWorkspaceId = resolveWorkspaceId;
+exports.tryResolveWorkspaceId = tryResolveWorkspaceId;
+exports.resolveWorkspaceIdWithEnv = resolveWorkspaceIdWithEnv;
+const activation_1 = require("./activation");
+// Folder = workspace (notes/20260604-folder-equals-workspace-binding-design.md,
+// T1.1). The single shared resolver for "which workspace is this directory bound
+// to?". It walks UP from a start dir to the nearest `.meetless.json` marker
+// (nearest-wins, mirroring how Claude Code resolves CLAUDE.md and how the bash
+// gate `meetless_activated` behaves) and returns the marker's workspaceId.
+//
+// The marker is the ONLY source of the workspaceId. There is no cli-config
+// fallback: cli-config carries machine creds (controlUrl, controlToken, actor),
+// never the per-folder workspace binding. A directory with no usable marker is
+// "not activated" and workspace-scoped commands refuse with a clear pointer to
+// `mla activate`.
+class NotActivatedError extends Error {
+    startDir;
+    constructor(startDir) {
+        super(`No Meetless workspace is activated for this directory ` +
+            `(${startDir}). Run 'mla activate' here to bind this repository to a ` +
+            `workspace. Meetless resolves the workspace from the nearest ` +
+            `.meetless.json, walking up from the current directory.`);
+        this.startDir = startDir;
+        this.name = "NotActivatedError";
+    }
+}
+exports.NotActivatedError = NotActivatedError;
+class MarkerMissingWorkspaceIdError extends Error {
+    markerPath;
+    constructor(markerPath) {
+        super(`The Meetless marker at ${markerPath} has no usable workspaceId ` +
+            `(missing or malformed). Re-run 'mla activate' to repair the binding.`);
+        this.markerPath = markerPath;
+        this.name = "MarkerMissingWorkspaceIdError";
+    }
+}
+exports.MarkerMissingWorkspaceIdError = MarkerMissingWorkspaceIdError;
+// Non-throwing lookup: returns the resolved context, or null when no usable
+// marker exists up the tree (no marker at all, or a marker with no workspaceId).
+// Use this on best-effort paths (CLI bootstrap trace flush, prefetch) that must
+// degrade silently rather than fail a non-workspace command.
+function findWorkspaceContext(startDir = process.cwd()) {
+    const found = (0, activation_1.findActivation)(startDir);
+    if (!found || !found.workspaceId)
+        return null;
+    return {
+        workspaceId: found.workspaceId,
+        workspaceName: found.workspaceName,
+        markerPath: found.path,
+        markerDir: found.dir,
+    };
+}
+// Throwing lookup for command bodies that REQUIRE an activated workspace.
+// Distinguishes "no marker" (NotActivatedError) from "marker present but no
+// usable workspaceId" (MarkerMissingWorkspaceIdError) so callers and `mla
+// doctor` / `mla workspace show` can report a stale binding precisely.
+function resolveWorkspaceContext(startDir = process.cwd()) {
+    const found = (0, activation_1.findActivation)(startDir);
+    if (!found)
+        throw new NotActivatedError(startDir);
+    if (!found.workspaceId)
+        throw new MarkerMissingWorkspaceIdError(found.path);
+    return {
+        workspaceId: found.workspaceId,
+        workspaceName: found.workspaceName,
+        markerPath: found.path,
+        markerDir: found.dir,
+    };
+}
+function resolveWorkspaceId(startDir = process.cwd()) {
+    return resolveWorkspaceContext(startDir).workspaceId;
+}
+function tryResolveWorkspaceId(startDir = process.cwd()) {
+    const ctx = findWorkspaceContext(startDir);
+    return ctx ? ctx.workspaceId : null;
+}
+// Shared resolver for commands that require a workspace: checks the
+// MEETLESS_WORKSPACE_ID env var first (operator override), then walks up from
+// process.cwd() via tryResolveWorkspaceId to the nearest .meetless.json marker.
+// Returns undefined when neither source yields an id. Never throws.
+function resolveWorkspaceIdWithEnv() {
+    const envWs = (process.env.MEETLESS_WORKSPACE_ID ?? "").trim();
+    if (envWs)
+        return envWs;
+    try {
+        return tryResolveWorkspaceId() ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/zip.js

@@ -0,0 +1,154 @@
+"use strict";
+// Zero-dependency, store-only (uncompressed) ZIP writer + reader.
+//
+// The mla CLI deliberately keeps a tiny dependency surface (Phase 4.5 OSS
+// hardening: only @sentry/node + the workspace trace-core). The Phase 5 debug
+// bundle (gap 6.7) needs to emit a single .zip; pulling in archiver/adm-zip just
+// for that would undo that hardening. A store-only ZIP is a small, well-specified
+// container (PKWARE APPNOTE: local file header + central directory + end-of-
+// central-directory), so we hand-roll it here with only Node built-ins.
+//
+// "Store" means no compression: the file bytes appear verbatim. That is fine for
+// a debug bundle (text + small JSON) and removes the only part of the spec that
+// would need zlib stream plumbing. CRC-32 is still required by the format and is
+// implemented below; readStoredZip verifies it on read so a corrupt bundle is
+// caught rather than silently opened.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32 = crc32;
+exports.createZip = createZip;
+exports.readStoredZip = readStoredZip;
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// Fixed DOS timestamp (1980-01-01 00:00:00, the ZIP epoch). Deterministic by
+// design: the bundle's real created-at lives in manifest.json, and a fixed entry
+// time keeps two bundles of the same inputs byte-identical (easier to test and
+// to diff). Avoids any reliance on a wall clock in the archive layer.
+const DOS_DATE = 0x0021; // year=1980, month=1, day=1
+const DOS_TIME = 0x0000;
+const CRC_TABLE = (() => {
+    const table = new Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+// Build a store-only ZIP archive from the given entries. Names use forward
+// slashes (the ZIP convention) and are encoded UTF-8.
+function createZip(entries) {
+    const localChunks = [];
+    const centralChunks = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const nameBuf = Buffer.from(entry.name.replace(/\\/g, "/"), "utf8");
+        const data = entry.data;
+        const crc = crc32(data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(LOCAL_FILE_HEADER_SIG, 0);
+        local.writeUInt16LE(20, 4); // version needed (2.0)
+        local.writeUInt16LE(0x0800, 6); // flags: bit 11 = UTF-8 names
+        local.writeUInt16LE(0, 8); // method: 0 = store
+        local.writeUInt16LE(DOS_TIME, 10);
+        local.writeUInt16LE(DOS_DATE, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(data.length, 18); // compressed size == size (store)
+        local.writeUInt32LE(data.length, 22); // uncompressed size
+        local.writeUInt16LE(nameBuf.length, 26);
+        local.writeUInt16LE(0, 28); // extra field length
+        localChunks.push(local, nameBuf, data);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(CENTRAL_DIR_SIG, 0);
+        central.writeUInt16LE(20, 4); // version made by
+        central.writeUInt16LE(20, 6); // version needed
+        central.writeUInt16LE(0x0800, 8); // flags: UTF-8
+        central.writeUInt16LE(0, 10); // method: store
+        central.writeUInt16LE(DOS_TIME, 12);
+        central.writeUInt16LE(DOS_DATE, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(data.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(nameBuf.length, 28);
+        central.writeUInt16LE(0, 30); // extra length
+        central.writeUInt16LE(0, 32); // comment length
+        central.writeUInt16LE(0, 34); // disk number start
+        central.writeUInt16LE(0, 36); // internal attrs
+        central.writeUInt32LE(0, 38); // external attrs
+        central.writeUInt32LE(offset, 42); // local header offset
+        centralChunks.push(central, nameBuf);
+        offset += local.length + nameBuf.length + data.length;
+    }
+    const centralDir = Buffer.concat(centralChunks);
+    const localData = Buffer.concat(localChunks);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(END_OF_CENTRAL_DIR_SIG, 0);
+    eocd.writeUInt16LE(0, 4); // disk number
+    eocd.writeUInt16LE(0, 6); // disk with central dir
+    eocd.writeUInt16LE(entries.length, 8); // entries on this disk
+    eocd.writeUInt16LE(entries.length, 10); // total entries
+    eocd.writeUInt32LE(centralDir.length, 12); // central dir size
+    eocd.writeUInt32LE(localData.length, 16); // central dir offset
+    eocd.writeUInt16LE(0, 20); // comment length
+    return Buffer.concat([localData, centralDir, eocd]);
+}
+// Parse a store-only ZIP produced by createZip back into its entries, verifying
+// each entry's CRC-32. Throws on a malformed archive or a CRC mismatch. Used by
+// the debug-bundle tests for a real round-trip and available for self-verify.
+function readStoredZip(buf) {
+    // Locate the end-of-central-directory record (no trailing comment, so it is
+    // the last 22 bytes for archives we produce).
+    let eocdOffset = -1;
+    for (let i = buf.length - 22; i >= 0; i--) {
+        if (buf.readUInt32LE(i) === END_OF_CENTRAL_DIR_SIG) {
+            eocdOffset = i;
+            break;
+        }
+    }
+    if (eocdOffset < 0) {
+        throw new Error("readStoredZip: end-of-central-directory record not found");
+    }
+    const total = buf.readUInt16LE(eocdOffset + 10);
+    let p = buf.readUInt32LE(eocdOffset + 16); // central dir offset
+    const entries = [];
+    for (let n = 0; n < total; n++) {
+        if (buf.readUInt32LE(p) !== CENTRAL_DIR_SIG) {
+            throw new Error("readStoredZip: bad central directory signature");
+        }
+        const method = buf.readUInt16LE(p + 10);
+        if (method !== 0) {
+            throw new Error(`readStoredZip: unsupported method ${method} (store only)`);
+        }
+        const crc = buf.readUInt32LE(p + 16);
+        const size = buf.readUInt32LE(p + 24);
+        const nameLen = buf.readUInt16LE(p + 28);
+        const extraLen = buf.readUInt16LE(p + 30);
+        const commentLen = buf.readUInt16LE(p + 32);
+        const localOffset = buf.readUInt32LE(p + 42);
+        const name = buf.toString("utf8", p + 46, p + 46 + nameLen);
+        // Walk into the local header to find the data start (its name/extra lengths
+        // can differ from the central record's, so read them locally).
+        if (buf.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER_SIG) {
+            throw new Error("readStoredZip: bad local file header signature");
+        }
+        const localNameLen = buf.readUInt16LE(localOffset + 26);
+        const localExtraLen = buf.readUInt16LE(localOffset + 28);
+        const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+        const data = buf.subarray(dataStart, dataStart + size);
+        if (crc32(data) !== crc) {
+            throw new Error(`readStoredZip: CRC mismatch for ${name}`);
+        }
+        entries.push({ name, data: Buffer.from(data) });
+        p += 46 + nameLen + extraLen + commentLen;
+    }
+    return entries;
+}

package/dist/pretool-entry.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPretoolEntry = runPretoolEntry;
+// The minimal PreToolUse entrypoint (latency lever A,
+// notes/20260615-rules-as-node-and-action-interception-consolidated-proposal.md).
+//
+// The managed pre-tool-use.sh hook runs THIS file (`node dist/pretool-entry.js`)
+// directly instead of `mla _internal pretool-observe`. Both call the very same
+// runInternalPretoolObserve core, so the deny decision is byte-identical; the only
+// difference is the require graph. cli.js eagerly pulls all 30+ command modules
+// (~150ms cold). This entry's transitive closure is only the ce0 store + the
+// rules/scanner deny path (~12ms cold), a ~10x cold-start cut on the Write/Edit hot
+// path. When this file is absent (a pkg binary, an older install), the hook falls
+// back to `mla _internal pretool-observe`, so the slow path stays correct.
+//
+// It is a thin IO shell: read the decision via stdin (the core does it), forward the
+// core's exit code, and fail OPEN (exit 0) on any unexpected rejection so an
+// entrypoint fault can never escalate into a blocking hook decision.
+const internal_pretool_observe_1 = require("./commands/internal-pretool-observe");
+/**
+ * Run the observe core with no argv (the PreToolUse payload arrives on stdin, not in
+ * args) and forward its exit code. The core already fails open internally to exit 0;
+ * the catch here is the belt-and-suspenders guard for an unexpected throw before the
+ * promise settles, preserving the "never block a tool" invariant at the process edge.
+ */
+async function runPretoolEntry(observe = internal_pretool_observe_1.runInternalPretoolObserve, exit = (code) => process.exit(code)) {
+    try {
+        exit(await observe([]));
+    }
+    catch {
+        exit(0);
+    }
+}
+if (require.main === module) {
+    void runPretoolEntry();
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@meetless/mla",
+  "version": "0.1.4",
+  "license": "Apache-2.0",
+  "private": false,
+  "description": "Meetless CLI (mla): governed change-control and knowledge for AI coding agents.",
+  "keywords": [
+    "meetless",
+    "mla",
+    "cli",
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "mcp",
+    "governance",
+    "knowledge-base"
+  ],
+  "homepage": "https://meetless.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Meetless/mla.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Meetless/mla/issues"
+  },
+  "author": "Meetless",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "mla": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "pkg": {
+    "assets": [
+      "dist/hooks-template/**/*",
+      "dist/build-info.json"
+    ],
+    "scripts": [
+      "dist/**/*.js"
+    ]
+  },
+  "dependencies": {
+    "@sentry/node": "^10.39.0",
+    "better-sqlite3": "^11.8.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.30",
+    "@yao-pkg/pkg": "^6.3.0",
+    "esbuild": "^0.28.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5",
+    "@meetless/mcp": "0.1.0",
+    "@meetless/trace-core": "0.1.0",
+    "@meetless/ask-core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js && node scripts/gen-build-info.js && node scripts/bundle-esm.js && chmod +x dist/cli.js dist/pretool-entry.js",
+    "dev": "ts-node src/cli.ts",
+    "start": "node dist/cli.js",
+    "test": "jest --config jest.config.js",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}