takomi 2.1.2 → 2.1.4

package/src/skills-installer.js

@@ -1,101 +1,101 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import crypto from 'crypto';
-import pc from 'picocolors';
-import { PATHS } from './utils.js';
-
-const HOME = os.homedir();
-const TAKOMI_HOME = path.join(HOME, '.takomi');
-export const SKILLS_MANIFEST_PATH = path.join(TAKOMI_HOME, 'skills-manifest.json');
-export const SKILLS_ROOT = path.join(HOME, '.agents', 'skills');
-
-function sha256(value) {
-  return crypto.createHash('sha256').update(value).digest('hex');
-}
-
-async function hashDirectory(dir) {
-  if (!await fs.pathExists(dir)) return null;
-  const entries = [];
-  async function walk(current, prefix = '') {
-    const names = (await fs.readdir(current)).sort();
-    for (const name of names) {
-      const full = path.join(current, name);
-      const rel = path.join(prefix, name).replace(/\\/g, '/');
-      const stat = await fs.stat(full);
-      if (stat.isDirectory()) {
-        entries.push(`dir:${rel}`);
-        await walk(full, rel);
-      } else {
-        entries.push(`file:${rel}:${sha256(await fs.readFile(full))}`);
-      }
-    }
-  }
-  await walk(dir);
-  return sha256(entries.join('\n'));
-}
-
-async function listBundledSkills() {
-  const entries = await fs.readdir(PATHS.skills);
-  const skills = [];
-  for (const entry of entries) {
-    const stat = await fs.stat(path.join(PATHS.skills, entry));
-    if (stat.isDirectory()) skills.push(entry);
-  }
-  return skills.sort();
-}
-
-export async function readSkillsInstallManifest() {
-  try {
-    if (await fs.pathExists(SKILLS_MANIFEST_PATH)) return await fs.readJson(SKILLS_MANIFEST_PATH);
-  } catch {}
-  return null;
-}
-
-export async function writeSkillsInstallManifest(manifest) {
-  await fs.ensureDir(TAKOMI_HOME);
-  await fs.writeJson(SKILLS_MANIFEST_PATH, manifest, { spaces: 2 });
-}
-
-export async function installBundledSkills(version = 'unknown') {
-  const skillNames = await listBundledSkills();
-  await fs.ensureDir(SKILLS_ROOT);
-
-  const installed = {};
-  for (const name of skillNames) {
-    const src = path.join(PATHS.skills, name);
-    const dest = path.join(SKILLS_ROOT, name);
-    if (await fs.pathExists(dest)) {
-      await fs.remove(dest);
-    }
-    await fs.copy(src, dest, { overwrite: true, errorOnExist: false });
-    installed[name] = await hashDirectory(dest);
-  }
-
-  const manifest = {
-    takomiVersion: version,
-    installedAt: new Date().toISOString(),
-    targetRoot: SKILLS_ROOT,
-    owned: installed,
-  };
-
-  await writeSkillsInstallManifest(manifest);
-  return { targetRoot: SKILLS_ROOT, manifest, count: skillNames.length };
-}
-
-export async function validateSkillsInstall() {
-  const names = await listBundledSkills();
-  const missing = [];
-  for (const name of names) {
-    if (!await fs.pathExists(path.join(SKILLS_ROOT, name))) missing.push(name);
-  }
-  return { root: SKILLS_ROOT, expected: names.length, missing, ok: missing.length === 0 };
-}
-
-export function printSkillsInstallSummary(result, validation) {
-  console.log(pc.green('\n✔ Installed bundled Takomi skills'));
-  console.log(pc.white(`  Root:     ${result.targetRoot}`));
-  console.log(pc.white(`  Manifest: ${SKILLS_MANIFEST_PATH}`));
-  console.log(pc.white(`  Count:    ${result.count}`));
-  console.log(pc.white(`  Status:   ${validation.ok ? 'ok' : `missing ${validation.missing.length}`}`));
-}
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import pc from 'picocolors';
+import { PATHS } from './utils.js';
+
+const HOME = os.homedir();
+const TAKOMI_HOME = path.join(HOME, '.takomi');
+export const SKILLS_MANIFEST_PATH = path.join(TAKOMI_HOME, 'skills-manifest.json');
+export const SKILLS_ROOT = path.join(HOME, '.agents', 'skills');
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+async function hashDirectory(dir) {
+  if (!await fs.pathExists(dir)) return null;
+  const entries = [];
+  async function walk(current, prefix = '') {
+    const names = (await fs.readdir(current)).sort();
+    for (const name of names) {
+      const full = path.join(current, name);
+      const rel = path.join(prefix, name).replace(/\\/g, '/');
+      const stat = await fs.stat(full);
+      if (stat.isDirectory()) {
+        entries.push(`dir:${rel}`);
+        await walk(full, rel);
+      } else {
+        entries.push(`file:${rel}:${sha256(await fs.readFile(full))}`);
+      }
+    }
+  }
+  await walk(dir);
+  return sha256(entries.join('\n'));
+}
+
+async function listBundledSkills() {
+  const entries = await fs.readdir(PATHS.skills);
+  const skills = [];
+  for (const entry of entries) {
+    const stat = await fs.stat(path.join(PATHS.skills, entry));
+    if (stat.isDirectory()) skills.push(entry);
+  }
+  return skills.sort();
+}
+
+export async function readSkillsInstallManifest() {
+  try {
+    if (await fs.pathExists(SKILLS_MANIFEST_PATH)) return await fs.readJson(SKILLS_MANIFEST_PATH);
+  } catch {}
+  return null;
+}
+
+export async function writeSkillsInstallManifest(manifest) {
+  await fs.ensureDir(TAKOMI_HOME);
+  await fs.writeJson(SKILLS_MANIFEST_PATH, manifest, { spaces: 2 });
+}
+
+export async function installBundledSkills(version = 'unknown') {
+  const skillNames = await listBundledSkills();
+  await fs.ensureDir(SKILLS_ROOT);
+
+  const installed = {};
+  for (const name of skillNames) {
+    const src = path.join(PATHS.skills, name);
+    const dest = path.join(SKILLS_ROOT, name);
+    if (await fs.pathExists(dest)) {
+      await fs.remove(dest);
+    }
+    await fs.copy(src, dest, { overwrite: true, errorOnExist: false });
+    installed[name] = await hashDirectory(dest);
+  }
+
+  const manifest = {
+    takomiVersion: version,
+    installedAt: new Date().toISOString(),
+    targetRoot: SKILLS_ROOT,
+    owned: installed,
+  };
+
+  await writeSkillsInstallManifest(manifest);
+  return { targetRoot: SKILLS_ROOT, manifest, count: skillNames.length };
+}
+
+export async function validateSkillsInstall() {
+  const names = await listBundledSkills();
+  const missing = [];
+  for (const name of names) {
+    if (!await fs.pathExists(path.join(SKILLS_ROOT, name))) missing.push(name);
+  }
+  return { root: SKILLS_ROOT, expected: names.length, missing, ok: missing.length === 0 };
+}
+
+export function printSkillsInstallSummary(result, validation) {
+  console.log(pc.green('\n✔ Installed bundled Takomi skills'));
+  console.log(pc.white(`  Root:     ${result.targetRoot}`));
+  console.log(pc.white(`  Manifest: ${SKILLS_MANIFEST_PATH}`));
+  console.log(pc.white(`  Count:    ${result.count}`));
+  console.log(pc.white(`  Status:   ${validation.ok ? 'ok' : `missing ${validation.missing.length}`}`));
+}

package/src/update-check.js

@@ -0,0 +1,140 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import https from 'https';
+import { spawnSync } from 'child_process';
+import pc from 'picocolors';
+
+const CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const CACHE_PATH = path.join(os.homedir(), '.takomi', 'update-check.json');
+const REGISTRY_URL = 'https://registry.npmjs.org/takomi/latest';
+
+function parseVersion(version = '') {
+  const [core] = String(version).replace(/^v/, '').split('-');
+  return core.split('.').map((part) => Number.parseInt(part, 10) || 0);
+}
+
+export function isNewerVersion(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const left = a[i] || 0;
+    const right = b[i] || 0;
+    if (left > right) return true;
+    if (left < right) return false;
+  }
+  return false;
+}
+
+function fetchLatestPackageInfo(timeoutMs = 2500) {
+  return new Promise((resolve) => {
+    const req = https.get(REGISTRY_URL, {
+      headers: {
+        'accept': 'application/json',
+        'user-agent': 'takomi-update-check',
+      },
+      timeout: timeoutMs,
+    }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode && res.statusCode >= 400) return resolve(null);
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', () => resolve(null));
+  });
+}
+
+async function readCache() {
+  try {
+    return await fs.readJson(CACHE_PATH);
+  } catch {
+    return null;
+  }
+}
+
+async function writeCache(cache) {
+  try {
+    await fs.ensureDir(path.dirname(CACHE_PATH));
+    await fs.writeJson(CACHE_PATH, cache, { spaces: 2 });
+  } catch {
+    // Update checks must never block normal Takomi startup.
+  }
+}
+
+export async function getLatestTakomiVersion({ currentVersion, force = false } = {}) {
+  const now = Date.now();
+  const cache = await readCache();
+  if (!force && cache?.checkedAt && now - cache.checkedAt < CHECK_INTERVAL_MS) {
+    return cache;
+  }
+
+  const info = await fetchLatestPackageInfo();
+  const latestVersion = typeof info?.version === 'string' ? info.version : null;
+  const next = {
+    checkedAt: now,
+    currentVersion,
+    latestVersion,
+    updateAvailable: Boolean(latestVersion && currentVersion && isNewerVersion(latestVersion, currentVersion)),
+  };
+  await writeCache(next);
+  return next;
+}
+
+export function notifyIfTakomiUpdateAvailable(currentVersion) {
+  if (process.env.TAKOMI_NO_UPDATE_CHECK === '1') return;
+
+  // Fire-and-forget by design: launching the Takomi harness must never wait on
+  // network, DNS, npm registry latency, or cache file IO.
+  setTimeout(() => {
+    getLatestTakomiVersion({ currentVersion })
+      .then((result) => {
+        if (!result?.updateAvailable) return;
+        console.log(pc.yellow(`\n⬆ Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
+        console.log(pc.dim('  Run: takomi upgrade'));
+        console.log(pc.dim('  Disable this check with TAKOMI_NO_UPDATE_CHECK=1.\n'));
+      })
+      .catch(() => {
+        // Silent: update checks must never affect harness startup or usage.
+      });
+  }, 0).unref?.();
+}
+
+export async function printTakomiUpdateStatus(currentVersion) {
+  const result = await getLatestTakomiVersion({ currentVersion, force: true });
+  if (!result?.latestVersion) {
+    console.log(pc.yellow('Could not check the npm registry for Takomi updates.'));
+    return;
+  }
+  if (result.updateAvailable) {
+    console.log(pc.yellow(`Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
+    console.log(pc.dim('Run: takomi upgrade'));
+    return;
+  }
+  console.log(pc.green(`Takomi is up to date (${currentVersion}).`));
+}
+
+export function upgradeTakomiPackage() {
+  console.log(pc.cyan('Updating Takomi from npm...\n'));
+  const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const result = spawnSync(command, ['install', '-g', 'takomi@latest'], {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+  if (result.status === 0) {
+    console.log(pc.green('\nTakomi updated. Run `takomi --version` to confirm.'));
+    return 0;
+  }
+  console.log(pc.red('\nTakomi update failed. Try manually: npm install -g takomi@latest'));
+  return result.status || 1;
+}