@witty-ai/skill-insight 0.3.0-beta → 0.5.0-beta

package/scripts/opencode_plugin.ts

@@ -18,9 +18,151 @@ function logDebug(msg) {
 
 // Global store
 let sessionStore = new Map();
-let uploadedSessions = new Set();
+let uploadedSessions = new Map(); // sessionId -> uploaded message count
 let sessionGraph = new Map(); // parent_id -> [child_ids]
 let pendingChildSessions = new Map(); // child_id -> {parent_id, data}
+let lastDeltaByPartField = new Map();
+
+const STORE_PATH = path.join(os.homedir(), '.opencode', 'witty_plugin_session_store.json');
+
+function cleanupOldSessions() {
+    const now = Date.now();
+    const threeDays = 3 * 24 * 3600 * 1000;
+    
+    let deletedCount = 0;
+    for (const [msgId, entry] of sessionStore.entries()) {
+        const time = entry.info?.created || entry.info?.time?.created;
+        if (time && (now - time > threeDays)) {
+            sessionStore.delete(msgId);
+            deletedCount++;
+        }
+    }
+    if (deletedCount > 0) logDebug(`Cleaned up ${deletedCount} old messages from sessionStore`);
+}
+
+function loadStore() {
+    try {
+        if (fs.existsSync(STORE_PATH)) {
+            const fileData = fs.readFileSync(STORE_PATH, 'utf8');
+            if (!fileData.trim()) return;
+            const data = JSON.parse(fileData);
+            
+            // Merge sessionStore: disk entries fill in gaps, but don't overwrite in-memory entries
+            if (data.sessionStore) {
+                const diskStore = new Map(data.sessionStore);
+                for (const [msgId, entry] of diskStore.entries()) {
+                    if (!sessionStore.has(msgId)) {
+                        if (entry.parts && !Array.isArray(entry.parts) && typeof entry.parts === 'object' && !(entry.parts instanceof Map)) {
+                             entry.parts = new Map(Object.entries(entry.parts));
+                        } else if (Array.isArray(entry.parts)) {
+                             entry.parts = new Map(entry.parts);
+                        } else if (!entry.parts) {
+                             entry.parts = new Map();
+                        }
+                        
+                        if (entry.toolParts && !Array.isArray(entry.toolParts) && typeof entry.toolParts === 'object' && !(entry.toolParts instanceof Map)) {
+                             entry.toolParts = new Map(Object.entries(entry.toolParts));
+                        } else if (Array.isArray(entry.toolParts)) {
+                             entry.toolParts = new Map(entry.toolParts);
+                        } else if (!entry.toolParts) {
+                             entry.toolParts = new Map();
+                        }
+
+                        sessionStore.set(msgId, entry);
+                    }
+                }
+            }
+            
+            // Merge uploadedSessions: keep the "newer" signature between memory and disk
+            if (data.uploadedSessions) {
+                for (const x of data.uploadedSessions) {
+                    const sid = Array.isArray(x) ? x[0] : x;
+                    const diskVal = Array.isArray(x) ? x[1] : 0;
+
+                    const normalize = (v) => {
+                        if (typeof v === 'number') return { count: v, lastAssistantLen: 0, lastTs: 0 };
+                        if (v && typeof v === 'object') {
+                            return {
+                                count: Number(v.count || 0),
+                                lastAssistantLen: Number(v.lastAssistantLen || 0),
+                                lastTs: Number(v.lastTs || 0)
+                            };
+                        }
+                        return { count: 0, lastAssistantLen: 0, lastTs: 0 };
+                    };
+
+                    const memSig = normalize(uploadedSessions.get(sid));
+                    const diskSig = normalize(diskVal);
+
+                    const diskNewer =
+                        diskSig.count > memSig.count ||
+                        (diskSig.count === memSig.count && diskSig.lastAssistantLen > memSig.lastAssistantLen) ||
+                        (diskSig.count === memSig.count && diskSig.lastAssistantLen === memSig.lastAssistantLen && diskSig.lastTs > memSig.lastTs);
+
+                    if (diskNewer) {
+                        uploadedSessions.set(sid, diskVal);
+                    } else if (!uploadedSessions.has(sid)) {
+                        uploadedSessions.set(sid, memSig);
+                    }
+                }
+            }
+            
+            // Merge sessionGraph: union child lists
+            if (data.sessionGraph) {
+                const diskGraph = new Map(data.sessionGraph);
+                for (const [parentId, childIds] of diskGraph.entries()) {
+                    if (!sessionGraph.has(parentId)) {
+                        sessionGraph.set(parentId, childIds);
+                    } else {
+                        const existing = sessionGraph.get(parentId);
+                        for (const cid of childIds) {
+                            if (!existing.includes(cid)) existing.push(cid);
+                        }
+                    }
+                }
+            }
+            
+            // Merge pendingChildSessions
+            if (data.pendingChildSessions) {
+                const diskPending = new Map(data.pendingChildSessions);
+                for (const [childId, childData] of diskPending.entries()) {
+                    if (!pendingChildSessions.has(childId)) {
+                        pendingChildSessions.set(childId, childData);
+                    }
+                }
+            }
+            
+            logDebug(`Loaded store (merged): ${sessionStore.size} messages`);
+        }
+    } catch(e) {
+        logDebug("Store read err: " + e.message);
+    }
+}
+
+function saveStore() {
+    try {
+        cleanupOldSessions();
+        
+        // Merge with disk state to prevent concurrent process data loss.
+        // loadStore() uses merge semantics (won't overwrite in-memory entries).
+        loadStore();
+        
+        const data = {
+            sessionStore: Array.from(sessionStore.entries()).map(([k, v]) => [k, {
+                ...v,
+                parts: v.parts instanceof Map ? Array.from(v.parts.entries()) : (v.parts || []),
+                toolParts: v.toolParts instanceof Map ? Array.from(v.toolParts.entries()) : (v.toolParts || [])
+            }]),
+            uploadedSessions: Array.from(uploadedSessions.entries()),
+            sessionGraph: Array.from(sessionGraph.entries()),
+            pendingChildSessions: Array.from(pendingChildSessions.entries()),
+            timestamp: new Date().toISOString()
+        };
+        fs.writeFileSync(STORE_PATH, JSON.stringify(data, null, 2), 'utf8');
+    } catch(e) {
+        logDebug("Store sync err: " + e.message);
+    }
+}
 
 function toMsTimestamp(v) {
     if (v == null) return null;
@@ -74,7 +216,7 @@ function getRequestOptions(targetUrl, apiKey, bodyLength) {
     let options = {
         hostname: targetUrl.hostname,
         port: targetUrl.port || (protocol === 'https:' ? 443 : 80),
-        path: path.join(targetUrl.pathname === '/' ? '' : targetUrl.pathname, '/api/upload'),
+        path: (targetUrl.pathname === '/' ? '' : targetUrl.pathname) + '/api/upload',
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -103,7 +245,7 @@ function getRequestOptions(targetUrl, apiKey, bodyLength) {
 function loadConfiguration() {
     let config = {};
     try {
-        const envPath = path.join(os.homedir(), '.witty', '.env');
+        const envPath = path.join(os.homedir(), '.skill-insight', '.env');
         if (fs.existsSync(envPath)) {
             const content = fs.readFileSync(envPath, 'utf8');
             content.split('\n').forEach(line => {
@@ -113,18 +255,19 @@ function loadConfiguration() {
         }
     } catch (e) {}
     return {
-        apiKey: config['WITTY_INSIGHT_API_KEY'] || process.env.WITTY_INSIGHT_API_KEY,
-        host: config['WITTY_INSIGHT_HOST'] || process.env.WITTY_INSIGHT_HOST
+        apiKey: config['SKILL_INSIGHT_API_KEY'] || process.env.SKILL_INSIGHT_API_KEY,
+        host: config['SKILL_INSIGHT_HOST'] || process.env.SKILL_INSIGHT_HOST
     };
 }
 
 function collectSessionMessages(sessionId) {
     const messages = [];
+    logDebug(`collectSessionMessages: scanning ${sessionStore.size} entries for session ${sessionId}`);
     for (const [mid, entry] of sessionStore.entries()) {
         if (entry.info.sessionID === sessionId) {
             // Calculate latency for this message if possible from parts
             let partBasedDuration = 0;
-            if (entry.parts.size > 0) {
+            if (entry.parts instanceof Map && entry.parts.size > 0) {
                 const parts = Array.from(entry.parts.values()).map(p => p.time?.start || 0).filter(t => t > 0).sort((a,b)=>a-b);
                 if (parts.length >= 1) {
                     const start = parts[0];
@@ -133,9 +276,13 @@ function collectSessionMessages(sessionId) {
                 }
             }
 
+            const role = entry.info.role || 'unknown';
+            const content = entry.content || entry.info.content || "";
+            logDebug(`Found message in store: id=${mid}, role=${role}, content_len=${content.length}`);
+
             messages.push({
-                role: entry.info.role || 'unknown',
-                content: entry.content || entry.info.content || "",
+                role: role,
+                content: content,
                 tool_calls: entry.info.tool_calls || entry.info.toolCalls,
                 function_call: entry.info.function_call || entry.info.functionCall,
                 usage: entry.info.usage || entry.info.tokens,
@@ -147,6 +294,7 @@ function collectSessionMessages(sessionId) {
             });
         }
     }
+    logDebug(`collectSessionMessages: collected ${messages.length} messages for ${sessionId}`);
     return messages;
 }
 
@@ -196,6 +344,7 @@ function collectSessionWithChildren(sessionId) {
 }
 
 export default async function WittySkillInsightPlugin(input) {
+  loadStore();
   const { apiKey, host } = loadConfiguration();
   if (!apiKey || !host) {
       logDebug("Plugin disabled: Missing API Key or Host");
@@ -212,7 +361,7 @@ export default async function WittySkillInsightPlugin(input) {
 
   // Auto-Sync Skills on Startup
   try {
-     const syncScript = path.join(os.homedir(), '.witty', 'sync_skills.ts');
+     const syncScript = path.join(os.homedir(), '.skill-insight', 'sync_skills.ts');
      if (fs.existsSync(syncScript)) {
          const cp = require('child_process');
          // Run async to avoid blocking
@@ -254,23 +403,6 @@ export default async function WittySkillInsightPlugin(input) {
            // Attempt to find session ID in various places
            const sessionId = event.session_id || event.properties?.sessionID || event.payload?.session_id;
 
-           // 0. Handle session.created events to establish parent-child relationships
-           if (event.type === 'session.created') {
-               const sessionInfo = event.properties?.info || event.payload?.info;
-               if (sessionInfo && sessionInfo.id && sessionInfo.parentID) {
-                   const childId = sessionInfo.id;
-                   const parentId = sessionInfo.parentID;
-                   
-                   if (!sessionGraph.has(parentId)) {
-                       sessionGraph.set(parentId, []);
-                   }
-                   if (!sessionGraph.get(parentId).includes(childId)) {
-                       sessionGraph.get(parentId).push(childId);
-                       logDebug(`Session created: ${childId} is child of ${parentId}`);
-                   }
-               }
-           }
-
            // 1. Accumulate Message Metadata
            if (event.type === 'message.created' || event.type === 'message.updated') {
              let info = (event.payload && event.payload.message) || (event.properties && event.properties.info);
@@ -309,6 +441,8 @@ export default async function WittySkillInsightPlugin(input) {
                         });
                   }
                   const entry = sessionStore.get(msgId);
+                  if (!(entry.parts instanceof Map)) entry.parts = new Map(Array.isArray(entry.parts) ? entry.parts : []);
+                  if (entry.toolParts && !(entry.toolParts instanceof Map)) entry.toolParts = new Map(Array.isArray(entry.toolParts) ? entry.toolParts : []);
                   
                   // Store part
                   const partId = part.id || `temp_${Date.now()}_${Math.random()}`;
@@ -414,22 +548,81 @@ export default async function WittySkillInsightPlugin(input) {
               }
           }
 
+          if (event.type === 'message.part.delta') {
+              const props = event.properties || event.payload || {};
+              const msgId = props.messageID || props.message_id;
+              const partId = props.partID || props.part_id;
+              const field = props.field;
+              const delta = props.delta;
+
+              if (msgId && partId && field && typeof delta === 'string') {
+                  if (!sessionStore.has(msgId)) {
+                      sessionStore.set(msgId, {
+                          info: { sessionID: sessionId },
+                          parts: new Map(),
+                          toolParts: new Map(),
+                          content: ''
+                      });
+                  }
+
+                  const entry = sessionStore.get(msgId);
+                  if (!(entry.parts instanceof Map)) entry.parts = new Map(Array.isArray(entry.parts) ? entry.parts : []);
+
+                  const dedupeKey = `${msgId}:${partId}:${field}`;
+                  const lastDelta = lastDeltaByPartField.get(dedupeKey);
+                  if (lastDelta !== delta) {
+                      lastDeltaByPartField.set(dedupeKey, delta);
+                      if (lastDeltaByPartField.size > 5000) {
+                          for (const k of lastDeltaByPartField.keys()) {
+                              lastDeltaByPartField.delete(k);
+                              if (lastDeltaByPartField.size <= 4000) break;
+                          }
+                      }
+
+                      const existingPart = entry.parts.get(partId) || {
+                          id: partId,
+                          messageID: msgId,
+                          sessionID: sessionId,
+                          type: 'text'
+                      };
+                      const prev = typeof existingPart[field] === 'string' ? existingPart[field] : '';
+                      existingPart[field] = prev + delta;
+                      entry.parts.set(partId, existingPart);
+
+                      let full = "";
+                      const sortedParts = Array.from(entry.parts.values()).sort((a, b) => {
+                          const ta = a.time?.start || (a.meta && a.meta.start) || 0;
+                          const tb = b.time?.start || (b.meta && b.meta.start) || 0;
+                          return ta - tb;
+                      });
+
+                      for (const p of sortedParts) {
+                          if (p.text) full += p.text;
+                          else if (p.content) full += p.content;
+                      }
+                      entry.content = full;
+                  }
+              }
+          }
+
            // 3. Upload on Session Idle
            if (event.type === "session.idle") {
                if (!sessionId || !sessionId.startsWith("ses")) return;
 
-               // Check if this is a child session (has parent_id or is in sessionGraph)
-               const parentId = event.parent_id || event.properties?.parentID || event.payload?.parent_id;
-               
-               // Also check if this session is registered as a child in sessionGraph
-               let foundParentId = parentId;
-               if (!foundParentId) {
-                   for (const [potentialParent, childIds] of sessionGraph.entries()) {
-                       if (childIds.includes(sessionId)) {
-                           foundParentId = potentialParent;
-                           logDebug(`Found parent ${foundParentId} for for child ${sessionId} from sessionGraph`);
-                           break;
-                       }
+               // Reload store from disk to pick up any data written by
+               // concurrent child processes (e.g. opencode run executed
+               // from within the opencode interactive interface).
+               loadStore();
+
+               // Only treat a session as "child" when it was detected via Task tool
+               // (i.e. registered in sessionGraph). Do NOT rely on event.parentID because
+               // nested `opencode run ...` can also set parentID and we want both sessions uploaded.
+               let foundParentId = null;
+               for (const [potentialParent, childIds] of sessionGraph.entries()) {
+                   if (childIds.includes(sessionId)) {
+                       foundParentId = potentialParent;
+                       logDebug(`Found parent ${foundParentId} for for child ${sessionId} from sessionGraph`);
+                       break;
                    }
                }
                
@@ -587,11 +780,38 @@ export default async function WittySkillInsightPlugin(input) {
                   timestamp: new Date().toISOString()
               };
 
-              if (uploadedSessions.has(sessionId)) {
-                  logDebug(`Session ${sessionId} already uploaded, skipping.`);
+              let lastTs = 0;
+              for (const m of messages) {
+                  const t1 = toMsTimestamp(m.timestamp) || 0;
+                  const t2 = toMsTimestamp(m.timeInfo?.completed) || 0;
+                  const t3 = toMsTimestamp(m.timeInfo?.created) || 0;
+                  lastTs = Math.max(lastTs, t1, t2, t3);
+              }
+              const lastAssistantLen = (lastAssistantContent || '').length;
+
+              const normalize = (v) => {
+                  if (typeof v === 'number') return { count: v, lastAssistantLen: 0, lastTs: 0 };
+                  if (v && typeof v === 'object') {
+                      return {
+                          count: Number(v.count || 0),
+                          lastAssistantLen: Number(v.lastAssistantLen || 0),
+                          lastTs: Number(v.lastTs || 0)
+                      };
+                  }
+                  return { count: 0, lastAssistantLen: 0, lastTs: 0 };
+              };
+
+              const prevSig = normalize(uploadedSessions.get(sessionId));
+              const shouldSkip =
+                  messages.length <= prevSig.count &&
+                  lastAssistantLen <= prevSig.lastAssistantLen &&
+                  lastTs <= prevSig.lastTs;
+
+              if (shouldSkip) {
+                  logDebug(`Session ${sessionId} already uploaded (count=${prevSig.count}, lastAssistantLen=${prevSig.lastAssistantLen}, lastTs=${prevSig.lastTs}) (cur: count=${messages.length}, lastAssistantLen=${lastAssistantLen}, lastTs=${lastTs}), skipping.`);
                   return;
               }
-              uploadedSessions.add(sessionId);
+              uploadedSessions.set(sessionId, { count: messages.length, lastAssistantLen, lastTs });
 
               const body = JSON.stringify(payload);
               logDebug(`Payload Body Size: ${Buffer.byteLength(body)} bytes`);
@@ -658,16 +878,27 @@ try {
               // We must explicitly resolve the node binary path.
               let nodeBin = 'node';
               try {
-                  nodeBin = cp.execSync('which node', { encoding: 'utf8', timeout: 3000 }).trim() || 'node';
+                  const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
+                  nodeBin = cp.execSync(nodeCmd, { encoding: 'utf8', timeout: 3000 }).trim() || 'node';
+                  if (process.platform === 'win32') {
+                      const lines = nodeBin.split('\n');
+                      nodeBin = lines[0].trim() || 'node';
+                  }
               } catch (e) {
                   logDebug(`Could not resolve node path, falling back to 'node'`);
               }
-              const shellCmd = `nohup "${nodeBin}" "${scriptPath}" > "${logPath}" 2>&1 &`;
-              logDebug(`Launching uploader via shell: ${shellCmd}`);
+              
+              logDebug(`Launching uploader: node=${nodeBin}, script=${scriptPath}`);
               try {
-                  cp.execSync(shellCmd, { stdio: 'ignore', timeout: 5000 });
+                  const uploader = cp.spawn(nodeBin, [scriptPath], {
+                      detached: true,
+                      stdio: ['ignore', fs.openSync(logPath, 'a'), fs.openSync(logPath, 'a')],
+                      windowsHide: true
+                  });
+                  uploader.unref();
+                  logDebug(`Uploader spawned successfully (PID: ${uploader.pid})`);
               } catch (spawnErr) {
-                  logDebug(`execSync uploader error: ${spawnErr.message}`);
+                  logDebug(`spawn uploader error: ${spawnErr.message}`);
               }
 
               /* 
@@ -681,6 +912,7 @@ try {
       } catch (err) {
           logDebug(`Plugin Exception: ${err.message}`);
       }
+      saveStore();
     }
   };
 }

package/scripts/postinstall.js

@@ -7,67 +7,85 @@ const path = require('path')
 const {
   ensureEnvFile,
   ensureDataDirectory,
-  runCommand
+  runCommand,
+  getDataRoot,
+  migrateDataIfNeeded
 } = require('./utils.js')
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..')
 
-console.log('=== Witty-Skill-Insight Post-Install Initialization ===\n')
+console.log('=== Skill-Insight Post-Install Initialization ===\n')
 
 try {
-  ensureEnvFile(PACKAGE_ROOT)
+  migrateDataIfNeeded()
   console.log()
-  
-  ensureDataDirectory(PACKAGE_ROOT)
+
+  ensureEnvFile()
+  console.log()
+
+  ensureDataDirectory()
   console.log()
-  
+
+  const dataRoot = getDataRoot()
+  const dbPath = path.join(dataRoot, 'data', 'witty_insight.db')
+  const dbUrl = `file:${dbPath}`
+  process.env.DATABASE_URL = dbUrl
+
   console.log('Syncing database schema...')
-  execSync('npx prisma db push', { stdio: 'inherit', cwd: PACKAGE_ROOT })
+  execSync('npx prisma db push', {
+    stdio: 'inherit',
+    cwd: PACKAGE_ROOT,
+    env: { ...process.env, DATABASE_URL: dbUrl }
+  })
   console.log('✓ Database schema synced')
   console.log()
-  
+
   console.log('Generating Prisma client...')
-  execSync('npx prisma generate', { stdio: 'inherit', cwd: PACKAGE_ROOT })
+  execSync('npx prisma generate', {
+    stdio: 'inherit',
+    cwd: PACKAGE_ROOT,
+    env: { ...process.env, DATABASE_URL: dbUrl }
+  })
   console.log('✓ Prisma client generated')
   console.log()
-  
+
   const standaloneDir = path.join(PACKAGE_ROOT, '.next', 'standalone')
   if (fs.existsSync(standaloneDir)) {
     console.log('Setting up standalone environment...')
-    
+
     const staticDir = path.join(PACKAGE_ROOT, '.next', 'static')
     const standaloneStaticDir = path.join(standaloneDir, '.next', 'static')
-    
+
     if (fs.existsSync(staticDir) && !fs.existsSync(standaloneStaticDir)) {
       fs.mkdirSync(path.dirname(standaloneStaticDir), { recursive: true })
-      execSync(`cp -r "${staticDir}" "${path.dirname(standaloneStaticDir)}/"`, { stdio: 'inherit' })
+      fs.cpSync(staticDir, standaloneStaticDir, { recursive: true })
       console.log('✓ Static files copied to standalone')
     }
-    
+
     const publicDir = path.join(PACKAGE_ROOT, 'public')
     const standalonePublicDir = path.join(standaloneDir, 'public')
-    
+
     if (fs.existsSync(publicDir) && !fs.existsSync(standalonePublicDir)) {
-      execSync(`cp -r "${publicDir}" "${standaloneDir}/"`, { stdio: 'inherit' })
+      fs.cpSync(publicDir, standalonePublicDir, { recursive: true })
       console.log('✓ Public files copied to standalone')
     }
-    
+
     const prismaClientDir = path.join(PACKAGE_ROOT, 'node_modules', '.prisma', 'client')
     const standaloneNodeModules = path.join(standaloneDir, 'node_modules')
     const standalonePrismaDir = path.join(standaloneNodeModules, '.prisma')
     const standaloneClientDir = path.join(standalonePrismaDir, 'client')
-    
+
     if (fs.existsSync(prismaClientDir)) {
       fs.mkdirSync(standalonePrismaDir, { recursive: true })
-      
+
       if (fs.existsSync(standaloneClientDir)) {
         fs.rmSync(standaloneClientDir, { recursive: true, force: true })
       }
-      
-      execSync(`cp -r "${prismaClientDir}" "${standalonePrismaDir}/"`, { stdio: 'inherit' })
+
+      fs.cpSync(prismaClientDir, standaloneClientDir, { recursive: true })
       console.log('✓ Prisma client copied to standalone')
     }
-    
+
     const pgDir = path.join(PACKAGE_ROOT, 'node_modules', 'pg')
     if (fs.existsSync(pgDir)) {
       if (!fs.existsSync(standaloneNodeModules)) {
@@ -75,61 +93,85 @@ try {
       }
       const standalonePgDir = path.join(standaloneNodeModules, 'pg')
       if (!fs.existsSync(standalonePgDir)) {
-        execSync(`cp -r "${pgDir}" "${standaloneNodeModules}/"`, { stdio: 'inherit' })
+        fs.cpSync(pgDir, standalonePgDir, { recursive: true })
         console.log('✓ pg module copied to standalone')
       }
     }
-    
+
     const chunksDir = path.join(standaloneDir, '.next', 'server', 'chunks')
     if (fs.existsSync(chunksDir)) {
       const chunkFiles = fs.readdirSync(chunksDir).filter(f => f.endsWith('.js'))
       let foundPrismaHash = null
       let foundPgHash = null
-      
+
       for (const file of chunkFiles) {
         const filePath = path.join(chunksDir, file)
         const content = fs.readFileSync(filePath, 'utf8')
-        
+
         if (!foundPrismaHash) {
           const prismaHashMatch = content.match(/@prisma\/client-([a-f0-9]+)/)
           if (prismaHashMatch) {
             foundPrismaHash = prismaHashMatch[1]
           }
         }
-        
+
         if (!foundPgHash) {
           const pgHashMatch = content.match(/["']pg-([a-f0-9]+)["']/)
           if (pgHashMatch) {
             foundPgHash = pgHashMatch[1]
           }
         }
-        
+
         if (foundPrismaHash && foundPgHash) {
           break
         }
       }
-      
+
       if (foundPrismaHash) {
         const hashName = `@prisma/client-${foundPrismaHash}`
         const hashDir = path.join(standaloneNodeModules, hashName)
-        
+
         if (!fs.existsSync(hashDir)) {
           fs.mkdirSync(path.dirname(hashDir), { recursive: true })
-          fs.symlinkSync(standaloneClientDir, hashDir, 'dir')
-          console.log(`✓ Created symlink: ${hashName} -> .prisma/client`)
+          if (process.platform === 'win32') {
+            try {
+              fs.symlinkSync(standaloneClientDir, hashDir, 'junction')
+              console.log(`✓ Created junction: ${hashName} -> .prisma/client`)
+            } catch (err) {
+              console.log(`⚠️  Could not create junction on Windows: ${err.message}`)
+              console.log(`   Falling back to copying directory...`)
+              fs.cpSync(standaloneClientDir, hashDir, { recursive: true })
+              console.log(`✓ Copied directory: ${hashName}`)
+            }
+          } else {
+            fs.symlinkSync(standaloneClientDir, hashDir, 'dir')
+            console.log(`✓ Created symlink: ${hashName} -> .prisma/client`)
+          }
         }
       } else {
         console.log('⚠️  Could not find Prisma hash in build output')
       }
-      
+
       if (foundPgHash) {
         const pgHashName = `pg-${foundPgHash}`
         const pgHashDir = path.join(standaloneNodeModules, pgHashName)
         const pgTargetDir = path.join(standaloneNodeModules, 'pg')
-        
+
         if (!fs.existsSync(pgHashDir) && fs.existsSync(pgTargetDir)) {
-          fs.symlinkSync(pgTargetDir, pgHashDir, 'dir')
-          console.log(`✓ Created symlink: ${pgHashName} -> pg`)
+          if (process.platform === 'win32') {
+            try {
+              fs.symlinkSync(pgTargetDir, pgHashDir, 'junction')
+              console.log(`✓ Created junction: ${pgHashName} -> pg`)
+            } catch (err) {
+              console.log(`⚠️  Could not create junction on Windows: ${err.message}`)
+              console.log(`   Falling back to copying directory...`)
+              fs.cpSync(pgTargetDir, pgHashDir, { recursive: true })
+              console.log(`✓ Copied directory: ${pgHashName}`)
+            }
+          } else {
+            fs.symlinkSync(pgTargetDir, pgHashDir, 'dir')
+            console.log(`✓ Created symlink: ${pgHashName} -> pg`)
+          }
         }
       } else {
         console.log('⚠️  Could not find pg hash in build output')
@@ -137,7 +179,7 @@ try {
     }
     console.log()
   }
-  
+
   console.log('=== Initialization Complete ===')
   console.log('\nStart the service with:')
   console.log('  npx @witty-ai/skill-insight start')
@@ -147,4 +189,4 @@ try {
 } catch (error) {
   console.error('\n❌ Initialization failed:', error.message)
   process.exit(1)
-}
+}

package/scripts/restart.js

@@ -3,7 +3,7 @@
 const { sleep } = require('./utils.js')
 
 async function run(options) {
-  console.log('=== Restarting Witty-Skill-Insight Service ===\n')
+  console.log('=== Restarting Skill-Insight Service ===\n')
   
   try {
     const stop = require('./stop.js')