invos 1.0.0 → 2.0.2

package/src/commands/init.js

@@ -1,44 +1,55 @@
-import { existsSync, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { collectFiles, copyFileWithDirs, ensureDir } from '../utils.js';
+import { existsSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
+import { collectFiles, copyFileWithDirs, ensureDir, isDevPath } from '../utils.js';
 import { buildLock, writeLock } from '../lock.js';
 import { syncClaudeSymlinks } from '../symlinks.js';
 
 export async function init(kit, kitRoot, args) {
-  const idx = args.indexOf('--dir');
-  let targetDir;
-  if (idx !== -1 && args[idx + 1]) {
-    targetDir = resolve(process.cwd(), args[idx + 1]);
-  } else {
-    targetDir = resolve(process.cwd(), args[0] || '.');
+  let name = null;
+  let targetDir = null;
+  const rest = [...args];
+
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === '--name' && rest[i + 1]) {
+      name = rest[i + 1];
+      rest.splice(i, 2);
+      i--;
+    } else if (rest[i] === '--dir' && rest[i + 1]) {
+      targetDir = resolve(process.cwd(), rest[i + 1]);
+      rest.splice(i, 2);
+      i--;
+    }
   }
 
-  if (targetDir === '.' || !args[0]) {
-    targetDir = process.cwd();
+  if (!targetDir) {
+    const slug = name || rest[0];
+    targetDir = slug && slug !== '.'
+      ? resolve(process.cwd(), slug)
+      : process.cwd();
   }
 
-  if (existsSync(targetDir) && targetDir !== process.cwd()) {
-    console.error(`Directory ${targetDir} already exists. Use install for existing projects.`);
+  if (existsSync(resolve(targetDir, 'AGENTS.md')) && existsSync(resolve(targetDir, 'INVOS-LOCK.json'))) {
+    console.error('Já parece INVOS. Use: npx invos install --dir', targetDir);
     process.exit(1);
   }
 
   ensureDir(targetDir);
-  const files = collectFiles(kitRoot, '', true);
-
-  let count = 0;
+  const files = collectFiles(kitRoot, '', true).filter(f => !isDevPath(f.relPath));
+  let n = 0;
   for (const f of files) {
     const dest = resolve(targetDir, f.relPath);
-    copyFileWithDirs(f.fullPath, dest);
-    count++;
+    if (!existsSync(dest)) {
+      copyFileWithDirs(f.fullPath, dest);
+      n++;
+    }
   }
 
-  // Generate lock
-  const lock = buildLock(kitRoot, targetDir);
+  const lock = buildLock(kitRoot, kit.version || '2.0.0');
   writeLock(targetDir, lock);
-
-  // Symlinks
   syncClaudeSymlinks(kitRoot, targetDir);
 
-  console.log(`✓ invos init complete — ${count} files in ${targetDir}`);
-  console.log('  Run: cd ' + targetDir + ' && npx invos doctor');
+  console.log(`✓ invos init — ${n} files → ${targetDir}`);
+  console.log(`  kit ${kit.version || '?'}`);
+  console.log(`  Next: open folder → /instalar`);
+  console.log(`  Doctor: npx invos doctor --dir ${basename(targetDir)}`);
 }

package/src/commands/install.js

@@ -1,41 +1,37 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { collectFiles, copyFileWithDirs, shouldCopyOnInstall, ensureDir, isDevPath } from '../utils.js';
+import {
+  collectFiles, copyFileWithDirs, shouldCopyOnInstall, isDevPath,
+} from '../utils.js';
 import { buildLock, readLock, writeLock } from '../lock.js';
 import { syncClaudeSymlinks } from '../symlinks.js';
 
-export async function install(kit, kitRoot, targetDir, args) {
-  // Collect ALL kit files (skip user-data denylist) then filter out dev infra
-  const allFiles = collectFiles(kitRoot, '', true);
-  const files = allFiles.filter(f => !isDevPath(f.relPath));
+export async function install(kit, kitRoot, targetDir) {
+  const files = collectFiles(kitRoot, '', true).filter(f => !isDevPath(f.relPath));
   let copied = 0;
   let skipped = 0;
 
   for (const f of files) {
     const dest = resolve(targetDir, f.relPath);
-    if (shouldCopyOnInstall(dest)) {
-      if (!existsSync(dest)) {
-        ensureDir(dest.substring(0, dest.lastIndexOf('/')) || dest);
-      }
+    if (shouldCopyOnInstall(dest) && !existsSync(dest)) {
       copyFileWithDirs(f.fullPath, dest);
       copied++;
-    } else {
+    } else if (existsSync(dest) && !shouldCopyOnInstall(dest)) {
+      skipped++;
+    } else if (existsSync(dest)) {
       skipped++;
+    } else {
+      copyFileWithDirs(f.fullPath, dest);
+      copied++;
     }
   }
 
-  // Lock file (merge with existing)
-  const existingLock = readLock(targetDir);
-  const lock = buildLock(kitRoot, targetDir, existingLock?.custom || {});
-  if (existingLock) {
-    lock.installedAt = existingLock.installedAt;
-    lock.custom = existingLock.custom || {};
-  }
+  const existing = readLock(targetDir);
+  const lock = buildLock(kitRoot, kit.version || '2.0.0', existing?.custom || {});
+  if (existing?.installedAt) lock.installedAt = existing.installedAt;
   writeLock(targetDir, lock);
-
-  // Symlinks
   syncClaudeSymlinks(kitRoot, targetDir);
 
-  console.log(`✓ invos install — ${copied} files copied, ${skipped} skipped (kept user data)`);
+  console.log(`✓ invos install — ${copied} new, ${skipped} kept`);
   console.log('  Run: npx invos doctor');
 }

package/src/commands/update.js

@@ -1,70 +1,53 @@
-import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { collectFiles, copyFileWithDirs, shouldOverwriteOnUpdate, sha256File, isDenylisted, isTemplatePlaceholder } from '../utils.js';
+import {
+  collectFiles, copyFileWithDirs, shouldOverwriteOnUpdate,
+  sha256File, isDenylisted, isDevPath,
+} from '../utils.js';
 import { readLock, updateLockShipped, writeLock } from '../lock.js';
 import { syncClaudeSymlinks } from '../symlinks.js';
 
 export async function update(kit, kitRoot, targetDir, args) {
   const dryRun = args.includes('--dry-run');
   const lock = readLock(targetDir);
-
   if (!lock) {
-    console.error('INVOS-LOCK.json not found. Run install first.');
+    console.error('INVOS-LOCK.json missing. Run: npx invos install');
     process.exit(1);
   }
 
-  const files = collectFiles(kitRoot, '');
+  console.log(`  source: ${kitRoot} (bundled/local — no token)`);
+
+  const files = collectFiles(kitRoot, '', true).filter(f => !isDevPath(f.relPath));
   let updated = 0;
   let skipped = 0;
-  let agentsBackedUp = false;
+  let agentsNote = false;
 
   for (const f of files) {
-    const dest = resolve(targetDir, f.relPath);
     const rel = f.relPath;
+    const dest = resolve(targetDir, rel);
 
-    // USER denylist check
     if (isDenylisted(rel)) {
       skipped++;
       continue;
     }
 
-    // Special: AGENTS.md custom handling
     if (rel === 'AGENTS.md' && existsSync(dest)) {
-      const shippedSha = sha256File(f.fullPath);
-      const localSha = sha256File(dest);
-      const customDecision = lock.custom?.['AGENTS.md'];
-
-      if (localSha !== shippedSha) {
-        if (customDecision === 'skip') {
+      const a = sha256File(f.fullPath);
+      const b = sha256File(dest);
+      if (a !== b) {
+        const decision = lock.custom?.['AGENTS.md'];
+        if (decision === 'replace') {
           if (!dryRun) {
-            const bakPath = resolve(targetDir, 'AGENTS.md.shipped.bak');
-            writeFileSync(bakPath, readFileSync(f.fullPath));
-            console.warn('⚠️  AGENTS.md custom — backup em AGENTS.md.shipped.bak (respecting skip lock)');
-            agentsBackedUp = true;
-          }
-          skipped++;
-          continue;
-        }
-        if (customDecision === 'replace' || !existsSync(dest)) {
-          // Replace: just overwrite (handled below)
-          if (!dryRun) {
-            const bakPath = resolve(targetDir, 'AGENTS.md.shipped.bak');
-            writeFileSync(bakPath, readFileSync(dest));
-            console.warn('⚠️  AGENTS.md custom — backup em AGENTS.md.shipped.bak (replacing)');
-            agentsBackedUp = true;
+            writeFileSync(resolve(targetDir, 'AGENTS.md.local.bak'), readFileSync(dest));
+            console.warn('⚠️  AGENTS.md → replace (local.bak)');
           }
         } else {
-          // First time seeing divergence — warn and skip
           if (!dryRun) {
-            const bakPath = resolve(targetDir, 'AGENTS.md.shipped.bak');
-            writeFileSync(bakPath, readFileSync(f.fullPath));
-            console.warn('⚠️  AGENTS.md custom — backup em AGENTS.md.shipped.bak');
-            console.warn('  Next update will respect lock. Run again with --dry-run after setting:');
-            console.warn('  "invos update" → replace | "invos update --skip-agents" → skip');
-
-            // Write to lock: ask user decision
+            writeFileSync(resolve(targetDir, 'AGENTS.md.shipped.bak'), readFileSync(f.fullPath));
             lock.custom = lock.custom || {};
-            lock.custom['AGENTS.md'] = 'skip'; // default skip after first backup
+            lock.custom['AGENTS.md'] = 'skip';
+            console.warn('⚠️  AGENTS.md custom — shipped.bak; skip (lock)');
+            agentsNote = true;
           }
           skipped++;
           continue;
@@ -72,42 +55,21 @@ export async function update(kit, kitRoot, targetDir, args) {
       }
     }
 
-    // Skip if template placeholder only (for SEED files on UPDATE — e.g., marca/marca.md)
-    if (existsSync(dest) && shouldSkipSeedPlaceholder(rel, dest)) {
-      skipped++;
-      continue;
-    }
-
-    // Overwrite PRODUCT files
-    if (!existsSync(dest) || shouldOverwriteOnUpdate(rel, dest, lock)) {
-      if (!dryRun) {
-        copyFileWithDirs(f.fullPath, dest);
-      }
+    if (!existsSync(dest) || shouldOverwriteOnUpdate(rel, dest)) {
+      if (!dryRun) copyFileWithDirs(f.fullPath, dest);
       updated++;
     } else {
       skipped++;
     }
   }
 
-  // Update lock
   if (!dryRun) {
-    updateLockShipped(kitRoot, lock);
+    updateLockShipped(kitRoot, lock, kit.version);
     writeLock(targetDir, lock);
     syncClaudeSymlinks(kitRoot, targetDir);
   }
 
-  console.log(`✓ invos update${dryRun ? ' (dry-run)' : ''} — ${updated} files updated, ${skipped} skipped`);
-  if (agentsBackedUp) console.log('  AGENTS.md backup created');
-  if (dryRun) console.log('  Run without --dry-run to apply');
-}
-
-function shouldSkipSeedPlaceholder(rel, destPath) {
-  // Only skip template files that are STILL placeholders
-  const templateFiles = ['marca/marca.md', 'memoria/perfil.md', 'memoria/empresa.md'];
-  if (!templateFiles.includes(rel)) return false;
-
-  const content = readFileSync(destPath, 'utf-8');
-  const templateMarkers = ['[o que', '[seu nome]', 'PREENCHA', 'primeira sessão'];
-  const lower = content.toLowerCase();
-  return !templateMarkers.some(m => lower.includes(m));
+  console.log(`✓ invos update${dryRun ? ' (dry-run)' : ''} — ${updated} updated, ${skipped} skipped (USER ok)`);
+  console.log(`  kit ${kit.version || '?'}`);
+  if (agentsNote) console.log('  set INVOS-LOCK custom.AGENTS.md=replace to force AGENTS');
 }

package/src/lock.js

@@ -1,38 +1,35 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { sha256File, collectFiles, isDenylisted } from './utils.js';
-import { loadManifest } from './manifest.js';
+import { sha256File, collectFiles } from './utils.js';
 
 export function readLock(targetDir) {
   const path = resolve(targetDir, 'INVOS-LOCK.json');
   if (!existsSync(path)) return null;
   try {
-    return JSON.parse(readFileSync(path, 'utf-8'));
+    return JSON.parse(readFileSync(path, 'utf8'));
   } catch {
     return null;
   }
 }
 
 export function writeLock(targetDir, data) {
-  const path = resolve(targetDir, 'INVOS-LOCK.json');
-  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+  writeFileSync(resolve(targetDir, 'INVOS-LOCK.json'), JSON.stringify(data, null, 2) + '\n');
 }
 
 export function computeShippedSha(kitRoot) {
-  const files = collectFiles(kitRoot, '', true);
   const shipped = {};
-  // INVOS.json itself
   shipped['INVOS.json'] = sha256File(resolve(kitRoot, 'INVOS.json'));
-  for (const f of files) {
+  for (const f of collectFiles(kitRoot, '', true)) {
+    if (f.relPath.startsWith('packages/')) continue;
     shipped[f.relPath] = sha256File(f.fullPath);
   }
   return shipped;
 }
 
-export function buildLock(kitRoot, targetDir, custom = {}) {
+export function buildLock(kitRoot, kitVersion = '2.0.0', custom = {}) {
   const now = new Date().toISOString();
   return {
-    version: '1.0.0',
+    version: kitVersion,
     shippedSha: computeShippedSha(kitRoot),
     custom,
     installedAt: now,
@@ -40,8 +37,9 @@ export function buildLock(kitRoot, targetDir, custom = {}) {
   };
 }
 
-export function updateLockShipped(kitRoot, lock) {
+export function updateLockShipped(kitRoot, lock, kitVersion) {
   lock.shippedSha = computeShippedSha(kitRoot);
   lock.updatedAt = new Date().toISOString();
+  if (kitVersion) lock.version = kitVersion;
   return lock;
 }

package/src/manifest.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 export function loadManifest(path) {
   if (!existsSync(path)) return null;
   try {
-    return JSON.parse(readFileSync(path, 'utf-8'));
+    return JSON.parse(readFileSync(path, 'utf8'));
   } catch {
     return null;
   }

package/src/resolve-kit.js

@@ -3,31 +3,46 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const INVOS_KIT_ALLOWED_DIRS = ['.']; // Only current dir or explicit path from dev
+
+function validateKitPath(p) {
+  if (!p || typeof p !== 'string') return false;
+  const resolved = resolve(p);
+  if (!existsSync(resolved)) {
+    console.error('INVOS_KIT_PATH directory does not exist:', resolved);
+    return false;
+  }
+  if (!existsSync(resolve(resolved, 'INVOS.json'))) return false;
+  return true;
+}
 
 /**
- * Kit source resolution (first hit wins):
- * 1. INVOS_KIT_PATH env
- * 2. Bundled kit next to package (npm install / npx)
- * 3. Monorepo layout: packages/cli → invos root
+ * 1. INVOS_KIT_PATH
+ * 2. packages/cli/kit (bundled — npm)
+ * 3. parent InvOS.v2 root (dev)
  */
 export function resolveKitRoot() {
   if (process.env.INVOS_KIT_PATH) {
+    if (!validateKitPath(process.env.INVOS_KIT_PATH)) {
+      console.error('INVOS_KIT_PATH points to invalid kit directory:', process.env.INVOS_KIT_PATH);
+      process.exit(1);
+    }
     const p = resolve(process.env.INVOS_KIT_PATH);
-    if (existsSync(resolve(p, 'INVOS.json'))) return p;
-    console.error('INVOS_KIT_PATH set but INVOS.json missing:', p);
-    process.exit(1);
+    return p;
   }
 
   const bundled = resolve(__dirname, '../kit');
   if (existsSync(resolve(bundled, 'INVOS.json'))) return bundled;
 
-  const monorepo = resolve(__dirname, '../../..');
-  if (existsSync(resolve(monorepo, 'INVOS.json'))) return monorepo;
+  // packages/cli → ../.. = InvOS.v2 root
+  const v2 = resolve(__dirname, '../..');
+  if (existsSync(resolve(v2, 'INVOS.json'))) return v2;
 
   console.error(`
-INVOS kit not found.
-- Reinstall: npm i -g invos@latest  (or npx invos@latest)
-- Or set: export INVOS_KIT_PATH=/path/to/invos-kit
+Kit INVOS v2 não encontrado.
+- Dev: rode a partir de InvOS.v2 (tem INVOS.json na raiz)
+- Publish: npm run bundle-kit
+- Override: export INVOS_KIT_PATH=/path/to/InvOS.v2
 `);
   process.exit(1);
 }

package/src/symlinks.js

@@ -1,78 +1,61 @@
-import { existsSync, mkdirSync, symlinkSync, unlinkSync, readlinkSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import {
+  existsSync, mkdirSync, symlinkSync, unlinkSync, readlinkSync,
+  readdirSync, statSync,
+} from 'node:fs';
 import { resolve, dirname } from 'node:path';
 
-const CLAUDE_SKILLS_RELPATH = '../../.agents/skills';
+const REL = '../../.agents/skills';
 
-export function syncClaudeSymlinks(kitRoot, targetRoot) {
-  const claudeDir = resolve(targetRoot, '.claude', 'skills');
-  const agentsDir = resolve(targetRoot, '.agents', 'skills');
-
-  if (!existsSync(agentsDir)) {
-    mkdirSync(agentsDir, { recursive: true });
-  }
-
-  const manifestPath = resolve(kitRoot, 'INVOS.json');
-  if (!existsSync(manifestPath)) return;
-  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-  const skills = manifest.seed?.skills || [];
+function listSkills(agentsDir) {
+  if (!existsSync(agentsDir)) return [];
+  return readdirSync(agentsDir).filter(e => {
+    const p = resolve(agentsDir, e);
+    try {
+      return statSync(p).isDirectory() && existsSync(resolve(p, 'SKILL.md'));
+    } catch (err) {
+      console.error('listSkills: skipping', e, err.message);
+      return false;
+    }
+  });
+}
 
+export function syncClaudeSymlinks(_kitRoot, targetRoot) {
+  const agentsDir = resolve(targetRoot, '.agents', 'skills');
+  const claudeDir = resolve(targetRoot, '.claude', 'skills');
+  mkdirSync(agentsDir, { recursive: true });
   mkdirSync(claudeDir, { recursive: true });
 
-  for (const skill of skills) {
-    const target = resolve(agentsDir, skill);
+  for (const skill of listSkills(agentsDir)) {
     const linkPath = resolve(claudeDir, skill);
-
-    if (!existsSync(target)) continue;
-
     if (existsSync(linkPath)) {
       try {
-        const existing = readlinkSync(linkPath);
-        if (existing === `${CLAUDE_SKILLS_RELPATH}/${skill}`) continue;
-        unlinkSync(linkPath);
-      } catch {
+        if (readlinkSync(linkPath) === `${REL}/${skill}`) continue;
         unlinkSync(linkPath);
+      } catch (err) {
+        console.error('syncClaudeSymlinks: failed to update', skill, err.message);
       }
     }
-
-    symlinkSync(`${CLAUDE_SKILLS_RELPATH}/${skill}`, linkPath);
+    symlinkSync(`${REL}/${skill}`, linkPath);
   }
 }
 
 export function checkClaudeSymlinks(targetRoot) {
+  const agentsDir = resolve(targetRoot, '.agents', 'skills');
   const claudeDir = resolve(targetRoot, '.claude', 'skills');
-  if (!existsSync(claudeDir)) return { ok: false, errors: ['.claude/skills/ not found'] };
+  const expected = listSkills(agentsDir);
+  if (!expected.length) return { ok: false, errors: ['.agents/skills empty'] };
+  if (!existsSync(claudeDir)) return { ok: false, errors: ['.claude/skills missing'] };
 
   const errors = [];
-  let entries = [];
-  try {
-    entries = readdirSync(claudeDir);
-  } catch { return { ok: false, errors: ['.claude/skills/ unreadable'] }; }
-
-  for (const entry of entries) {
-    const linkPath = resolve(claudeDir, entry);
+  for (const s of expected) {
+    const link = resolve(claudeDir, s);
     try {
-      const target = readlinkSync(linkPath);
-      const absTarget = resolve(dirname(linkPath), target);
-
-      // Resolve target — must exist and be a dir with SKILL.md
-      if (!existsSync(absTarget)) {
-        errors.push(`${entry}: target missing (${target})`);
-        continue;
-      }
-      const st = statSync(absTarget);
-      if (!st.isDirectory()) {
-        errors.push(`${entry}: target not a directory (${target})`);
-        continue;
-      }
-      // Nested skills like apple-notes → ../../.agents/skills/apple/apple-notes
-      // are valid if the resolved target has SKILL.md
-      if (!existsSync(resolve(absTarget, 'SKILL.md'))) {
-        errors.push(`${entry}: target has no SKILL.md (${target})`);
-      }
+      const t = readlinkSync(link);
+      const abs = resolve(dirname(link), t);
+      if (!existsSync(resolve(abs, 'SKILL.md'))) errors.push(`${s}: broken`);
     } catch {
-      errors.push(`${entry}: not a symlink or unreadable`);
+      errors.push(`${s}: not a symlink`);
     }
   }
-
   return { ok: errors.length === 0, errors };
 }