@thinkingai/ae-cli 6.1.23 → 6.1.25

package/dist/project-semantic-36KOCYN7.js

@@ -0,0 +1,356 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  assertOutputPathAvailable,
+  downloadAnalysisArtifact,
+  withAsyncArtifactLifecycle
+} from "./chunk-XKIW3QMF.js";
+import {
+  CapabilityGatewayError,
+  dryRunCapability,
+  executeCapabilityWithEnvelope,
+  validateCapability
+} from "./chunk-QYXDJOLA.js";
+import {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain
+} from "./chunk-KPQY44JQ.js";
+import "./chunk-BW7JUDEI.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-DU72X2IO.js";
+import "./chunk-IG3DYEIR.js";
+import "./chunk-YVGXGTD6.js";
+
+// src/commands/project-semantic/asset-package/materializer.ts
+import { createHash, randomBytes } from "crypto";
+import { createReadStream } from "fs";
+import {
+  appendFile,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { createInterface } from "readline";
+import { createGunzip } from "zlib";
+import { basename, dirname, resolve } from "path";
+var MAX_COMPRESSED_BYTES = 64 * 1024 * 1024;
+var MAX_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+var MAX_RECORDS = 2e5;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var SUPPORTED_SCHEMA_VERSIONS = /* @__PURE__ */ new Set(["1.0", "3.0"]);
+var REQUIRED_FILES = [
+  "manifest.json",
+  "indexes/work-units.jsonl",
+  "indexes/asset-directory.jsonl",
+  "indexes/coverage-batches.jsonl",
+  "indexes/definition-families.jsonl",
+  "indexes/governance-coverage.jsonl",
+  "catalog/published.jsonl",
+  "catalog/active-candidates.jsonl",
+  "catalog/rejected-candidates.jsonl"
+];
+async function preflightAssetPackageOutput(args) {
+  await assertOutputPathAvailable(args.output, args.force);
+}
+async function materializeProjectSemanticAssetPackage(args) {
+  const descriptor = packageDescriptor(args.finalDescriptor);
+  const output = resolve(args.output);
+  const parent = dirname(output);
+  const nonce = `${process.pid}-${randomBytes(6).toString("hex")}`;
+  const staging = resolve(parent, `.${basename(output)}.staging-${nonce}`);
+  const archive = resolve(parent, `.${basename(output)}.archive-${nonce}.jsonl.gz`);
+  const backup = resolve(parent, `.${basename(output)}.backup-${nonce}`);
+  let movedExisting = false;
+  await assertOutputPathAvailable(output, args.force, {
+    run_id: args.runId,
+    artifact_id: args.artifactId
+  });
+  await mkdir(parent, { recursive: true });
+  await mkdir(staging, { recursive: false });
+  try {
+    const download = await downloadAnalysisArtifact(
+      args.ctx.host(),
+      args.runId,
+      args.artifactId,
+      archive,
+      { signal: args.signal, ensureReady: false }
+    );
+    if (download.bytes > MAX_COMPRESSED_BYTES) {
+      throw packageError("Asset package archive exceeds 64 MiB.", "ASSET_PACKAGE_ARCHIVE_TOO_LARGE");
+    }
+    const materialized = await materializeArchive(archive, staging, descriptor);
+    if (args.force && await exists(output)) {
+      await rename(output, backup);
+      movedExisting = true;
+    }
+    await rename(staging, output);
+    if (movedExisting) {
+      await rm(backup, { recursive: true, force: true });
+      movedExisting = false;
+    }
+    return {
+      ...args.finalDescriptor,
+      output_path: output,
+      archive_bytes: download.bytes,
+      record_count: materialized.recordCount,
+      uncompressed_bytes: materialized.uncompressedBytes
+    };
+  } catch (error) {
+    if (movedExisting) {
+      await rename(backup, output).catch(() => void 0);
+    }
+    throw error;
+  } finally {
+    await rm(archive, { force: true }).catch(() => void 0);
+    await rm(staging, { recursive: true, force: true }).catch(() => void 0);
+    if (!movedExisting) {
+      await rm(backup, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+}
+async function materializeArchive(archive, staging, descriptor) {
+  const compressed = await stat(archive);
+  if (compressed.size > MAX_COMPRESSED_BYTES) {
+    throw packageError("Asset package archive exceeds 64 MiB.", "ASSET_PACKAGE_ARCHIVE_TOO_LARGE");
+  }
+  const digest = createHash("sha256");
+  const lines = createInterface({
+    input: createReadStream(archive).pipe(createGunzip()),
+    crlfDelay: Infinity
+  });
+  let recordCount = 0;
+  let uncompressedBytes = 0;
+  let manifest;
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    uncompressedBytes += Buffer.byteLength(line, "utf8") + 1;
+    if (uncompressedBytes > MAX_UNCOMPRESSED_BYTES) {
+      throw packageError(
+        "Asset package archive exceeds 512 MiB after decompression.",
+        "ASSET_PACKAGE_ARCHIVE_TOO_LARGE"
+      );
+    }
+    recordCount += 1;
+    if (recordCount > MAX_RECORDS) {
+      throw packageError("Asset package has too many records.", "ASSET_PACKAGE_RECORD_LIMIT_EXCEEDED");
+    }
+    digest.update(line, "utf8");
+    digest.update("\n", "utf8");
+    const record = parseRecord(line);
+    const target = resolveRecordPath(staging, record.path);
+    await mkdir(dirname(target), { recursive: true });
+    const content = `${JSON.stringify(record.content)}
+`;
+    if (record.append) {
+      await appendFile(target, content, "utf8");
+    } else {
+      await writeFile(target, content, { encoding: "utf8", flag: "wx" });
+    }
+    if (record.path === "manifest.json") {
+      manifest = asObject(record.content);
+    }
+  }
+  const actualHash = digest.digest("hex");
+  if (actualHash !== descriptor.snapshotHash) {
+    throw packageError(
+      `Asset package content hash mismatch: expected ${descriptor.snapshotHash}, received ${actualHash}.`,
+      "ASSET_PACKAGE_HASH_MISMATCH"
+    );
+  }
+  if (!manifest || !Number.isInteger(Number(manifest.project_id))) {
+    throw packageError("Asset package manifest is missing project identity.", "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  const schemaVersion = typeof manifest.schema_version === "string" ? manifest.schema_version : "";
+  if (!SUPPORTED_SCHEMA_VERSIONS.has(schemaVersion)) {
+    throw packageError(
+      `Project semantic asset package schema ${[...SUPPORTED_SCHEMA_VERSIONS].join(" or ")} is required.`,
+      "ASSET_PACKAGE_VERSION_MISMATCH"
+    );
+  }
+  for (const required of REQUIRED_FILES) {
+    if (!await exists(resolve(staging, required))) {
+      throw packageError(`Asset package is missing required file ${required}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+    }
+  }
+  await verifyDetailLocators(staging, schemaVersion);
+  await writeFile(resolve(staging, ".asset-package.json"), JSON.stringify({
+    snapshot_id: descriptor.snapshotId,
+    snapshot_hash: descriptor.snapshotHash,
+    schema_version: schemaVersion,
+    package_kind: typeof manifest.package_kind === "string" ? manifest.package_kind : "project_semantic_asset_package",
+    company_id: Number(manifest.company_id),
+    project_id: Number(manifest.project_id),
+    project_name: typeof manifest.project_name === "string" ? manifest.project_name : void 0,
+    record_count: recordCount,
+    asset_scope: typeof manifest.asset_scope === "string" ? manifest.asset_scope : "governed",
+    exported_asset_count: Number(manifest.exported_asset_count ?? manifest.authenticated_asset_count),
+    authenticated_asset_count: Number(manifest.authenticated_asset_count),
+    unauthenticated_asset_count: Number(manifest.unauthenticated_asset_count ?? 0),
+    truncated: Boolean(manifest.truncated),
+    counts: manifest.counts,
+    filter_policy: manifest.filter_policy
+  }, null, 2), "utf8");
+  return { recordCount, uncompressedBytes };
+}
+async function verifyDetailLocators(root, schemaVersion) {
+  const directory = await readFile(resolve(root, "indexes/asset-directory.jsonl"), "utf8");
+  for (const line of directory.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const row = asObject(JSON.parse(line));
+    if (!row || row.record_type === "header") continue;
+    const detail = await verifyContentLocator(root, row.detail_locator, "Detail");
+    await verifyContentLocator(root, detail.raw_locator, "Raw detail", { skipHash: schemaVersion === "3.0" });
+  }
+}
+async function verifyContentLocator(root, value, label, options = {}) {
+  const locator = asObject(value);
+  if (!locator || typeof locator.path !== "string" || typeof locator.content_hash !== "string" || !SHA256_PATTERN.test(locator.content_hash)) {
+    throw packageError(
+      `Asset package contains an invalid ${label.toLowerCase()} locator.`,
+      "ASSET_PACKAGE_MANIFEST_INVALID"
+    );
+  }
+  const target = resolveRecordPath(root, locator.path);
+  if (!await exists(target)) {
+    throw packageError(`Asset package is missing ${label.toLowerCase()} file ${locator.path}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  const content = asObject(JSON.parse(await readFile(target, "utf8")));
+  if (!content) {
+    throw packageError(`${label} file is not a JSON object: ${locator.path}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  if (!options.skipHash) {
+    const actualHash = createHash("sha256").update(JSON.stringify(content), "utf8").digest("hex");
+    if (actualHash !== locator.content_hash) {
+      throw packageError(`${label} content hash mismatch for ${locator.path}.`, "ASSET_PACKAGE_HASH_MISMATCH");
+    }
+  }
+  return content;
+}
+function parseRecord(line) {
+  const value = JSON.parse(line);
+  const record = asObject(value);
+  if (!record || typeof record.path !== "string") {
+    throw packageError("Asset package record is missing path.", "ASSET_PACKAGE_RECORD_INVALID");
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, "content")) {
+    throw packageError("Asset package record is missing content.", "ASSET_PACKAGE_RECORD_INVALID");
+  }
+  return {
+    path: record.path,
+    append: Boolean(record.append),
+    content: record.content
+  };
+}
+function resolveRecordPath(root, path) {
+  if (path.startsWith("/") || path.includes("\0")) {
+    throw packageError(`Invalid asset package path: ${path}`, "ASSET_PACKAGE_PATH_INVALID");
+  }
+  const target = resolve(root, path);
+  const normalizedRoot = `${resolve(root)}/`;
+  if (!target.startsWith(normalizedRoot)) {
+    throw packageError(`Invalid asset package path: ${path}`, "ASSET_PACKAGE_PATH_INVALID");
+  }
+  return target;
+}
+function packageDescriptor(descriptor) {
+  const snapshotHash = stringValue(descriptor.snapshot_hash, "snapshot_hash").toLowerCase();
+  if (!SHA256_PATTERN.test(snapshotHash)) {
+    throw packageError("Asset package export returned invalid snapshot_hash.", "ASSET_PACKAGE_DESCRIPTOR_INVALID");
+  }
+  return {
+    snapshotId: typeof descriptor.snapshot_id === "string" ? descriptor.snapshot_id : void 0,
+    snapshotHash
+  };
+}
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function stringValue(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw packageError(`${label} must be a non-empty string.`, "ASSET_PACKAGE_DESCRIPTOR_INVALID");
+  }
+  return value;
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function packageError(message, code) {
+  return new CapabilityGatewayError(message, code, 422);
+}
+
+// src/commands/project-semantic/asset-package/export.ts
+var ASSET_PACKAGE_EXPORT_CAPABILITY = "business_semantics.asset_package.export";
+var ASSET_SCOPES = /* @__PURE__ */ new Set(["governed", "collaborative", "all_visible"]);
+var GATEWAY_DOMAIN = "analysis";
+function assetScope(ctx) {
+  const value = ctx.str("asset-scope") || "governed";
+  if (!ASSET_SCOPES.has(value)) {
+    throw new Error("asset-scope must be one of: governed, collaborative, all_visible");
+  }
+  return value;
+}
+var assetPackageExportCommand = {
+  service: "project-semantic",
+  resource: "asset-package",
+  command: "export",
+  description: "Export and materialize a knowledge-ready project asset package for CLI Agent consumption.",
+  helpText: "Requires access to the target project. Explicit asset-package export is independent of automatic knowledge-base discovery.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
+    {
+      name: "asset-scope",
+      type: "string",
+      required: false,
+      desc: "Asset scope: governed, collaborative, or all_visible. Defaults to governed."
+    }
+  ],
+  risk: "read",
+  validateInput: (ctx) => validateCapability(
+    ctx.host(),
+    resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+    ASSET_PACKAGE_EXPORT_CAPABILITY,
+    { project_id: ctx.num("project-id"), asset_scope: assetScope(ctx) }
+  ),
+  dryRun: (ctx) => dryRunCapability(
+    ctx.host(),
+    resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+    ASSET_PACKAGE_EXPORT_CAPABILITY,
+    { project_id: ctx.num("project-id"), asset_scope: assetScope(ctx) }
+  ),
+  execute: async (ctx) => {
+    const projectId = ctx.num("project-id");
+    const scope = assetScope(ctx);
+    const response = await executeCapabilityWithEnvelope(
+      ctx.host(),
+      resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+      ASSET_PACKAGE_EXPORT_CAPABILITY,
+      { project_id: projectId, asset_scope: scope }
+    );
+    return response.data;
+  }
+};
+var projectSemanticAssetPackageExport = withAsyncArtifactLifecycle(assetPackageExportCommand, {
+  preflightOutput: ({ output, force }) => preflightAssetPackageOutput({ output, force }),
+  materialize: materializeProjectSemanticAssetPackage
+});
+
+// src/commands/project-semantic/index.ts
+registerCapabilityGatewayRoute("project-semantic", {
+  gatewayDomain: "analysis",
+  capabilityPrefixes: ["business_semantics.asset_package"]
+});
+var commands = [
+  projectSemanticAssetPackageExport
+];
+var project_semantic_default = commands;
+export {
+  project_semantic_default as default
+};

package/dist/{sync-O45NXEQY.js → sync-EQLSTUS7.js}

@@ -21,8 +21,8 @@ import {
 } from "./chunk-T6OSFQZD.js";
 import {
   require_lib
-} from "./chunk-DVMLWQD4.js";
-import "./chunk-V2NUHPXF.js";
+} from "./chunk-SO5LKIWP.js";
+import "./chunk-GK7WDY7E.js";
 import {
   TeAgentApiError,
   TeAgentCredentialsError,
@@ -30,16 +30,16 @@ import {
   postSandboxSyncPull,
   postToMainApp,
   uploadToMainApp
-} from "./chunk-HBGADCKA.js";
+} from "./chunk-KJDOTPYU.js";
 import {
   printError
-} from "./chunk-DX5CDO34.js";
+} from "./chunk-BW7JUDEI.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-7XGFSUOM.js";
-import "./chunk-7FTTULED.js";
+import "./chunk-DU72X2IO.js";
+import "./chunk-IG3DYEIR.js";
 import {
   __toESM
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // src/commands/sync/index.ts
 var import_jszip = __toESM(require_lib(), 1);