@aipper/aiws 0.0.28 → 0.0.30

package/src/hash.js

@@ -1,25 +0,0 @@
-import crypto from "node:crypto";
-import { readText } from "./fs.js";
-
-/**
- * @param {string} s
- */
-export function normalizeNewlines(s) {
-  return s.replaceAll("\r\n", "\n");
-}
-
-/**
- * @param {string} text
- */
-export function sha256Text(text) {
-  return crypto.createHash("sha256").update(text, "utf8").digest("hex");
-}
-
-/**
- * @param {string} filePath
- */
-export async function sha256FileText(filePath) {
-  const content = normalizeNewlines(await readText(filePath));
-  return sha256Text(content);
-}
-

package/src/json-schema-lite.js

@@ -1,164 +0,0 @@
-import { UserError } from "./errors.js";
-
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function joinPath(base, segment) {
-  if (!base || base === "$") return `$${segment}`;
-  return `${base}${segment}`;
-}
-
-function resolvePointer(rootSchema, ref) {
-  if (typeof ref !== "string" || !ref.startsWith("#/")) {
-    throw new UserError("Unsupported schema $ref.", { details: String(ref || "") });
-  }
-  const parts = ref
-    .slice(2)
-    .split("/")
-    .map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let cur = rootSchema;
-  for (const part of parts) {
-    if (!isPlainObject(cur) && !Array.isArray(cur)) return undefined;
-    cur = cur[part];
-  }
-  return cur;
-}
-
-function typeMatches(value, type) {
-  switch (type) {
-    case "object":
-      return isPlainObject(value);
-    case "array":
-      return Array.isArray(value);
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    default:
-      return true;
-  }
-}
-
-/**
- * @param {any} value
- * @param {any} schema
- * @param {any} rootSchema
- * @param {string} curPath
- * @param {string[]} errors
- */
-function validateNode(value, schema, rootSchema, curPath, errors) {
-  if (!isPlainObject(schema)) return;
-
-  if (schema.$ref) {
-    const target = resolvePointer(rootSchema, schema.$ref);
-    if (!target) {
-      errors.push(`${curPath}: unresolved $ref ${schema.$ref}`);
-      return;
-    }
-    validateNode(value, target, rootSchema, curPath, errors);
-    return;
-  }
-
-  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-    const matched = schema.anyOf.some((candidate) => {
-      const branchErrors = [];
-      validateNode(value, candidate, rootSchema, curPath, branchErrors);
-      return branchErrors.length === 0;
-    });
-    if (!matched) errors.push(`${curPath}: does not match anyOf`);
-  }
-
-  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-    for (const candidate of schema.allOf) validateNode(value, candidate, rootSchema, curPath, errors);
-  }
-
-  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let matches = 0;
-    for (const candidate of schema.oneOf) {
-      const branchErrors = [];
-      validateNode(value, candidate, rootSchema, curPath, branchErrors);
-      if (branchErrors.length === 0) matches += 1;
-    }
-    if (matches !== 1) errors.push(`${curPath}: does not match exactly one schema`);
-  }
-
-  if (schema.type && !typeMatches(value, schema.type)) {
-    errors.push(`${curPath}: expected ${schema.type}`);
-    return;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(schema, "const") && value !== schema.const) {
-    errors.push(`${curPath}: expected const ${JSON.stringify(schema.const)}`);
-  }
-
-  if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
-    errors.push(`${curPath}: expected one of ${schema.enum.map((item) => JSON.stringify(item)).join(", ")}`);
-  }
-
-  if (typeof value === "string") {
-    if (typeof schema.minLength === "number" && value.length < schema.minLength) {
-      errors.push(`${curPath}: expected minLength ${schema.minLength}`);
-    }
-    if (typeof schema.pattern === "string") {
-      const re = new RegExp(schema.pattern);
-      if (!re.test(value)) errors.push(`${curPath}: does not match pattern ${schema.pattern}`);
-    }
-  }
-
-  if (Array.isArray(value)) {
-    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-      errors.push(`${curPath}: expected minItems ${schema.minItems}`);
-    }
-    if (schema.items) {
-      value.forEach((item, index) => validateNode(item, schema.items, rootSchema, joinPath(curPath, `[${index}]`), errors));
-    }
-  }
-
-  if (isPlainObject(value)) {
-    const entries = Object.keys(value);
-    if (typeof schema.minProperties === "number" && entries.length < schema.minProperties) {
-      errors.push(`${curPath}: expected minProperties ${schema.minProperties}`);
-    }
-    if (typeof schema.maxProperties === "number" && entries.length > schema.maxProperties) {
-      errors.push(`${curPath}: expected maxProperties ${schema.maxProperties}`);
-    }
-    const properties = isPlainObject(schema.properties) ? schema.properties : {};
-    const required = Array.isArray(schema.required) ? schema.required : [];
-    for (const key of required) {
-      if (!Object.prototype.hasOwnProperty.call(value, key)) errors.push(`${curPath}: missing required property ${key}`);
-    }
-    for (const [key, childSchema] of Object.entries(properties)) {
-      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
-      validateNode(value[key], childSchema, rootSchema, joinPath(curPath, `.${key}`), errors);
-    }
-    if (schema.additionalProperties === false) {
-      for (const key of entries) {
-        if (!Object.prototype.hasOwnProperty.call(properties, key)) {
-          errors.push(`${curPath}: unexpected property ${key}`);
-        }
-      }
-    }
-  }
-}
-
-/**
- * @param {any} value
- * @param {any} schema
- * @param {{ source: string }} options
- */
-export function validateJsonSchemaLite(value, schema, options) {
-  const errors = [];
-  validateNode(value, schema, schema, "$", errors);
-  if (errors.length > 0) {
-    throw new UserError("Spec doc schema validation failed.", {
-      details: [options?.source || "", ...errors].filter(Boolean).join("\n"),
-    });
-  }
-}

package/src/managed-blocks.js

@@ -1,131 +0,0 @@
-import { normalizeNewlines, sha256Text } from "./hash.js";
-import { UserError } from "./errors.js";
-
-/**
- * @param {string} s
- * @returns {string}
- */
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * @param {string} text
- * @param {string} blockId
- * @returns {{ beginLineIndex: number, endLineIndex: number, innerText: string, beginLine: string, endLine: string } | null}
- */
-export function findManagedBlock(text, blockId) {
-  const t = normalizeNewlines(text);
-  const lines = t.split("\n");
-  const beginRe = new RegExp(`AIWS_MANAGED_BEGIN:${escapeRegExp(blockId)}(?:\\s|$|-->)`);
-  const endRe = new RegExp(`AIWS_MANAGED_END:${escapeRegExp(blockId)}(?:\\s|$|-->)`);
-
-  let beginLineIndex = -1;
-  let endLineIndex = -1;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (beginLineIndex === -1 && beginRe.test(lines[i] ?? "")) {
-      beginLineIndex = i;
-      continue;
-    }
-    if (beginLineIndex !== -1 && endRe.test(lines[i] ?? "")) {
-      endLineIndex = i;
-      break;
-    }
-  }
-
-  if (beginLineIndex === -1 || endLineIndex === -1 || endLineIndex <= beginLineIndex) return null;
-
-  const innerLines = lines.slice(beginLineIndex + 1, endLineIndex);
-  let innerText = innerLines.join("\n");
-  if (innerLines.length > 0) innerText += "\n";
-
-  return {
-    beginLineIndex,
-    endLineIndex,
-    innerText,
-    beginLine: lines[beginLineIndex] ?? "",
-    endLine: lines[endLineIndex] ?? "",
-  };
-}
-
-/**
- * Extract the canonical block chunk (begin+inner+end) from a template file.
- *
- * @param {string} templateText
- * @param {string} blockId
- * @returns {{ blockChunk: string, innerText: string }}
- */
-export function extractTemplateBlock(templateText, blockId) {
-  const t = normalizeNewlines(templateText);
-  const block = findManagedBlock(t, blockId);
-  if (!block) {
-    throw new UserError(`Template is missing managed block: ${blockId}`, { exitCode: 1 });
-  }
-  const blockChunk = `${block.beginLine}\n${block.innerText}${block.endLine}\n`;
-  return { blockChunk, innerText: block.innerText };
-}
-
-/**
- * @param {string} targetText
- * @param {string} blockId
- * @param {string} newInnerText normalized; may end with "\n"
- * @param {{ insertIfMissing: boolean, templateBlockChunk?: string } } options
- * @returns {{ nextText: string, changed: boolean, inserted: boolean }}
- */
-export function upsertManagedBlock(targetText, blockId, newInnerText, options) {
-  const original = normalizeNewlines(targetText);
-  const block = findManagedBlock(original, blockId);
-  if (!block) {
-    if (!options.insertIfMissing) {
-      throw new UserError(`Missing managed block: ${blockId}`);
-    }
-    if (!options.templateBlockChunk) {
-      throw new UserError(`Cannot insert managed block without template chunk: ${blockId}`, { exitCode: 1 });
-    }
-    const nextText = insertBlockAtTop(original, options.templateBlockChunk);
-    return { nextText, changed: true, inserted: true };
-  }
-
-  const lines = original.split("\n");
-  const begin = lines.slice(0, block.beginLineIndex + 1);
-  const end = lines.slice(block.endLineIndex);
-
-  const innerLines = newInnerText.endsWith("\n") ? newInnerText.slice(0, -1).split("\n") : newInnerText.split("\n");
-  const rebuilt = [...begin, ...innerLines, ...end].join("\n");
-
-  return { nextText: rebuilt, changed: rebuilt !== original, inserted: false };
-}
-
-/**
- * Insert block chunk near the top with minimal disruption:
- * - If the file starts with a Markdown heading (`# ...`), insert after the first line.
- * - Otherwise, insert at the very top.
- *
- * @param {string} text normalized
- * @param {string} blockChunk normalized; should end with "\n"
- */
-function insertBlockAtTop(text, blockChunk) {
-  const t = normalizeNewlines(text);
-  const chunk = normalizeNewlines(blockChunk).endsWith("\n") ? normalizeNewlines(blockChunk) : `${normalizeNewlines(blockChunk)}\n`;
-
-  const lines = t.split("\n");
-  if (lines.length > 0 && (lines[0] ?? "").startsWith("# ")) {
-    const after = lines.slice(1).join("\n");
-    const head = `${lines[0]}\n`;
-    return `${head}\n${chunk}\n${after}`.replace(/\n{3,}/g, "\n\n");
-  }
-  return `${chunk}\n${t}`.replace(/\n{3,}/g, "\n\n");
-}
-
-/**
- * @param {string} text
- * @param {string} blockId
- */
-export function hashManagedBlockInner(text, blockId) {
-  const block = findManagedBlock(text, blockId);
-  if (!block) {
-    throw new UserError(`Missing managed block: ${blockId}`);
-  }
-  return sha256Text(block.innerText);
-}

package/src/manifest.js

@@ -1,153 +0,0 @@
-import path from "node:path";
-import { normalizeNewlines, sha256FileText, sha256Text } from "./hash.js";
-import { joinRel, normalizeRel } from "./path-utils.js";
-import { pathExists, readText, writeText } from "./fs.js";
-import { findManagedBlock } from "./managed-blocks.js";
-import { UserError } from "./errors.js";
-
-/**
- * @param {any} manifest
- */
-export function isPlaceholderManifest(manifest) {
-  if (!manifest || typeof manifest !== "object") return true;
-  if (manifest.installed_at === "1970-01-01T00:00:00Z" || manifest.updated_at === "1970-01-01T00:00:00Z") return true;
-
-  const managed = Array.isArray(manifest.managed) ? manifest.managed : [];
-  for (const m of managed) {
-    if (!m || typeof m !== "object") continue;
-    if (typeof m.sha256 === "string" && m.sha256.includes("<sha256>")) return true;
-    if (m.blocks && typeof m.blocks === "object") {
-      for (const v of Object.values(m.blocks)) {
-        if (typeof v === "string" && v.includes("<sha256>")) return true;
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * @param {{ workspaceRoot: string, templateId: string, specVersion: string, aiwsVersion: string, installedAt: string, updatedAt: string, tools: string[], templateManifest: any }} options
- */
-export async function writeWorkspaceManifest(options) {
-  const managed = await computeManagedState({
-    workspaceRoot: options.workspaceRoot,
-    templateManifest: options.templateManifest,
-  });
-
-  const obj = {
-    manifest_version: 1,
-    template_id: options.templateId,
-    spec_version: options.specVersion,
-    aiws_version: options.aiwsVersion,
-    installed_at: options.installedAt,
-    updated_at: options.updatedAt,
-    tools: options.tools,
-    managed,
-  };
-
-  const outPath = path.join(options.workspaceRoot, ".aiws", "manifest.json");
-  await writeText(outPath, JSON.stringify(obj, null, 2) + "\n");
-  return obj;
-}
-
-/**
- * Compute managed hashes for the current workspace.
- *
- * Note: `.aiws/manifest.json` is intentionally excluded from `managed` to avoid self-hashing.
- *
- * @param {{ workspaceRoot: string, templateManifest: any }} options
- */
-export async function computeManagedState(options) {
-  const update = options.templateManifest?.update || {};
-  const replaceFiles = Array.isArray(update.replace_file) ? update.replace_file : [];
-  const managedBlocks = update.managed_blocks && typeof update.managed_blocks === "object" ? update.managed_blocks : {};
-
-  /** @type {any[]} */
-  const out = [];
-
-  for (const relRaw of replaceFiles) {
-    const rel = normalizeRel(relRaw);
-    if (!rel || rel === ".aiws/manifest.json") continue;
-    const abs = joinRel(options.workspaceRoot, rel);
-    if (!(await pathExists(abs))) throw new UserError(`Missing required managed file: ${rel}`);
-    out.push({ path: rel, mode: "replace_file", sha256: await sha256FileText(abs) });
-  }
-
-  for (const [fileRelRaw, blockIdsRaw] of Object.entries(managedBlocks)) {
-    const fileRel = normalizeRel(fileRelRaw);
-    if (!fileRel) continue;
-    const abs = joinRel(options.workspaceRoot, fileRel);
-    if (!(await pathExists(abs))) throw new UserError(`Missing required managed file: ${fileRel}`);
-    const text = normalizeNewlines(await readText(abs));
-    /** @type {Record<string, string>} */
-    const blocks = {};
-    const ids = Array.isArray(blockIdsRaw) ? blockIdsRaw : [];
-    for (const idRaw of ids) {
-      const id = String(idRaw);
-      const found = findManagedBlock(text, id);
-      if (!found) throw new UserError(`Missing managed block: ${id}`, { details: `File: ${fileRel}` });
-      blocks[id] = sha256Text(found.innerText);
-    }
-    out.push({ path: fileRel, mode: "managed_blocks", blocks });
-  }
-
-  out.sort((a, b) => String(a.path).localeCompare(String(b.path)));
-  return out;
-}
-
-/**
- * Validate current workspace against the stored `.aiws/manifest.json` and template contract.
- *
- * @param {{ workspaceRoot: string, storedManifest: any, templateManifest: any }} options
- */
-export async function validateDrift(options) {
-  const stored = options.storedManifest;
-  if (isPlaceholderManifest(stored)) {
-    throw new UserError("Workspace manifest is placeholder/uninitialized.", {
-      details: "Run `aiws init` to generate a real .aiws/manifest.json.",
-    });
-  }
-
-  const expected = await computeManagedState({ workspaceRoot: options.workspaceRoot, templateManifest: options.templateManifest });
-  const currentByPath = new Map(expected.map((e) => [e.path, e]));
-
-  const managed = Array.isArray(stored.managed) ? stored.managed : [];
-  const storedByPath = new Map(managed.map((e) => [String(e.path || ""), e]));
-
-  /** @type {string[]} */
-  const problems = [];
-
-  for (const [p, cur] of currentByPath.entries()) {
-    const s = storedByPath.get(p);
-    if (!s) {
-      problems.push(`missing manifest entry: ${p}`);
-      continue;
-    }
-    if (cur.mode !== s.mode) {
-      problems.push(`mode mismatch: ${p} (expected ${cur.mode}, got ${s.mode})`);
-      continue;
-    }
-    if (cur.mode === "replace_file") {
-      if (cur.sha256 !== s.sha256) {
-        problems.push(`sha256 mismatch: ${p}`);
-      }
-      continue;
-    }
-    if (cur.mode === "managed_blocks") {
-      const curBlocks = cur.blocks || {};
-      const sBlocks = s.blocks || {};
-      for (const [bid, curSha] of Object.entries(curBlocks)) {
-        if (!sBlocks[bid]) {
-          problems.push(`missing block in manifest: ${p} (${bid})`);
-        } else if (sBlocks[bid] !== curSha) {
-          problems.push(`block sha256 mismatch: ${p} (${bid})`);
-        }
-      }
-    }
-  }
-
-  if (problems.length > 0) {
-    throw new UserError("Workspace drift detected.", { details: problems.join("\n") });
-  }
-}
-

package/src/opencode-env.js

@@ -1,76 +0,0 @@
-import path from "node:path";
-import { pathExists, readText } from "./fs.js";
-
-const OPENCODE_AGENT_NAMES = ["planner-sisyphus", "librarian", "explore", "oracle"];
-
-/**
- * @param {string} value
- */
-function relativeOrDot(value) {
-  return value ? value.replaceAll(path.sep, "/") : ".";
-}
-
-/**
- * @param {any} raw
- * @param {string} agentName
- */
-function readAgentState(raw, agentName) {
-  const agents = raw && typeof raw === "object" && raw.agents && typeof raw.agents === "object" ? raw.agents : {};
-  const entry = agents[agentName];
-  return {
-    present: !!entry && typeof entry === "object",
-    enabled: !!(entry && typeof entry === "object" && entry.enabled === true),
-    replacePlan: entry && typeof entry === "object" && typeof entry.replace_plan === "boolean" ? entry.replace_plan : null,
-  };
-}
-
-/**
- * @param {string} workspaceRoot
- */
-export async function detectOpenCodeEnvironment(workspaceRoot) {
-  const opencodeDir = path.join(workspaceRoot, ".opencode");
-  const configPath = path.join(opencodeDir, "oh-my-opencode.json");
-  const examplePath = path.join(opencodeDir, "oh-my-opencode.json.example");
-  const opencodeDirExists = await pathExists(opencodeDir);
-  const configExists = await pathExists(configPath);
-  const exampleExists = await pathExists(examplePath);
-
-  /** @type {any} */
-  let config = null;
-  let configStatus = "missing";
-  let configError = "";
-  if (configExists) {
-    try {
-      config = JSON.parse(await readText(configPath));
-      configStatus = "loaded";
-    } catch (error) {
-      configStatus = "invalid";
-      configError = error instanceof Error ? error.message : String(error);
-    }
-  }
-
-  const agents = Object.fromEntries(OPENCODE_AGENT_NAMES.map((name) => [name, readAgentState(config, name)]));
-  const enabledAgents = OPENCODE_AGENT_NAMES.filter((name) => agents[name]?.enabled === true);
-  const recommendedAgentsReady = ["planner-sisyphus", "librarian", "explore", "oracle"].every((name) => agents[name]?.enabled === true);
-
-  return {
-    workspaceRoot,
-    opencodeDir,
-    opencodeDirExists,
-    configPath,
-    configExists,
-    configStatus,
-    configError,
-    examplePath,
-    exampleExists,
-    mode: configStatus === "loaded" ? "oMo-enabled" : "standard-opencode",
-    recommendedAgentsReady,
-    enabledAgents,
-    agents,
-    rel: {
-      opencodeDir: relativeOrDot(path.relative(workspaceRoot, opencodeDir)),
-      configPath: relativeOrDot(path.relative(workspaceRoot, configPath)),
-      examplePath: relativeOrDot(path.relative(workspaceRoot, examplePath)),
-    },
-  };
-}

package/src/path-utils.js

@@ -1,20 +0,0 @@
-import path from "node:path";
-
-/**
- * Join a POSIX-style relative path (with `/`) onto an absolute root.
- *
- * @param {string} rootDir
- * @param {string} relPosix
- */
-export function joinRel(rootDir, relPosix) {
-  return path.join(rootDir, ...String(relPosix).split("/"));
-}
-
-/**
- * Normalize a relative path from manifest (always forward slashes).
- *
- * @param {string} rel
- */
-export function normalizeRel(rel) {
-  return String(rel).replaceAll("\\", "/").replaceAll(/\/+/g, "/").replace(/^\/+/, "");
-}