aligndev 0.22.0 → 0.22.1

package/dist/config.js

@@ -1,21 +1,19 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { type } from "arktype";
 import { CODING_AGENTS, detectCodingAgents } from "./code/coding-agent.js";
 import { errorMessage } from "./errors.js";
+import { arrayOf, boolean, literal, nonEmptyString, object, optional, parseShape, string, } from "./json-shape.js";
 export const PLATFORMS = ["openclaw", "codingAgent"];
-const codeSchema = type({
-    "+": "reject",
-    "agent?": type.enumerated(...CODING_AGENTS),
-    "models?": "string[]",
-    "skipPermissions?": "boolean",
-    "unset?": "string[]",
+const codeShape = object({
+    agent: optional(literal(...CODING_AGENTS)),
+    models: optional(arrayOf(string)),
+    skipPermissions: optional(boolean),
+    unset: optional(arrayOf(string)),
 });
-const configSchema = type({
-    "+": "reject",
-    "platform?": type.enumerated(...PLATFORMS),
-    "projectsRoot?": "string > 0",
-    "code?": codeSchema,
+const configShape = object({
+    platform: optional(literal(...PLATFORMS)),
+    projectsRoot: optional(nonEmptyString),
+    code: optional(codeShape),
 });
 // An absent file is a normal state: every key takes its default.
 export function loadConfig(home) {
@@ -44,10 +42,7 @@ function parseConfigFile(path) {
     catch (error) {
         throw invalidConfig(path, errorMessage(error));
     }
-    const config = configSchema(value);
-    if (config instanceof type.errors)
-        throw invalidConfig(path, config.summary.split("\n", 1)[0]);
-    return config;
+    return parseShape(configShape, value, (detail) => invalidConfig(path, detail));
 }
 function invalidConfig(path, detail) {
     return new Error(`Error: invalid aligndev config ${path}: ${detail}`);

package/dist/json-shape.d.ts

@@ -0,0 +1,21 @@
+export type Check<T> = (value: unknown, path: string) => T;
+export interface OptionalField<T> {
+    optional: Check<T>;
+}
+type Fields<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? OptionalField<Exclude<T[K], undefined>> : Check<T[K]>;
+};
+/** Runs `check` at the root; a shape failure becomes `toError(<message>)`. */
+export declare function parseShape<T>(check: Check<T>, value: unknown, toError: (detail: string) => Error): T;
+/** Rejects the first unknown key, then checks each field in declaration order. */
+export declare function object<T extends object>(fields: Fields<T>): Check<T>;
+export declare function optional<T>(check: Check<T>): OptionalField<T>;
+export declare function literal<const T extends readonly (string | number)[]>(...values: T): Check<T[number]>;
+export declare function integerBetween(min: number, max: number): Check<number>;
+export declare function nonEmptyString(value: unknown, path: string): string;
+export declare function string(value: unknown, path: string): string;
+export declare function boolean(value: unknown, path: string): boolean;
+export declare function matching(pattern: RegExp): Check<string>;
+export declare function arrayOf<T>(check: Check<T>): Check<T[]>;
+export declare function nonEmptyArrayOf<T>(check: Check<T>): Check<T[]>;
+export {};

package/dist/json-shape.js

@@ -0,0 +1,115 @@
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+class ShapeError extends Error {
+}
+/** Runs `check` at the root; a shape failure becomes `toError(<message>)`. */
+export function parseShape(check, value, toError) {
+    try {
+        return check(value, "");
+    }
+    catch (error) {
+        if (error instanceof ShapeError)
+            throw toError(error.message);
+        throw error;
+    }
+}
+/** Rejects the first unknown key, then checks each field in declaration order. */
+export function object(fields) {
+    const entries = Object.entries(fields);
+    return (value, path) => {
+        if (!isPlainObject(value))
+            throw shapeError(path, "be an object");
+        const unknownKey = Object.keys(value).find((key) => !Object.hasOwn(fields, key));
+        if (unknownKey !== undefined)
+            throw shapeError(childPath(path, unknownKey), "be removed");
+        const result = {};
+        for (const [key, field] of entries) {
+            const fieldPath = childPath(path, key);
+            if (typeof field === "function")
+                result[key] = field(value[key], fieldPath);
+            else if (value[key] !== undefined)
+                result[key] = field.optional(value[key], fieldPath);
+        }
+        // The fields mirror T key by key.
+        return result;
+    };
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function childPath(path, key) {
+    if (!IDENTIFIER.test(key))
+        return bracketPath(path, JSON.stringify(key));
+    return path === "" ? key : `${path}.${key}`;
+}
+function bracketPath(path, segment) {
+    return `${path === "" ? "value" : path}[${segment}]`;
+}
+function shapeError(path, expectation) {
+    return new ShapeError(`${path === "" ? "value" : path} must ${expectation}`);
+}
+export function optional(check) {
+    return { optional: check };
+}
+export function literal(...values) {
+    const expectation = `be ${listOf(values.map((item) => JSON.stringify(item)))}`;
+    return (value, path) => {
+        const match = values.find((item) => item === value);
+        if (match === undefined)
+            throw shapeError(path, expectation);
+        return match;
+    };
+}
+function listOf(items) {
+    if (items.length === 1)
+        return items[0];
+    return `${items.slice(0, -1).join(", ")} or ${items.at(-1)}`;
+}
+export function integerBetween(min, max) {
+    return (value, path) => {
+        if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max)
+            throw shapeError(path, `be an integer from ${min} to ${max}`);
+        return value;
+    };
+}
+export function nonEmptyString(value, path) {
+    if (typeof value !== "string" || value.length === 0)
+        throw shapeError(path, "be a non-empty string");
+    return value;
+}
+export function string(value, path) {
+    if (typeof value !== "string")
+        throw shapeError(path, "be a string");
+    return value;
+}
+export function boolean(value, path) {
+    if (typeof value !== "boolean")
+        throw shapeError(path, "be a boolean");
+    return value;
+}
+export function matching(pattern) {
+    return (value, path) => {
+        const text = string(value, path);
+        if (!pattern.test(text))
+            throw shapeError(path, `match ${String(pattern)}`);
+        return text;
+    };
+}
+export function arrayOf(check) {
+    return (value, path) => {
+        if (!Array.isArray(value))
+            throw shapeError(path, "be an array");
+        return value.map((item, index) => check(item, bracketPath(path, String(index))));
+    };
+}
+export function nonEmptyArrayOf(check) {
+    const checkArray = arrayOf(check);
+    return (value, path) => {
+        const items = checkArray(value, path);
+        if (items.length === 0)
+            throw shapeError(path, "be a non-empty array");
+        return items;
+    };
+}

package/dist/project/layout.js

@@ -1,6 +1,6 @@
 import { runAlignfirst } from "../alignfirst-cli.js";
 import { errorMessage } from "../errors.js";
-const MIN_ALIGNFIRST_VERSION = "0.5.0";
+const MIN_ALIGNFIRST_VERSION = "0.9.0";
 export function readProjectReport(command, cwd, env) {
     const result = runAlignfirst(command, ["config", "--json"], cwd, env);
     if (result.status !== 0) {
@@ -14,16 +14,24 @@ export function readProjectReport(command, cwd, env) {
     catch (error) {
         throw new Error(`Invalid alignfirst config report for ${cwd}: ${errorMessage(error)}`);
     }
+    if (isOutdatedReport(value))
+        return { error: outdatedAlignfirst(cwd) };
     return parseProjectReport(value, cwd);
 }
 function firstLine(value) {
     return value.trim().split("\n", 1)[0] ?? "";
 }
+// Before alignfirst 0.9.0, the report had no `.alignfirst-instructions` location.
+function isOutdatedReport(value) {
+    return (isRecord(value) && !(isRecord(value.locations) && ".alignfirst-instructions" in value.locations));
+}
+function outdatedAlignfirst(path) {
+    return (`The alignfirst CLI used in ${path} is too old: aligndev requires alignfirst ` +
+        `${MIN_ALIGNFIRST_VERSION} or later.`);
+}
 function parseProjectReport(value, path) {
     if (!isRecord(value))
         throw invalidReport(path);
-    if (value.source === "root" || value.locations === undefined)
-        throw outdatedAlignfirst(path);
     return {
         source: parseSource(value.source, path),
         cli: parseCli(value.cli, path),
@@ -109,10 +117,6 @@ function parseLocation(value, path) {
 function invalidReport(path) {
     return new Error(`Invalid alignfirst config report for ${path}`);
 }
-function outdatedAlignfirst(path) {
-    return new Error(`The alignfirst CLI used in ${path} is too old: aligndev requires alignfirst ` +
-        `${MIN_ALIGNFIRST_VERSION} or later.`);
-}
 function isPortRange(value) {
     return isRecord(value) && typeof value.first === "number" && typeof value.last === "number";
 }

package/dist/project/markers.js

@@ -1,20 +1,18 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { type } from "arktype";
 import { errorMessage } from "../errors.js";
+import { integerBetween, matching, nonEmptyArrayOf, object, optional, parseShape, string, } from "../json-shape.js";
 import { formatRange } from "./format.js";
 export const MARKER_FILENAME = ".alignfirst-projects.json";
-const markerPortRangeSchema = type({
-    "+": "reject",
-    first: "1 <= number.integer <= 65535",
-    last: "1 <= number.integer <= 65535",
-    "code?": /^[a-z][a-z0-9-]*$/,
-    "description?": "string",
+const markerPortRangeShape = object({
+    first: integerBetween(1, 65_535),
+    last: integerBetween(1, 65_535),
+    code: optional(matching(/^[a-z][a-z0-9-]*$/)),
+    description: optional(string),
 });
-const markerSchema = type({
-    "+": "reject",
-    "description?": "string",
-    "portRanges?": markerPortRangeSchema.array().atLeastLength(1),
+const markerShape = object({
+    description: optional(string),
+    portRanges: optional(nonEmptyArrayOf(markerPortRangeShape)),
 });
 export function readMarker(dir) {
     const path = join(dir, MARKER_FILENAME);
@@ -27,10 +25,7 @@ export function readMarker(dir) {
     catch (error) {
         throw invalidMarker(path, errorMessage(error));
     }
-    const marker = markerSchema(value);
-    if (marker instanceof type.errors) {
-        throw invalidMarker(path, marker.summary.split("\n", 1)[0]);
-    }
+    const marker = parseShape(markerShape, value, (detail) => invalidMarker(path, detail));
     if (marker.portRanges !== undefined)
         assertValidPortRanges(marker.portRanges, path);
     return marker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aligndev",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "license": "CC0-1.0",
   "author": "Thomas MUR",
   "description": "The AlignDev CLI: the assistant's playbook, coding-agent delegation, and project inventory.",
@@ -37,9 +37,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "arktype": "^2.2.3"
-  },
   "devDependencies": {
     "@types/node": "~24.13.3",
     "rimraf": "~6.1.3",

package/templates/guide/code.md

@@ -159,17 +159,17 @@ Run the chain end to end. The plan is a step of the implementation, not a checkp
 
 ### Where the plan runs
 
-Planning in the spec's own session is cheaper: the agent already holds the investigation. That advantage ends once the session fills up, because the spec discussion competes with the planning work for the same context window. `contextTokens` in the `{{ALIGNDEV}} code status` output is the measure; the threshold is **150k**.
+Planning in the spec's own session is cheaper: the agent already holds the investigation. That advantage ends once the session fills up, because the spec discussion competes with the planning work for the same context window. `contextTokens` in the `{{ALIGNDEV}} code status` output is the measure; the threshold is **160k**.
 
 Read `contextCompacted` first. When it is `true`, the agent compacted the conversation: the investigation now survives only as a summary, so the advantage of staying is already gone. Plan in a fresh session whatever `contextTokens` says. Treat an empty `contextTokens` the same way — `contextTokensError` says why the figure is missing, and an unknown occupancy is not a reason to gamble on staying.
 
-**Below 150k — plan in the spec session.** Send the protocol with no message:
+**Below 160k — plan in the spec session.** Send the protocol with no message:
 
 ```bash
 {{ALIGNDEV}} code resume <sessionId> --protocol plan
 ```
 
-**At or above 150k — make the spec stand alone, then plan in a fresh session.** The next session reads the spec file and nothing else, so the spec must carry every decision the discussion settled. Ask for that first, in the session that holds the discussion:
+**At or above 160k — make the spec stand alone, then plan in a fresh session.** The next session reads the spec file and nothing else, so the spec must carry every decision the discussion settled. Ask for that first, in the session that holds the discussion:
 
 ```bash
 {{ALIGNDEV}} code resume <sessionId> --message "Ensure this spec is self-sufficient: another session will write the plans from it."