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

package/.next/standalone/scripts/start.js

@@ -13,21 +13,26 @@ const {
   ensureEnvFile,
   ensureDataDirectory,
   runCommand,
-  sleep
+  sleep,
+  getDataRoot
 } = require('./utils.js')
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..')
 
+const isWindows = process.platform === 'win32'
+const pythonCmd = isWindows ? 'python' : 'python3'
+const pipCmd = isWindows ? 'pip' : 'pip3'
+
 function loadEnvFile(envPath) {
   if (!fs.existsSync(envPath)) return {}
-  
+
   const content = fs.readFileSync(envPath, 'utf8')
   const env = {}
-  
+
   content.split('\n').forEach(line => {
     const trimmed = line.trim()
     if (!trimmed || trimmed.startsWith('#')) return
-    
+
     const match = trimmed.match(/^([^=]+)=(.*)$/)
     if (match) {
       const key = match[1].trim()
@@ -39,7 +44,7 @@ function loadEnvFile(envPath) {
       env[key] = value
     }
   })
-  
+
   return env
 }
 
@@ -48,7 +53,7 @@ let spawnedProc = null
 async function createAdminUser(port) {
   return new Promise((resolve) => {
     const postData = JSON.stringify({ username: 'admin' })
-    
+
     const options = {
       hostname: 'localhost',
       port: port,
@@ -59,7 +64,7 @@ async function createAdminUser(port) {
         'Content-Length': Buffer.byteLength(postData)
       }
     }
-    
+
     const req = http.request(options, (res) => {
       let data = ''
       res.on('data', (chunk) => { data += chunk })
@@ -68,11 +73,11 @@ async function createAdminUser(port) {
           try {
             const result = JSON.parse(data)
             if (result.apiKey) {
-              const wittyDir = path.join(os.homedir(), '.witty')
-              if (!fs.existsSync(wittyDir)) {
-                fs.mkdirSync(wittyDir, { recursive: true })
+              const skillInsightDir = path.join(os.homedir(), '.skill-insight')
+              if (!fs.existsSync(skillInsightDir)) {
+                fs.mkdirSync(skillInsightDir, { recursive: true })
               }
-              const keyFilePath = path.join(wittyDir, '.admin_api_key')
+              const keyFilePath = path.join(skillInsightDir, '.admin_api_key')
               fs.writeFileSync(keyFilePath, result.apiKey, 'utf8')
               console.log('✓ Admin user created successfully')
               console.log(`  API Key saved to: ${keyFilePath}`)
@@ -86,12 +91,12 @@ async function createAdminUser(port) {
         resolve()
       })
     })
-    
+
     req.on('error', (e) => {
       console.log('⚠️  Failed to create admin user:', e.message)
       resolve()
     })
-    
+
     req.write(postData)
     req.end()
   })
@@ -119,13 +124,14 @@ process.on('SIGTERM', () => {
 
 async function run(options) {
   const port = getPort(options)
-  
-  console.log('=== Starting Witty-Skill-Insight Service ===\n')
-  
-  ensureEnvFile(PACKAGE_ROOT)
-  ensureDataDirectory(PACKAGE_ROOT)
+  const dataRoot = getDataRoot()
+
+  console.log('=== Starting Skill-Insight Service ===\n')
+
+  ensureEnvFile()
+  ensureDataDirectory()
   console.log()
-  
+
   const existingPid = findPidOnPort(port)
   if (existingPid) {
     console.log(`⚠️  Port ${port} is already in use by PID: ${existingPid}`)
@@ -133,81 +139,89 @@ async function run(options) {
     console.log(`\nTo stop: npx @witty-ai/skill-insight stop --port ${port}`)
     process.exit(1)
   }
-  
-  const dbPath = path.join(PACKAGE_ROOT, 'data', 'witty_insight.db')
-  process.env.DATABASE_URL = `file:${dbPath}`
-  
-  const envPath = path.join(PACKAGE_ROOT, '.env')
+
+  const dbPath = path.join(dataRoot, 'data', 'witty_insight.db')
+  const dbUrl = `file:${dbPath}`
+  process.env.DATABASE_URL = dbUrl
+
+  const envPath = path.join(dataRoot, '.env')
   const fileEnv = loadEnvFile(envPath)
-  
+
   if (fileEnv.DB_HOST) {
     console.log('OpenGauss configuration detected (DB_HOST=' + fileEnv.DB_HOST + ')')
     console.log('Initializing OpenGauss database with project schema...')
-    
+
     try {
-      execSync('python3 -c "import psycopg2"', { stdio: 'pipe' })
+      execSync(`${pythonCmd} -c "import psycopg2"`, { stdio: 'pipe' })
     } catch (e) {
       console.log('psycopg2 not found. Installing psycopg2-binary...')
       try {
-        execSync('pip3 install psycopg2-binary', { stdio: 'inherit' })
+        execSync(`${pipCmd} install psycopg2-binary`, { stdio: 'inherit' })
       } catch (pipError) {
         console.log('Warning: Could not install psycopg2-binary. OpenGauss init may fail.')
       }
     }
-    
+
     const initScript = path.join(PACKAGE_ROOT, 'scripts', 'init_opengauss.py')
     if (fs.existsSync(initScript)) {
       try {
         const initEnv = { ...process.env, ...fileEnv }
-        execSync('python3 "' + initScript + '"', { 
-          stdio: 'inherit', 
+        execSync(`${pythonCmd} "${initScript}"`, {
+          stdio: 'inherit',
           cwd: PACKAGE_ROOT,
           env: initEnv
         })
         console.log('✓ OpenGauss initialized successfully')
       } catch (initError) {
         console.error('Warning: OpenGauss initialization failed:', initError.message)
-        console.error('You may need to run it manually: python3 scripts/init_opengauss.py')
+        console.error(`You may need to run it manually: ${pythonCmd} scripts/init_opengauss.py`)
       }
     } else {
       console.log('Warning: init_opengauss.py not found, skipping OpenGauss init')
     }
     console.log()
   }
-  
+
   try {
     console.log('Syncing database schema...')
-    await runCommand('npx prisma db push', { cwd: PACKAGE_ROOT })
+    await runCommand('npx prisma db push', {
+      cwd: PACKAGE_ROOT,
+      env: { ...process.env, DATABASE_URL: dbUrl }
+    })
     console.log('✓ Database schema synced')
     console.log()
-    
+
     console.log('Generating Prisma client...')
-    await runCommand('npx prisma generate', { cwd: PACKAGE_ROOT })
+    await runCommand('npx prisma generate', {
+      cwd: PACKAGE_ROOT,
+      env: { ...process.env, DATABASE_URL: dbUrl }
+    })
     console.log('✓ Prisma client generated')
     console.log()
   } catch (error) {
     console.error('❌ Database initialization failed:', error.message)
     process.exit(1)
   }
-  
+
   const standaloneServer = path.join(PACKAGE_ROOT, '.next', 'standalone', 'server.js')
   const isStandalone = fs.existsSync(standaloneServer)
   const nextDir = path.join(PACKAGE_ROOT, '.next')
   const isProduction = fs.existsSync(nextDir) && fs.existsSync(path.join(nextDir, 'BUILD_ID'))
-  
+
   console.log(`Starting server on port ${port}...`)
-  
-  const logPath = path.join(PACKAGE_ROOT, 'server.log')
-  const env = { 
-    ...process.env, 
-    ...fileEnv, 
-    DATABASE_URL: `file:${dbPath}`,
+
+  const logPath = path.join(dataRoot, 'server.log')
+
+  const env = {
+    ...process.env,
+    ...fileEnv,
+    DATABASE_URL: dbUrl,
     PORT: port.toString(),
     HOSTNAME: '0.0.0.0'
   }
-  
+
   let command, args
-  
+
   if (isStandalone) {
     console.log('Mode: production (standalone)')
     command = 'node'
@@ -221,31 +235,41 @@ async function run(options) {
     command = 'npm'
     args = ['run', 'dev']
   }
-  
+
   try {
     const logFd = fs.openSync(logPath, 'a')
-    
-    spawnedProc = spawn(command, args, {
-      stdio: ['ignore', logFd, logFd],
-      env,
-      detached: true,
-      cwd: PACKAGE_ROOT
-    })
-    
+
+    if (isWindows) {
+      spawnedProc = spawn(command, args, {
+        stdio: ['ignore', logFd, logFd],
+        env,
+        detached: true,
+        cwd: PACKAGE_ROOT,
+        windowsHide: true
+      })
+    } else {
+      spawnedProc = spawn(command, args, {
+        stdio: ['ignore', logFd, logFd],
+        env,
+        detached: true,
+        cwd: PACKAGE_ROOT
+      })
+    }
+
     spawnedProc.on('error', (error) => {
       console.error('❌ Failed to spawn process:', error.message)
       process.exit(1)
     })
-    
+
     spawnedProc.unref()
   } catch (error) {
     console.error('❌ Failed to spawn process:', error.message)
     process.exit(1)
   }
-  
+
   const maxRetries = 10
   const retryDelay = 500
-  
+
   for (let i = 0; i < maxRetries; i++) {
     await sleep(retryDelay)
     const pid = findPidOnPort(port)
@@ -259,9 +283,9 @@ async function run(options) {
       return
     }
   }
-  
+
   console.error('❌ Failed to start server. Check server.log for details.')
   process.exit(1)
 }
 
-module.exports = { run }
+module.exports = { run }

package/.next/standalone/scripts/status.js

@@ -10,7 +10,7 @@ async function run(options) {
   try {
     const port = getPort(options)
     
-    console.log(`=== Witty-Skill-Insight Service Status ===\n`)
+    console.log(`=== Skill-Insight Service Status ===\n`)
     
     const pid = findPidOnPort(port)
     

package/.next/standalone/scripts/stop.js

@@ -8,10 +8,30 @@ const {
   isPortListening
 } = require('./utils.js')
 
+const isWindows = process.platform === 'win32'
+
+function killProcessByName(pattern) {
+  if (isWindows) {
+    try {
+      execSync(`powershell -Command "Get-Process | Where-Object { $_.CommandLine -like '*${pattern}*' } | Stop-Process -Force"`, { stdio: 'ignore' })
+      return true
+    } catch (e) {
+      return false
+    }
+  } else {
+    try {
+      execSync(`pkill -f "${pattern}"`, { stdio: 'ignore' })
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+}
+
 async function run(options) {
   const port = getPort(options)
   
-  console.log(`=== Stopping Witty-Skill-Insight Service (Port: ${port}) ===\n`)
+  console.log(`=== Stopping Skill-Insight Service (Port: ${port}) ===\n`)
   
   const pid = findPidOnPort(port)
   
@@ -23,7 +43,11 @@ async function run(options) {
     } else {
       console.error(`❌ Failed to stop service (PID: ${pid})`)
       console.error('You may need to manually kill the process:')
-      console.error(`  kill -9 ${pid}`)
+      if (isWindows) {
+        console.error(`  taskkill /F /PID ${pid}`)
+      } else {
+        console.error(`  kill -9 ${pid}`)
+      }
       process.exit(1)
     }
     return
@@ -32,15 +56,10 @@ async function run(options) {
   const isListening = await isPortListening(port)
   if (isListening) {
     console.log(`Service is running on port ${port} but PID not available.`)
-    console.log('Trying to stop via pkill...')
-    
-    try {
-      execSync('pkill -f "next dev"', { stdio: 'ignore' })
-    } catch (e) {}
+    console.log('Trying to stop via process name...')
     
-    try {
-      execSync('pkill -f "next start"', { stdio: 'ignore' })
-    } catch (e) {}
+    killProcessByName('next dev')
+    killProcessByName('next start')
     
     await new Promise(resolve => setTimeout(resolve, 1000))
     
@@ -52,10 +71,15 @@ async function run(options) {
     
     console.error('❌ Failed to stop service automatically.')
     console.error('Please stop the service manually:')
-    console.error(`  pkill -f "next dev"`)
-    console.error(`  pkill -f "next start"`)
-    console.error('  or find the process and kill it:')
-    console.error(`  ps aux | grep next`)
+    if (isWindows) {
+      console.error('  taskkill /F /IM node.exe')
+      console.error('  or use Task Manager to find and end the process')
+    } else {
+      console.error(`  pkill -f "next dev"`)
+      console.error(`  pkill -f "next start"`)
+      console.error('  or find the process and kill it:')
+      console.error(`  ps aux | grep next`)
+    }
     process.exit(1)
     return
   }

package/.next/standalone/scripts/sync_skills.js

@@ -1,11 +1,11 @@
 "use strict";
 /**
- * Witty-Skill-Insight Skill Synchronizer
+ * Skill-Insight Skill Synchronizer
  *
  * Fetches configured skills from Dashboard and installs them locally.
  * Usage: node sync_skills.js [--check-only] [--agent <name>]
  *
- * Requires: ~/.witty/.env configuration
+ * Requires: ~/.skill-insight/.env configuration
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,7 +55,7 @@ const AGENTS_DIR_MAP = {
 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 => {
@@ -68,8 +68,8 @@ 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 || '127.0.0.1:3000'
+        apiKey: config['SKILL_INSIGHT_API_KEY'] || process.env.SKILL_INSIGHT_API_KEY,
+        host: config['SKILL_INSIGHT_HOST'] || process.env.SKILL_INSIGHT_HOST || '127.0.0.1:3000'
     };
 }
 async function fetchManifest(host) {

package/.next/standalone/scripts/utils.js

@@ -2,20 +2,73 @@ const { execSync, spawn } = require('child_process')
 const fs = require('fs')
 const path = require('path')
 const http = require('http')
+const os = require('os')
+
+function getDataRoot() {
+  if (process.env.SKILL_INSIGHT_DATA_DIR) {
+    return process.env.SKILL_INSIGHT_DATA_DIR
+  }
+  if (__dirname.includes('node_modules')) {
+    return path.join(os.homedir(), '.skill-insight')
+  }
+  return path.resolve(__dirname, '..')
+}
+
+function migrateDataIfNeeded() {
+  const newDataRoot = path.join(os.homedir(), '.skill-insight')
+  const newDbPath = path.join(newDataRoot, 'data', 'witty_insight.db')
+  const oldDbPath = path.resolve(__dirname, '../data/witty_insight.db')
+
+  const newExists = fs.existsSync(newDbPath)
+  const oldExists = fs.existsSync(oldDbPath)
+
+  if (newExists && oldExists) {
+    console.log('Database already exists at new location, skipping migration')
+    return
+  }
+
+  if (newExists && !oldExists) {
+    console.log('Using existing database at ' + newDbPath)
+    return
+  }
+
+  if (!newExists && oldExists) {
+    console.log('Migrating database to new location...')
+    const newDataPath = path.join(newDataRoot, 'data')
+    if (!fs.existsSync(newDataPath)) {
+      fs.mkdirSync(newDataPath, { recursive: true })
+    }
+    fs.copyFileSync(oldDbPath, newDbPath)
+    console.log('✓ Database migrated to ' + newDbPath)
+
+    try { fs.renameSync(oldDbPath, oldDbPath + '.bak') } catch (e) {}
+    return
+  }
+
+  console.log('Creating new database at ' + newDbPath)
+}
 
 function findPidOnPort(port) {
   const platform = process.platform
-  
+
   try {
     if (platform === 'win32') {
       const output = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' })
       const lines = output.trim().split('\n')
       for (const line of lines) {
         const parts = line.trim().split(/\s+/)
-        if (parts.length >= 5 && parts[1].includes(`:${port}`)) {
-          return parts[parts.length - 1]
+        if (parts.length >= 5) {
+          const localAddress = parts[1]
+          const state = parts[3]
+          const pid = parts[4]
+          const portMatch = localAddress.match(/:(\d+)$/)
+          if (portMatch && parseInt(portMatch[1]) === port && state === 'LISTENING') {
+            console.log(`[Windows] Found process ${pid} listening on port ${port}`)
+            return pid
+          }
         }
       }
+      console.log(`[Windows] No process found listening on port ${port}`)
     } else {
       if (fs.existsSync('/usr/bin/lsof') || fs.existsSync('/usr/sbin/lsof')) {
         try {
@@ -23,7 +76,7 @@ function findPidOnPort(port) {
           if (pid.trim()) return pid.trim()
         } catch (e) {}
       }
-      
+
       if (fs.existsSync('/bin/ss') || fs.existsSync('/usr/bin/ss')) {
         try {
           const output = execSync(`ss -lptn "sport = :${port}"`, { encoding: 'utf8' })
@@ -31,7 +84,7 @@ function findPidOnPort(port) {
           if (match) return match[1]
         } catch (e) {}
       }
-      
+
       if (fs.existsSync('/bin/netstat') || fs.existsSync('/usr/bin/netstat')) {
         try {
           const output = execSync(`netstat -nlp 2>/dev/null | grep ":${port} "`, { encoding: 'utf8' })
@@ -39,14 +92,14 @@ function findPidOnPort(port) {
           if (match) return match[1]
         } catch (e) {}
       }
-      
+
       try {
         const output = execSync(`fuser ${port}/tcp 2>/dev/null`, { encoding: 'utf8' })
         if (output.trim()) return output.trim()
       } catch (e) {}
     }
   } catch (e) {}
-  
+
   return null
 }
 
@@ -61,25 +114,37 @@ function isPortListening(port) {
     }, (res) => {
       resolve(true)
     })
-    
+
     req.on('error', () => {
       resolve(false)
     })
-    
+
     req.on('timeout', () => {
       req.destroy()
       resolve(false)
     })
-    
+
     req.end()
   })
 }
 
 function killProcess(pid) {
+  const platform = process.platform
+
   try {
-    execSync(`kill -9 ${pid}`, { stdio: 'ignore' })
-    return true
+    if (platform === 'win32') {
+      console.log(`[Windows] Attempting to kill process with PID ${pid} using taskkill...`)
+      execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' })
+      console.log(`[Windows] Successfully killed process ${pid}`)
+      return true
+    } else {
+      console.log(`[Unix] Attempting to kill process with PID ${pid} using kill -9...`)
+      execSync(`kill -9 ${pid}`, { stdio: 'ignore' })
+      console.log(`[Unix] Successfully killed process ${pid}`)
+      return true
+    }
   } catch (e) {
+    console.error(`Failed to kill process ${pid}: ${e.message}`)
     return false
   }
 }
@@ -87,36 +152,37 @@ function killProcess(pid) {
 function getPort(options) {
   if (options.port) return options.port
   if (process.env.PORT) return parseInt(process.env.PORT)
-  
+
   const envPath = path.join(process.cwd(), '.env')
   if (fs.existsSync(envPath)) {
     const envContent = fs.readFileSync(envPath, 'utf8')
     const match = envContent.match(/^PORT=(\d+)$/m)
     if (match) return parseInt(match[1])
   }
-  
+
   return 3000
 }
 
 function ensureEnvFile(packageRoot) {
-  const root = packageRoot || path.resolve(__dirname, '..')
+  const root = getDataRoot()
   const envPath = path.join(root, '.env')
-  const envExamplePath = path.join(root, '.env.example')
-  
+  const envExamplePath = path.join(path.resolve(__dirname, '..'), '.env.example')
+
   if (!fs.existsSync(envPath) && fs.existsSync(envExamplePath)) {
     console.log('No .env found. Initializing from .env.example...')
+    fs.mkdirSync(path.dirname(envPath), { recursive: true })
     fs.copyFileSync(envExamplePath, envPath)
-    console.log('✓ .env file created')
+    console.log('✓ .env file created at ' + envPath)
   }
 }
 
 function ensureDataDirectory(packageRoot) {
-  const root = packageRoot || path.resolve(__dirname, '..')
+  const root = getDataRoot()
   const dataPath = path.join(root, 'data')
   if (!fs.existsSync(dataPath)) {
     console.log('Creating data directory...')
     fs.mkdirSync(dataPath, { recursive: true })
-    console.log('✓ data directory created')
+    console.log('✓ data directory created at ' + dataPath)
   }
 }
 
@@ -129,7 +195,7 @@ function runCommand(command, options = {}) {
       shell: true,
       ...options
     })
-    
+
     proc.on('close', (code) => {
       if (code === 0) {
         resolve()
@@ -163,5 +229,7 @@ module.exports = {
   runCommand,
   sleep,
   isPortListening,
-  findAvailablePort
-}
+  findAvailablePort,
+  getDataRoot,
+  migrateDataIfNeeded
+}