@bigking67/pi-67 0.10.0

package/src/lib/npm-registry.mjs

@@ -0,0 +1,288 @@
+import { captureCommand } from "./shell-runner.mjs";
+
+export function npmLatestVersion(packageName, options = {}) {
+  if (options.noRemote) {
+    return { skipped: true, ok: false, latestVersion: "", outdated: false, message: "remote checks skipped" };
+  }
+  const result = captureCommand("npm", ["view", packageName, "version", "--json"], {
+    timeoutMs: options.timeoutMs || 8000,
+  });
+  if (!result.ok) {
+    const rawMessage = result.stderr || result.error || "npm registry lookup failed";
+    return {
+      skipped: false,
+      ok: false,
+      latestVersion: "",
+      outdated: false,
+      message: rawMessage.includes("E404") ? "not published on npm registry yet" : compactMessage(rawMessage),
+    };
+  }
+  const latestVersion = parseNpmVersion(result.stdout);
+  return {
+    skipped: false,
+    ok: Boolean(latestVersion),
+    latestVersion,
+    outdated: latestVersion ? compareSemver(options.currentVersion || "", latestVersion) < 0 : false,
+    message: latestVersion ? "" : "npm registry returned no version",
+  };
+}
+
+export function npmPackageScopeStatus(packageName, options = {}) {
+  const scope = packageScope(packageName);
+  if (!scope) {
+    return {
+      skipped: false,
+      ok: true,
+      blocking: false,
+      scoped: false,
+      scope: "",
+      code: "unscoped",
+      message: "unscoped npm package",
+      probes: [],
+    };
+  }
+  if (options.noRemote) {
+    return {
+      skipped: true,
+      ok: false,
+      blocking: false,
+      scoped: true,
+      scope,
+      code: "skipped",
+      message: "remote scope check skipped",
+      probes: [],
+    };
+  }
+
+  const scopeName = scope.slice(1);
+  const accessResult = captureCommand("npm", ["access", "list", "packages", scope, "--json"], {
+    timeoutMs: options.timeoutMs || 8000,
+  });
+  const accessProbe = npmProbe("npm access list packages", accessResult);
+  if (accessResult.ok) {
+    const packages = parseJsonObject(accessResult.stdout);
+    const packageCount = packages ? Object.keys(packages).length : 0;
+    return {
+      skipped: false,
+      ok: true,
+      blocking: false,
+      scoped: true,
+      scope,
+      code: "scope_visible",
+      message: `npm scope ${scope} is visible via npm access list packages (${packageCount} packages)`,
+      probes: [accessProbe],
+    };
+  }
+
+  const accessMessage = accessResult.stderr || accessResult.stdout || accessResult.error || "npm scope lookup failed";
+  const missing = isMissingNpmResource(accessMessage);
+  const forbidden = isForbiddenNpmResource(accessMessage);
+  if (missing || forbidden) {
+    return {
+      skipped: false,
+      ok: false,
+      blocking: true,
+      scoped: true,
+      scope,
+      code: missing ? "scope_missing" : "scope_forbidden",
+      message: missing
+        ? `npm scope ${scope} was not found; create/claim the npm user or org before publishing`
+        : `npm scope ${scope} is not accessible to this publisher; verify npm ownership, collaborators, or trusted publisher setup`,
+      probes: [accessProbe],
+    };
+  }
+
+  const orgResult = captureCommand("npm", ["org", "ls", scopeName, "--json"], {
+    timeoutMs: options.timeoutMs || 8000,
+  });
+  const orgProbe = npmProbe("npm org ls", orgResult);
+  if (orgResult.ok) {
+    const orgPackages = parseJsonObject(orgResult.stdout);
+    const packageCount = orgPackages ? Object.keys(orgPackages).length : 0;
+    return {
+      skipped: false,
+      ok: true,
+      blocking: false,
+      scoped: true,
+      scope,
+      code: "scope_org_visible_access_probe_inconclusive",
+      message: `npm scope ${scope} is visible via npm org ls; package-access probe was inconclusive (${packageCount} org entries)`,
+      probes: [accessProbe, orgProbe],
+    };
+  }
+
+  const orgMessage = orgResult.stderr || orgResult.stdout || orgResult.error || "npm scope lookup failed";
+  const orgMissing = isMissingNpmResource(orgMessage);
+  return {
+    skipped: false,
+    ok: false,
+    blocking: orgMissing,
+    scoped: true,
+    scope,
+    code: orgMissing ? "scope_missing" : "scope_probe_failed",
+    message: orgMissing
+      ? `npm scope ${scope} was not found; create/claim the npm user or org before publishing`
+      : compactMessage(accessMessage),
+    probes: [accessProbe, orgProbe],
+  };
+}
+
+export function npmPublishTargetStatus(packageName, options = {}) {
+  if (options.noRemote) {
+    return {
+      skipped: true,
+      ok: false,
+      blocking: false,
+      packageName,
+      firstPublish: false,
+      allowFirstPublish: Boolean(options.allowFirstPublish),
+      code: "skipped",
+      message: "remote publish target check skipped",
+    };
+  }
+
+  const registry = options.registry || {};
+  const scope = options.scope || npmPackageScopeStatus(packageName, options);
+  const registryLookupFailed = !registry.skipped && !registry.ok && registry.message !== "not published on npm registry yet";
+  const firstPublish = !registry.skipped && !registry.ok && registry.message === "not published on npm registry yet";
+
+  if (registryLookupFailed) {
+    return {
+      skipped: false,
+      ok: false,
+      blocking: true,
+      packageName,
+      firstPublish: false,
+      allowFirstPublish: Boolean(options.allowFirstPublish),
+      code: "registry_lookup_failed",
+      message: `npm registry lookup failed for ${packageName}: ${compactMessage(registry.message)}`,
+    };
+  }
+
+  if (scope.blocking && firstPublish && options.allowFirstPublish && scope.code === "scope_missing") {
+    return {
+      skipped: false,
+      ok: true,
+      blocking: false,
+      packageName,
+      firstPublish: true,
+      allowFirstPublish: true,
+      code: "first_publish_scope_probe_confirmed",
+      message: `first publish for ${packageName} explicitly confirmed; npm publish remains the authority for new-scope write permission`,
+    };
+  }
+
+  if (scope.blocking) {
+    return {
+      skipped: false,
+      ok: false,
+      blocking: true,
+      packageName,
+      firstPublish,
+      allowFirstPublish: Boolean(options.allowFirstPublish),
+      code: scope.code || "scope_blocked",
+      message: scope.message,
+    };
+  }
+
+  if (firstPublish && !options.allowFirstPublish) {
+    return {
+      skipped: false,
+      ok: false,
+      blocking: true,
+      packageName,
+      firstPublish: true,
+      allowFirstPublish: false,
+      code: "first_publish_requires_confirmation",
+      message: `first publish for ${packageName} requires explicit --allow-first-publish after npm scope and Trusted Publisher are configured`,
+    };
+  }
+
+  if (firstPublish) {
+    return {
+      skipped: false,
+      ok: true,
+      blocking: false,
+      packageName,
+      firstPublish: true,
+      allowFirstPublish: true,
+      code: "first_publish_confirmed",
+      message: `first publish for ${packageName} explicitly confirmed; npm will validate Trusted Publisher only during npm publish`,
+    };
+  }
+
+  return {
+    skipped: false,
+    ok: true,
+    blocking: false,
+    packageName,
+    firstPublish: false,
+    allowFirstPublish: Boolean(options.allowFirstPublish),
+    code: "published_package_target_ready",
+    message: `npm publish target ${packageName} is already present on the registry`,
+  };
+}
+
+function packageScope(packageName) {
+  const match = String(packageName || "").match(/^(@[^/]+)\//);
+  return match ? match[1] : "";
+}
+
+function parseNpmVersion(value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return "";
+  try {
+    const parsed = JSON.parse(trimmed);
+    return typeof parsed === "string" ? parsed : "";
+  } catch {
+    return trimmed.replace(/^"|"$/g, "");
+  }
+}
+
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(String(value || "").trim() || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function npmProbe(name, result) {
+  return {
+    name,
+    ok: Boolean(result.ok),
+    status: typeof result.status === "number" ? result.status : null,
+    message: result.ok ? "ok" : compactMessage(result.stderr || result.stdout || result.error || "failed"),
+  };
+}
+
+function isMissingNpmResource(message) {
+  const value = String(message || "");
+  return value.includes("Scope not found") || value.includes("E404") || value.includes("Not Found");
+}
+
+function isForbiddenNpmResource(message) {
+  const value = String(message || "");
+  return value.includes("E403") || value.includes("Forbidden");
+}
+
+export function compareSemver(left, right) {
+  const a = semverParts(left);
+  const b = semverParts(right);
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+}
+
+function semverParts(value) {
+  const match = String(value || "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return [0, 0, 0];
+  return match.slice(1).map((part) => Number(part));
+}
+
+function compactMessage(value) {
+  const line = String(value || "").split(/\r?\n/).find((item) => item.trim()) || "";
+  return line.trim().slice(0, 240);
+}

package/src/lib/output.mjs

@@ -0,0 +1,35 @@
+export class CliError extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+export function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function section(title) {
+  process.stdout.write(`\n${title}\n`);
+}
+
+export function pass(message) {
+  process.stdout.write(`  PASS ${message}\n`);
+}
+
+export function warn(message) {
+  process.stdout.write(`  WARN ${message}\n`);
+}
+
+export function info(message) {
+  process.stdout.write(`  INFO ${message}\n`);
+}
+
+export function fail(message) {
+  process.stdout.write(`  FAIL ${message}\n`);
+}
+
+export function keyValue(label, value) {
+  process.stdout.write(`${label.padEnd(18)}: ${value ?? ""}\n`);
+}

package/src/lib/paths.mjs

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const DEFAULT_REPO_URL = "https://github.com/bigKING67/pi-67.git";
+
+export function packageRoot() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+
+export function readCliPackageJson() {
+  const file = path.join(packageRoot(), "package.json");
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+export function expandHome(input) {
+  if (!input) return input;
+  if (input === "~") return os.homedir();
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+
+export function resolveContext(globalOptions = {}) {
+  const agentDir = path.resolve(expandHome(
+    globalOptions.agentDir ||
+      process.env.PI67_AGENT_DIR ||
+      process.env.PI_CODING_AGENT_DIR ||
+      path.join(os.homedir(), ".pi", "agent"),
+  ));
+  const repoRoot = path.resolve(expandHome(globalOptions.repoRoot || agentDir));
+  const skillsDir = path.resolve(expandHome(
+    globalOptions.skillsDir ||
+      process.env.PI67_SKILLS_DIR ||
+      path.join(os.homedir(), ".agents", "skills"),
+  ));
+  const packagesDir = path.resolve(expandHome(
+    globalOptions.packagesDir ||
+      process.env.PI67_PACKAGES_DIR ||
+      path.join(os.homedir(), ".agents", "packages"),
+  ));
+  const stateDir = path.join(os.homedir(), ".pi", "pi67");
+  return {
+    agentDir,
+    repoRoot,
+    skillsDir,
+    packagesDir,
+    stateDir,
+    reportsDir: path.join(stateDir, "reports"),
+    logsDir: path.join(stateDir, "logs"),
+    json: Boolean(globalOptions.json),
+    dryRun: Boolean(globalOptions.dryRun),
+    yes: Boolean(globalOptions.yes),
+    noRemote: Boolean(globalOptions.noRemote),
+  };
+}
+
+export function scriptPath(ctx, scriptName) {
+  return path.join(ctx.repoRoot, "scripts", scriptName);
+}
+
+export function pathExists(file) {
+  try {
+    fs.accessSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readTextIfExists(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}

package/src/lib/platform.mjs

@@ -0,0 +1,27 @@
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+
+export function isWindows() {
+  return process.platform === "win32";
+}
+
+export function platformName() {
+  return `${process.platform}-${os.arch()}`;
+}
+
+export function commandExists(name) {
+  const result = isWindows()
+    ? spawnSync("where.exe", [name], { encoding: "utf8" })
+    : spawnSync("sh", ["-lc", `command -v ${shellQuote(name)}`], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+export function findPowerShell() {
+  if (commandExists("pwsh")) return "pwsh";
+  if (commandExists("powershell")) return "powershell";
+  return "";
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}

package/src/lib/shell-runner.mjs

@@ -0,0 +1,40 @@
+import { spawnSync } from "node:child_process";
+import { CliError, info } from "./output.mjs";
+
+export function runCommand(command, args = [], options = {}) {
+  const cwd = options.cwd || process.cwd();
+  if (options.dryRun) {
+    info(`DRY-RUN (${cwd}) ${[command, ...args].join(" ")}`);
+    return { status: 0, stdout: "", stderr: "" };
+  }
+  const result = spawnSync(command, args, {
+    cwd,
+    stdio: options.stdio || "inherit",
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: "utf8",
+    timeout: options.timeoutMs,
+  });
+  if (result.error) {
+    throw new CliError(`failed to run ${command}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new CliError(`${command} exited with ${result.status}`, result.status || 1);
+  }
+  return result;
+}
+
+export function captureCommand(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || process.cwd(),
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: "utf8",
+    timeout: options.timeoutMs,
+  });
+  return {
+    ok: result.status === 0 && !result.error,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? result.error.message : "",
+  };
+}

package/src/lib/skill-policy.mjs

@@ -0,0 +1,85 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export function inventorySkills(ctx) {
+  const sourceRoot = path.join(ctx.repoRoot, "shared-skills");
+  const sourceNames = listSkillDirs(sourceRoot);
+  const entries = sourceNames.map((name) => {
+    const source = path.join(sourceRoot, name);
+    const target = path.join(ctx.skillsDir, name);
+    const sourceHash = hashDir(source);
+    const targetExists = fs.existsSync(target);
+    const targetHash = targetExists ? hashDir(target) : "";
+    const identical = targetExists && sourceHash === targetHash;
+    const conflict = targetExists && !identical;
+    return { name, source, target, sourceHash, targetExists, targetHash, identical, conflict };
+  });
+  return {
+    schema: "pi67.skills-inventory.v1",
+    sourceRoot,
+    skillsDir: ctx.skillsDir,
+    summary: {
+      source: entries.length,
+      missing: entries.filter((entry) => !entry.targetExists).length,
+      identical: entries.filter((entry) => entry.identical).length,
+      conflicts: entries.filter((entry) => entry.conflict).length,
+    },
+    entries,
+  };
+}
+
+export function syncSkills(ctx, { dryRun = false } = {}) {
+  const inventory = inventorySkills(ctx);
+  const actions = [];
+  fs.mkdirSync(ctx.skillsDir, { recursive: true });
+  for (const entry of inventory.entries) {
+    if (entry.identical) {
+      actions.push({ name: entry.name, action: "skip", reason: "identical" });
+      continue;
+    }
+    if (entry.conflict) {
+      actions.push({ name: entry.name, action: "warn", reason: "target differs; preserved" });
+      continue;
+    }
+    actions.push({ name: entry.name, action: dryRun ? "copy-dry-run" : "copy", reason: "missing" });
+    if (!dryRun) {
+      fs.cpSync(entry.source, entry.target, { recursive: true, errorOnExist: true });
+    }
+  }
+  return { ...inventory, actions };
+}
+
+function listSkillDirs(root) {
+  if (!fs.existsSync(root)) return [];
+  return fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(root, entry.name, "SKILL.md")))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function hashDir(root) {
+  if (!fs.existsSync(root)) return "";
+  const hash = crypto.createHash("sha256");
+  const files = [];
+  walk(root, files);
+  for (const file of files.sort()) {
+    const rel = path.relative(root, file).replace(/\\/g, "/");
+    hash.update(rel);
+    hash.update("\0");
+    hash.update(fs.readFileSync(file));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+function walk(dir, files) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(full, files);
+    } else if (entry.isFile()) {
+      files.push(full);
+    }
+  }
+}

package/src/lib/state-store.mjs

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+import { gitStatus } from "./git.mjs";
+import { currentTheme } from "./theme-policy.mjs";
+import { readJsonFileIfExists, writeJsonAtomic } from "./config-json.mjs";
+import { readCliPackageJson, readTextIfExists } from "./paths.mjs";
+
+export function writeState(ctx, operation) {
+  const pkg = readCliPackageJson();
+  const git = gitStatus(ctx.repoRoot);
+  const settings = readJsonFileIfExists(path.join(ctx.agentDir, "settings.json")) || {};
+  const state = {
+    schema: "pi67.state.v1",
+    updatedAt: new Date().toISOString(),
+    operation,
+    managerPackage: pkg.name,
+    managerVersion: pkg.version,
+    agentDir: ctx.agentDir,
+    repoRoot: ctx.repoRoot,
+    skillsDir: ctx.skillsDir,
+    packagesDir: ctx.packagesDir,
+    lastKnownVersion: readTextIfExists(path.join(ctx.repoRoot, "VERSION")).trim(),
+    lastKnownCommit: git.commit || "",
+    lastTheme: currentTheme(ctx),
+    lastProvider: settings.defaultProvider || "",
+    lastModel: settings.defaultModel || "",
+  };
+  fs.mkdirSync(ctx.stateDir, { recursive: true });
+  writeJsonAtomic(path.join(ctx.stateDir, "state.json"), state);
+  return state;
+}

package/src/lib/theme-policy.mjs

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readJsonFileIfExists } from "./config-json.mjs";
+
+const THEME_PACKAGE = "@victor-software-house/pi-curated-themes";
+
+export function currentTheme(ctx) {
+  const settings = readJsonFileIfExists(path.join(ctx.agentDir, "settings.json")) || {};
+  return settings.theme || "";
+}
+
+export function themeDirs(ctx) {
+  return [
+    path.join(ctx.agentDir, "npm", "node_modules", THEME_PACKAGE, "themes"),
+    path.join(ctx.repoRoot, "npm", "node_modules", THEME_PACKAGE, "themes"),
+  ];
+}
+
+export function listThemes(ctx) {
+  const names = new Set();
+  for (const dir of themeDirs(ctx)) {
+    if (!fs.existsSync(dir)) continue;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        names.add(entry.name.replace(/\.json$/, ""));
+      }
+    }
+  }
+  return [...names].sort();
+}
+
+export function hasTheme(ctx, name) {
+  return listThemes(ctx).includes(name);
+}