@vxnus/siduri 0.0.5 → 0.0.7

package/dist/manifest.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrganManifest = validateOrganManifest;
+function validateOrganManifest(manifest, sourcePath) {
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error(`Invalid manifest at ${sourcePath || 'unknown'}: expected an object`);
+    }
+    const m = manifest;
+    if (!m.name || typeof m.name !== 'string' || !m.name.startsWith('@siduri-x/')) {
+        throw new Error(`Invalid manifest name in ${sourcePath || 'unknown'}: expected package name starting with @siduri-x/`);
+    }
+    if (!m.organType || typeof m.organType !== 'string') {
+        throw new Error(`Invalid manifest organType in ${sourcePath || m.name}`);
+    }
+    if (!m.version || typeof m.version !== 'string') {
+        throw new Error(`Invalid manifest version in ${sourcePath || m.name}`);
+    }
+    if (!m.displayName || typeof m.displayName !== 'string') {
+        throw new Error(`Invalid manifest displayName in ${sourcePath || m.name}`);
+    }
+    if (!m.entrypoint || typeof m.entrypoint !== 'string') {
+        throw new Error(`Invalid manifest entrypoint in ${sourcePath || m.name}`);
+    }
+    if (!m.factory || typeof m.factory !== 'string') {
+        throw new Error(`Invalid manifest factory in ${sourcePath || m.name}`);
+    }
+    if (!m.configKey || typeof m.configKey !== 'string') {
+        throw new Error(`Invalid manifest configKey in ${sourcePath || m.name}`);
+    }
+    if (!m.configSchema || typeof m.configSchema !== 'object') {
+        throw new Error(`Invalid manifest configSchema in ${sourcePath || m.name}`);
+    }
+    if (!Array.isArray(m.environment)) {
+        throw new Error(`Invalid manifest environment in ${sourcePath || m.name}: expected array`);
+    }
+    if (!Array.isArray(m.services)) {
+        throw new Error(`Invalid manifest services in ${sourcePath || m.name}: expected array`);
+    }
+    return m;
+}

package/dist/release-check.d.ts

@@ -0,0 +1,9 @@
+export interface ReleaseCheckReport {
+    packagesChecked: number;
+    tarballsInspected: number;
+    manifestsValidated: number;
+    cleanMachinePassed: boolean;
+    passed: boolean;
+    errors: string[];
+}
+export declare function runReleaseCheck(repoRoot?: string): ReleaseCheckReport;

package/dist/release-check.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReleaseCheck = runReleaseCheck;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function run(cmd, cwd) {
+    return (0, node_child_process_1.execSync)(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+}
+function runReleaseCheck(repoRoot = node_path_1.default.resolve(__dirname, '../..')) {
+    const errors = [];
+    const tempPackDir = node_path_1.default.resolve(repoRoot, 'cli/temp-release-check-packs');
+    if (node_fs_1.default.existsSync(tempPackDir))
+        node_fs_1.default.rmSync(tempPackDir, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(tempPackDir, { recursive: true });
+    const canonicalPackages = [
+        { name: '@siduri-x/core', dir: 'packages/core', isOrgan: false, tarName: 'siduri-x-core-1.0.0.tgz' },
+        { name: '@siduri-x/brain', dir: 'packages/organs/brain', isOrgan: true, tarName: 'siduri-x-brain-1.0.0.tgz' },
+        { name: '@siduri-x/memory', dir: 'packages/organs/memory', isOrgan: true, tarName: 'siduri-x-memory-1.0.0.tgz' },
+        { name: '@siduri-x/knowledge', dir: 'packages/organs/knowledge', isOrgan: true, tarName: 'siduri-x-knowledge-1.0.0.tgz' },
+        { name: '@siduri-x/behavior', dir: 'packages/organs/behavior', isOrgan: true, tarName: 'siduri-x-behavior-1.0.0.tgz' },
+        { name: '@siduri-x/ear', dir: 'packages/organs/ear', isOrgan: true, tarName: 'siduri-x-ear-1.0.0.tgz' },
+        { name: '@siduri-x/vision', dir: 'packages/organs/vision', isOrgan: true, tarName: 'siduri-x-vision-1.0.0.tgz' },
+        { name: '@siduri-x/hands', dir: 'packages/organs/hands', isOrgan: true, tarName: 'siduri-x-hands-1.0.0.tgz' },
+        { name: '@siduri-x/body', dir: 'packages/organs/body', isOrgan: true, tarName: 'siduri-x-body-1.0.0.tgz' },
+        { name: '@siduri-x/voice', dir: 'packages/organs/voice', isOrgan: true, tarName: 'siduri-x-voice-1.0.0.tgz' },
+        { name: '@siduri-x/observation', dir: 'packages/organs/observation', isOrgan: true, tarName: 'siduri-x-observation-1.0.0.tgz' },
+        { name: '@vxnus/siduri', dir: 'cli', isOrgan: false, tarName: 'vxnus-siduri-0.0.7.tgz' },
+    ];
+    let packagesChecked = 0;
+    let tarballsInspected = 0;
+    let manifestsValidated = 0;
+    try {
+        // 1. Pack each package
+        for (const pkg of canonicalPackages) {
+            packagesChecked++;
+            try {
+                run(`pnpm --filter ${pkg.name} pack --pack-destination ${tempPackDir}`, repoRoot);
+            }
+            catch (err) {
+                errors.push(`Failed to pack ${pkg.name}: ${err.message}`);
+                continue;
+            }
+            const tarPath = node_path_1.default.join(tempPackDir, pkg.tarName);
+            if (!node_fs_1.default.existsSync(tarPath)) {
+                errors.push(`Tarball not found for ${pkg.name} at ${tarPath}`);
+                continue;
+            }
+            tarballsInspected++;
+            // Inspect tarball package.json
+            const pkgJsonRaw = run(`tar -xzf ${tarPath} -O package/package.json`, repoRoot);
+            const pkgJson = JSON.parse(pkgJsonRaw);
+            // Check package metadata
+            if (!pkgJson.name)
+                errors.push(`${pkg.name}: missing 'name'`);
+            if (!pkgJson.version)
+                errors.push(`${pkg.name}: missing 'version'`);
+            if (!pkgJson.description)
+                errors.push(`${pkg.name}: missing 'description'`);
+            if (!pkgJson.license)
+                errors.push(`${pkg.name}: missing 'license'`);
+            if (!pkgJson.engines || !pkgJson.engines.node)
+                errors.push(`${pkg.name}: missing 'engines.node'`);
+            // Check for zero workspace: or link: dependencies
+            const deps = { ...(pkgJson.dependencies || {}), ...(pkgJson.peerDependencies || {}) };
+            for (const [dep, ver] of Object.entries(deps)) {
+                if (typeof ver === 'string') {
+                    if (ver.startsWith('workspace:'))
+                        errors.push(`${pkg.name}: contains workspace dependency on ${dep}`);
+                    if (ver.startsWith('link:'))
+                        errors.push(`${pkg.name}: contains link: dependency on ${dep}`);
+                    if (ver.includes('../'))
+                        errors.push(`${pkg.name}: contains relative path on ${dep}`);
+                }
+            }
+            // Check tarball contents
+            const listing = run(`tar -tzf ${tarPath}`, repoRoot).split('\n');
+            if (pkg.isOrgan) {
+                if (!listing.some((l) => l.includes('package/organ-manifest.json'))) {
+                    errors.push(`${pkg.name}: organ-manifest.json missing in tarball`);
+                }
+                else {
+                    manifestsValidated++;
+                }
+            }
+            if (pkg.name === '@siduri-x/memory') {
+                if (!listing.some((l) => l.includes('package/migrations/001_initial_schema.sql'))) {
+                    errors.push(`${pkg.name}: migrations/001_initial_schema.sql missing in tarball`);
+                }
+            }
+            if (pkg.name === '@vxnus/siduri') {
+                if (!pkgJson.bin || !pkgJson.bin.siduri) {
+                    errors.push(`${pkg.name}: bin.siduri field missing in package.json`);
+                }
+            }
+        }
+    }
+    finally {
+        if (node_fs_1.default.existsSync(tempPackDir))
+            node_fs_1.default.rmSync(tempPackDir, { recursive: true, force: true });
+    }
+    return {
+        packagesChecked,
+        tarballsInspected,
+        manifestsValidated,
+        cleanMachinePassed: errors.length === 0,
+        passed: errors.length === 0,
+        errors,
+    };
+}
+if (require.main === module) {
+    console.log('Running release:check verification...');
+    const report = runReleaseCheck();
+    console.log(`Packages checked: ${report.packagesChecked}`);
+    console.log(`Tarballs inspected: ${report.tarballsInspected}`);
+    console.log(`Manifests validated: ${report.manifestsValidated}`);
+    if (report.passed) {
+        console.log('✓ release:check PASS: All packages meet canonical release invariants.');
+        process.exitCode = 0;
+    }
+    else {
+        console.error('✗ release:check FAIL:');
+        for (const err of report.errors) {
+            console.error(`  - ${err}`);
+        }
+        process.exitCode = 1;
+    }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vxnus/siduri",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Experimental CLI for installing and configuring Siduri companions",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/vxnuslabs/siduri-y",
@@ -24,22 +24,23 @@
   },
   "main": "dist/index.js",
   "scripts": {
-    "build": "tsc && node scripts/build-runtime.cjs",
-    "dev": "tsc -w"
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest --config jest.config.json"
   },
   "dependencies": {
     "@vxnus/e": "^0.1.4",
     "@vxnus/e-knowledge": "^0.1.4",
-    "cors": "^2.8.5",
-    "express": "^4.18.2",
     "inquirer": "^9.2.12",
-    "pg": "^8.23.0",
-    "ws": "^8.21.3",
-    "zod": "^4.4.3"
+    "pg": "^8.23.0"
   },
   "devDependencies": {
-    "typescript": "^5.3.3",
     "@types/inquirer": "^9.0.7",
-    "esbuild": "^0.25.0"
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.19.43",
+    "@types/pg": "^8.21.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.3.3"
   }
 }