homegraph 1.1.2 → 1.2.0

package/scripts/ohos-sdk-publish.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * Build and optionally publish homegraph-ohos-api-db-<version> (one npm package per API version).
+ *
+ * Usage:
+ *   node scripts/ohos-sdk-publish.mjs <zip-or-dir> [version] [--dry-run] [--no-publish]
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  resolveOhosSdkInput,
+  ohosApiDbFilename,
+  ohosApiDbPackageName,
+  indexOhosApiDb,
+} from '../dist/extraction/languages/arkts.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function parseArgs(argv) {
+  const positional = [];
+  const flags = new Set();
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) flags.add(arg);
+    else positional.push(arg);
+  }
+  return {
+    input: positional[0] ?? '',
+    version: positional[1] ?? '',
+    dryRun: flags.has('--dry-run'),
+    noPublish: flags.has('--no-publish'),
+  };
+}
+
+function buildNpmPackage(version, dbPath, outDir) {
+  const dbName = ohosApiDbFilename(version);
+  const pkgName = ohosApiDbPackageName(version);
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(path.join(outDir, 'scripts'), { recursive: true });
+  fs.copyFileSync(dbPath, path.join(outDir, dbName));
+
+  const postinstall = `#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const dbName = ${JSON.stringify(dbName)};
+const src = path.join(__dirname, '..', dbName);
+const dest = path.join(os.homedir(), '.homegraph', 'api', dbName);
+if (!fs.existsSync(src)) process.exit(0);
+fs.mkdirSync(path.dirname(dest), { recursive: true });
+fs.copyFileSync(src, dest);
+`;
+  fs.writeFileSync(path.join(outDir, 'scripts', 'postinstall.js'), postinstall, { mode: 0o755 });
+  fs.writeFileSync(
+    path.join(outDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: pkgName,
+        version: '1.0.0',
+        description: `Prebuilt HomeGraph OHOS API database for SDK ${version}`,
+        license: 'MIT',
+        files: [dbName, 'scripts/postinstall.js'],
+        scripts: { postinstall: 'node scripts/postinstall.js' },
+        homegraph: { ohosApiVersion: version, dbFile: dbName },
+      },
+      null,
+      2
+    ) + '\n'
+  );
+  return pkgName;
+}
+
+const { input, version, dryRun, noPublish } = parseArgs(process.argv);
+if (!input) {
+  console.error('Usage: node scripts/ohos-sdk-publish.mjs <zip-or-dir> [version] [--dry-run] [--no-publish]');
+  process.exit(1);
+}
+
+if (!fs.existsSync(path.join(ROOT, 'dist/extraction/languages/arkts.js'))) {
+  console.error('[ohos-sdk-publish] dist not built — run npm run build first');
+  process.exit(1);
+}
+
+const resolved = resolveOhosSdkInput({
+  inputPath: path.resolve(input),
+  versionOverride: version || undefined,
+});
+
+const dbPath = path.join(
+  fs.mkdtempSync(path.join(path.dirname(resolved.sdkHome), '.hg-ohos-pack-')),
+  ohosApiDbFilename(resolved.version)
+);
+const pkgDir = path.join(path.dirname(dbPath), 'npm-package');
+
+try {
+  process.stderr.write(`[ohos-sdk-publish] indexing ${resolved.version} …\n`);
+  const result = await indexOhosApiDb({
+    sdkHome: resolved.sdkHome,
+    version: resolved.version,
+    outputPath: dbPath,
+    onProgress: (p) => {
+      if (p.phase === 'arkts-batch') {
+        const label = p.subphase === 'scene' ? 'Scene' : 'Persist';
+        process.stderr.write(`\r${label}: ${p.current}/${p.total}`.padEnd(40));
+      }
+    },
+  });
+  process.stderr.write('\n');
+  if (!result.success) {
+    for (const err of result.errors.filter((e) => e.severity === 'error')) console.error(err.message);
+    process.exit(1);
+  }
+
+  const pkgName = buildNpmPackage(resolved.version, dbPath, pkgDir);
+  console.log(`[ohos-sdk-publish] package: ${pkgName} → ${pkgDir} (${result.nodesCreated} nodes)`);
+
+  if (dryRun || noPublish) {
+    console.log('[ohos-sdk-publish] skipping npm publish');
+    process.exit(0);
+  }
+  if (!process.env.NPM_TOKEN) {
+    console.error('[ohos-sdk-publish] NPM_TOKEN not set — package built, not published');
+    process.exit(0);
+  }
+
+  const { execFileSync } = await import('child_process');
+  execFileSync('npm', ['publish', '--access', 'public'], { cwd: pkgDir, stdio: 'inherit' });
+  console.log(`[ohos-sdk-publish] published ${pkgName}`);
+} finally {
+  resolved.cleanup?.();
+}

package/scripts/pack-npm.sh

@@ -1,119 +1,119 @@
-#!/usr/bin/env bash
-#
-# Assemble the npm thin-installer packages from built bundles (esbuild pattern).
-#
-# Produces, under release/npm/:
-#   homegraph-<target>/   one per built bundle — the vendored Node + app, tagged
-#                         with os/cpu so npm installs only the matching one.
-#   main/                 the homegraph shim package: a tiny bin
-#                         that execs the matching platform bundle, with every
-#                         platform package in optionalDependencies.
-#
-# The release pipeline then `npm publish`es each dir. This does NOT touch the
-# repo's package.json — the dev/from-source path keeps working; the *published*
-# main package's shape is generated here.
-#
-# Prereq: run build-bundle.sh for each target first (release/homegraph-*.tar.gz).
-# Usage:  scripts/pack-npm.sh [version]    (default: version from package.json)
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-VERSION="${1:-$(node -p "require('$ROOT/package.json').version")}"
-SCOPE="@colbymchenry"
-REL="$ROOT/release"
-NPM="$REL/npm"
-
-rm -rf "$NPM"
-mkdir -p "$NPM/main"
-
-shopt -s nullglob
-archives=("$REL"/homegraph-*.tar.gz "$REL"/homegraph-*.zip)
-[ ${#archives[@]} -gt 0 ] || { echo "[pack-npm] no bundles in $REL — run build-bundle.sh first" >&2; exit 1; }
-
-targets=()
-for archive in "${archives[@]}"; do
-  fname="$(basename "$archive")"
-  case "$fname" in
-    *.tar.gz) base="${fname%.tar.gz}" ;;   # homegraph-<target>
-    *.zip)    base="${fname%.zip}" ;;
-  esac
-  target="${base#homegraph-}"             # <target>, e.g. darwin-arm64 / win32-x64
-  os="${target%-*}"                       # darwin | linux | win32
-  arch="${target##*-}"                    # arm64 | x64
-  pkgdir="$NPM/$base"
-  mkdir -p "$pkgdir"
-  case "$fname" in
-    *.zip)
-      tmpx="$(mktemp -d)"
-      unzip -q "$archive" -d "$tmpx"
-      mv "$tmpx/homegraph-${target}"/* "$pkgdir"/
-      rm -rf "$tmpx"
-      nodefile="node.exe"
-      ;;
-    *)
-      tar -xzf "$archive" -C "$pkgdir" --strip-components=1
-      nodefile="node"
-      ;;
-  esac
-  VERSION="$VERSION" SCOPE="$SCOPE" TARGET="$target" OSV="$os" ARCHV="$arch" NODEFILE="$nodefile" \
-    node -e '
-      const fs=require("fs");
-      fs.writeFileSync(process.argv[1], JSON.stringify({
-        name: `${process.env.SCOPE}/homegraph-${process.env.TARGET}`,
-        version: process.env.VERSION,
-        description: `HomeGraph self-contained bundle for ${process.env.TARGET}`,
-        os: [process.env.OSV], cpu: [process.env.ARCHV],
-        files: [process.env.NODEFILE, "lib", "bin"],
-        license: "MIT"
-      }, null, 2) + "\n");
-    ' "$pkgdir/package.json"
-  targets+=("$target")
-  echo "[pack-npm] ${SCOPE}/homegraph-${target}@${VERSION}"
-done
-
-# Main shim package.
-#   npm-shim.js  CLI/MCP launcher (execs the bundled Node) — the `bin`.
-#   npm-sdk.js   programmatic/embedded entry (#354): re-exports the installed
-#                platform bundle's compiled library — the `main`.
-#   dist/        the .d.ts tree only (types). The runtime .js stays in the
-#                per-platform bundle so its deps aren't duplicated here.
-cp "$ROOT/scripts/npm-shim.js" "$NPM/main/npm-shim.js"
-cp "$ROOT/scripts/npm-sdk.js" "$NPM/main/npm-sdk.js"
-[ -f "$ROOT/README.md" ] && cp "$ROOT/README.md" "$NPM/main/README.md"
-
-# Ship the type declarations so `types`/`exports.types` resolve. Built from this
-# same release, so they can't skew from the runtime npm-sdk.js re-exports.
-[ -f "$ROOT/dist/index.d.ts" ] || ( echo "[pack-npm] building dist for .d.ts" >&2 && cd "$ROOT" && npm run build >/dev/null )
-ROOT="$ROOT" DEST="$NPM/main" node -e '
-  const fs=require("fs"), path=require("path");
-  const src=path.join(process.env.ROOT,"dist"), dest=path.join(process.env.DEST,"dist");
-  fs.cpSync(src, dest, { recursive:true, filter(s){
-    try { return fs.statSync(s).isDirectory() || s.endsWith(".d.ts"); } catch (e) { return false; }
-  }});
-'
-
-VERSION="$VERSION" SCOPE="$SCOPE" TARGETS="${targets[*]}" \
-  node -e '
-    const fs=require("fs");
-    const opt={};
-    for (const t of process.env.TARGETS.split(/\s+/).filter(Boolean))
-      opt[`${process.env.SCOPE}/homegraph-${t}`]=process.env.VERSION;
-    fs.writeFileSync(process.argv[1], JSON.stringify({
-      name: `${process.env.SCOPE}/homegraph`,
-      version: process.env.VERSION,
-      description: "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
-      bin: { homegraph: "npm-shim.js" },
-      main: "npm-sdk.js",
-      types: "dist/index.d.ts",
-      exports: {
-        ".": { types: "./dist/index.d.ts", default: "./npm-sdk.js" },
-        "./package.json": "./package.json"
-      },
-      optionalDependencies: opt,
-      files: ["npm-shim.js","npm-sdk.js","dist","README.md"],
-      license: "MIT"
-    }, null, 2) + "\n");
-  ' "$NPM/main/package.json"
-
-echo "[pack-npm] ${SCOPE}/homegraph@${VERSION} (${#targets[@]} platform packages in optionalDependencies)"
-echo "[pack-npm] output: $NPM"
+#!/usr/bin/env bash
+#
+# Assemble the npm thin-installer packages from built bundles (esbuild pattern).
+#
+# Produces, under release/npm/:
+#   homegraph-<target>/   one per built bundle — the vendored Node + app, tagged
+#                         with os/cpu so npm installs only the matching one.
+#   main/                 the homegraph shim package: a tiny bin
+#                         that execs the matching platform bundle, with every
+#                         platform package in optionalDependencies.
+#
+# The release pipeline then `npm publish`es each dir. This does NOT touch the
+# repo's package.json — the dev/from-source path keeps working; the *published*
+# main package's shape is generated here.
+#
+# Prereq: run build-bundle.sh for each target first (release/homegraph-*.tar.gz).
+# Usage:  scripts/pack-npm.sh [version]    (default: version from package.json)
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+VERSION="${1:-$(node -p "require('$ROOT/package.json').version")}"
+SCOPE="@colbymchenry"
+REL="$ROOT/release"
+NPM="$REL/npm"
+
+rm -rf "$NPM"
+mkdir -p "$NPM/main"
+
+shopt -s nullglob
+archives=("$REL"/homegraph-*.tar.gz "$REL"/homegraph-*.zip)
+[ ${#archives[@]} -gt 0 ] || { echo "[pack-npm] no bundles in $REL — run build-bundle.sh first" >&2; exit 1; }
+
+targets=()
+for archive in "${archives[@]}"; do
+  fname="$(basename "$archive")"
+  case "$fname" in
+    *.tar.gz) base="${fname%.tar.gz}" ;;   # homegraph-<target>
+    *.zip)    base="${fname%.zip}" ;;
+  esac
+  target="${base#homegraph-}"             # <target>, e.g. darwin-arm64 / win32-x64
+  os="${target%-*}"                       # darwin | linux | win32
+  arch="${target##*-}"                    # arm64 | x64
+  pkgdir="$NPM/$base"
+  mkdir -p "$pkgdir"
+  case "$fname" in
+    *.zip)
+      tmpx="$(mktemp -d)"
+      unzip -q "$archive" -d "$tmpx"
+      mv "$tmpx/homegraph-${target}"/* "$pkgdir"/
+      rm -rf "$tmpx"
+      nodefile="node.exe"
+      ;;
+    *)
+      tar -xzf "$archive" -C "$pkgdir" --strip-components=1
+      nodefile="node"
+      ;;
+  esac
+  VERSION="$VERSION" SCOPE="$SCOPE" TARGET="$target" OSV="$os" ARCHV="$arch" NODEFILE="$nodefile" \
+    node -e '
+      const fs=require("fs");
+      fs.writeFileSync(process.argv[1], JSON.stringify({
+        name: `${process.env.SCOPE}/homegraph-${process.env.TARGET}`,
+        version: process.env.VERSION,
+        description: `HomeGraph self-contained bundle for ${process.env.TARGET}`,
+        os: [process.env.OSV], cpu: [process.env.ARCHV],
+        files: [process.env.NODEFILE, "lib", "bin"],
+        license: "MIT"
+      }, null, 2) + "\n");
+    ' "$pkgdir/package.json"
+  targets+=("$target")
+  echo "[pack-npm] ${SCOPE}/homegraph-${target}@${VERSION}"
+done
+
+# Main shim package.
+#   npm-shim.js  CLI/MCP launcher (execs the bundled Node) — the `bin`.
+#   npm-sdk.js   programmatic/embedded entry (#354): re-exports the installed
+#                platform bundle's compiled library — the `main`.
+#   dist/        the .d.ts tree only (types). The runtime .js stays in the
+#                per-platform bundle so its deps aren't duplicated here.
+cp "$ROOT/scripts/npm-shim.js" "$NPM/main/npm-shim.js"
+cp "$ROOT/scripts/npm-sdk.js" "$NPM/main/npm-sdk.js"
+[ -f "$ROOT/README.md" ] && cp "$ROOT/README.md" "$NPM/main/README.md"
+
+# Ship the type declarations so `types`/`exports.types` resolve. Built from this
+# same release, so they can't skew from the runtime npm-sdk.js re-exports.
+[ -f "$ROOT/dist/index.d.ts" ] || ( echo "[pack-npm] building dist for .d.ts" >&2 && cd "$ROOT" && npm run build >/dev/null )
+ROOT="$ROOT" DEST="$NPM/main" node -e '
+  const fs=require("fs"), path=require("path");
+  const src=path.join(process.env.ROOT,"dist"), dest=path.join(process.env.DEST,"dist");
+  fs.cpSync(src, dest, { recursive:true, filter(s){
+    try { return fs.statSync(s).isDirectory() || s.endsWith(".d.ts"); } catch (e) { return false; }
+  }});
+'
+
+VERSION="$VERSION" SCOPE="$SCOPE" TARGETS="${targets[*]}" \
+  node -e '
+    const fs=require("fs");
+    const opt={};
+    for (const t of process.env.TARGETS.split(/\s+/).filter(Boolean))
+      opt[`${process.env.SCOPE}/homegraph-${t}`]=process.env.VERSION;
+    fs.writeFileSync(process.argv[1], JSON.stringify({
+      name: `${process.env.SCOPE}/homegraph`,
+      version: process.env.VERSION,
+      description: "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
+      bin: { homegraph: "npm-shim.js" },
+      main: "npm-sdk.js",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": { types: "./dist/index.d.ts", default: "./npm-sdk.js" },
+        "./package.json": "./package.json"
+      },
+      optionalDependencies: opt,
+      files: ["npm-shim.js","npm-sdk.js","dist","README.md"],
+      license: "MIT"
+    }, null, 2) + "\n");
+  ' "$NPM/main/package.json"
+
+echo "[pack-npm] ${SCOPE}/homegraph@${VERSION} (${#targets[@]} platform packages in optionalDependencies)"
+echo "[pack-npm] output: $NPM"