├── data
    └── res.json
├── .browserslistrc
├── public
    ├── icon.png
    ├── favicon.ico
    └── index.html
├── src
    ├── assets
    │   ├── logo.png
    │   └── tailwind.css
    ├── shims-vue.d.ts
    ├── helpers
    │   └── index.ts
    ├── components
    │   ├── Result.vue
    │   ├── misc
    │   │   ├── Error.vue
    │   │   ├── Warning.vue
    │   │   ├── InputApiKey.vue
    │   │   ├── list
    │   │   │   ├── Loader.vue
    │   │   │   ├── ListAdd.vue
    │   │   │   ├── ListAddLine.vue
    │   │   │   └── List.vue
    │   │   ├── FileTree.vue
    │   │   ├── IconFolder.vue
    │   │   ├── Accordeon.vue
    │   │   ├── InputTextarea.vue
    │   │   ├── ToggleSwitch.vue
    │   │   └── InputText.vue
    │   ├── insight
    │   │   ├── ProjectsList.vue
    │   │   ├── FileInsight.vue
    │   │   ├── Cycles.vue
    │   │   ├── SavedResults.vue
    │   │   ├── FilesInsight.vue
    │   │   ├── ContentInsight.vue
    │   │   ├── ResultFiles.vue
    │   │   └── Result.vue
    │   ├── Info.vue
    │   ├── ProjectDescription.vue
    │   ├── Examples.vue
    │   ├── Config.vue
    │   ├── File.vue
    │   ├── TheFooter.vue
    │   ├── Files.vue
    │   ├── Settings.vue
    │   ├── TabDocs.vue
    │   └── TabInsight.vue
    ├── main.ts
    ├── controllers
    │   └── externalRoutes.ts
    ├── background.ts
    └── App.vue
├── babel.config.js
├── postcss.config.js
├── .editorconfig
├── vue.config.js
├── tailwind.config.js
├── types
    └── index.ts
├── .gitignore
├── pyScripts
    └── countTokens.py
├── serve.ps1
├── tsconfig.json
├── engine
    ├── cli_insight.ts
    ├── api.ts
    ├── cli.ts
    ├── insight.ts
    ├── cli_update.ts
    └── index.ts
├── docs.ai.config.json
├── package.json
├── .eslintrc.js
├── README.md
├── helpers
    ├── index.ts
    └── node_gm.ts
└── docs.ai.json


/data/res.json:
--------------------------------------------------------------------------------
1 | []


--------------------------------------------------------------------------------
/.browserslistrc:
--------------------------------------------------------------------------------
1 | > 1%
2 | last 2 versions
3 | not dead
4 | 


--------------------------------------------------------------------------------
/public/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kypaku/gpt-project-insight/HEAD/public/icon.png


--------------------------------------------------------------------------------
/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kypaku/gpt-project-insight/HEAD/public/favicon.ico


--------------------------------------------------------------------------------
/src/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kypaku/gpt-project-insight/HEAD/src/assets/logo.png


--------------------------------------------------------------------------------
/babel.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   presets: [
3 |     '@vue/cli-plugin-babel/preset'
4 |   ]
5 | }
6 | 


--------------------------------------------------------------------------------
/src/assets/tailwind.css:
--------------------------------------------------------------------------------
1 | @tailwind base;
2 | 
3 | @tailwind components;
4 | 
5 | @tailwind utilities;
6 | 


--------------------------------------------------------------------------------
/postcss.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   plugins: {
3 |     tailwindcss: {},
4 |     autoprefixer: {}
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
1 | [*.{js,jsx,ts,tsx,vue}]
2 | indent_style = space
3 | indent_size = 2
4 | trim_trailing_whitespace = true
5 | insert_final_newline = true
6 | 


--------------------------------------------------------------------------------
/vue.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |     pluginOptions: {
3 |         electronBuilder: {
4 |             nodeIntegration: true, // <--- added
5 |         }
6 |     }
7 | }


--------------------------------------------------------------------------------
/src/shims-vue.d.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable */
2 | declare module '*.vue' {
3 |   import type { DefineComponent } from 'vue'
4 |   const component: DefineComponent<{}, {}, any>
5 |   export default component
6 | }
7 | 


--------------------------------------------------------------------------------
/tailwind.config.js:
--------------------------------------------------------------------------------
1 | /** @type {import('tailwindcss').Config} */
2 | module.exports = {
3 |   content: ['./public/**/*.html', './src/**/*.{vue,js,ts,jsx,tsx}'],
4 |   theme: {
5 |     extend: {}
6 |   },
7 |   plugins: []
8 | }
9 | 


--------------------------------------------------------------------------------
/types/index.ts:
--------------------------------------------------------------------------------
 1 | import { DescriptionResponse } from "../engine/api"
 2 | 
 3 | export interface IFile {
 4 |     fullPath?: string
 5 |     path: string
 6 |     size?: number
 7 |     description?: string
 8 |     state?: 'queued' | 'pending' | 'done' | 'error' | 'stopped'
 9 |     prompt?: string
10 |     used?: boolean
11 |     promise?: Promise<DescriptionResponse>
12 |     content?: string
13 | }
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | node_modules
 3 | /dist
 4 | 
 5 | 
 6 | # local env files
 7 | .env.local
 8 | .env.*.local
 9 | 
10 | # Log files
11 | npm-debug.log*
12 | yarn-debug.log*
13 | yarn-error.log*
14 | pnpm-debug.log*
15 | 
16 | # Editor directories and files
17 | .idea
18 | .vscode
19 | *.suo
20 | *.ntvs*
21 | *.njsproj
22 | *.sln
23 | *.sw?
24 | docs.ai.config.json
25 | 
26 | #Electron-builder output
27 | /dist_electron
28 | 
29 | /out_engine
30 | data


--------------------------------------------------------------------------------
/pyScripts/countTokens.py:
--------------------------------------------------------------------------------
 1 | from tiktoken import Tokenizer
 2 | from tiktoken.tokenizer import TokenizerConfig
 3 | from typing import List
 4 | 
 5 | def count_tokens(text: str) -> int:
 6 |     tokenizer = Tokenizer()
 7 |     try:
 8 |         tokens = list(tokenizer.tokenize(text))
 9 |         return len(tokens)
10 |     except TokenizerException as e:
11 |         print(f"Error: {e}")
12 |         return 0
13 | 
14 | text = sys.argv[1]
15 | token_count = count_tokens(text)
16 | print(f"Количество токенов: {token_count}")


--------------------------------------------------------------------------------
/serve.ps1:
--------------------------------------------------------------------------------
 1 | Add-Type -TypeDefinition @"
 2 |     using System;
 3 |     using System.Runtime.InteropServices;
 4 | 
 5 |     public class Win32 {
 6 |         [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
 7 |         public static extern bool SetConsoleTitle(string lpConsoleTitle);
 8 |     }
 9 | "@
10 | 
11 | function Set-ConsoleTitle ($title) {
12 |     [Win32]::SetConsoleTitle($title)
13 | }
14 | 
15 | Start-Process npm -ArgumentList 'run electron:serve' -NoNewWindow
16 | $dirName = Split-Path -Path $PSScriptRoot -Leaf
17 | Start-Sleep -Seconds 5
18 | Set-ConsoleTitle "Dev: $dirName" 


--------------------------------------------------------------------------------
/public/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width,initial-scale=1.0">
 7 |     <link rel="icon" href="<%= BASE_URL %>favicon.ico">
 8 |     <title>GPTProjectsInsight</title>
 9 |   </head>
10 |   <body>
11 |     <noscript>
12 |       <strong>We're sorry but <%= htmlWebpackPlugin.options.title %> doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
13 |     </noscript>
14 |     <div id="app"></div>
15 |     <!-- built files will be auto injected -->
16 |   </body>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/src/helpers/index.ts:
--------------------------------------------------------------------------------
 1 | const { exec } = require('child_process')
 2 | const fs = require('fs')
 3 | const path = require('path')
 4 | 
 5 | export const ROOT_DIR = path.resolve(__dirname, '..', '..', '..', '..', '..', '..')
 6 | // replace all files in text with string <a>file</a>
 7 | export function wrapFilesInString(text: string, files: string[]): string {
 8 |     return text.replaceAll(new RegExp(files.join('|'), 'g'), (match) => {
 9 |         return `<a href='#' class='underline file'>${match}</a>`
10 |     })
11 | }
12 | 
13 | export function indexesOf(string: string, substring: string): number[] {
14 |     const a = []; let i = -1
15 |     while ((i = string.indexOf(substring, i + 1)) >= 0) a.push(i)
16 |     return a
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/src/components/Result.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="result">
 3 |         {{ res }}
 4 |     </div>
 5 | </template>
 6 | 
 7 | <script lang='ts'>
 8 |     import { defineComponent } from 'vue'
 9 |     import { PropType } from 'vue'
10 | 
11 |     export default defineComponent({
12 |         props: {
13 |             res: Object as PropType<any>,
14 | 
15 |         },
16 |         components: {
17 | 
18 |         },
19 |         //emits: ['update:modelValue'], this.$emit('update:modelValue', title)
20 |         data() {
21 |             return {
22 |                 
23 |             }
24 |         },
25 |         computed: {
26 | 
27 |         },
28 |         methods: {
29 | 
30 |         },
31 |     })
32 | 
33 |     </script>
34 | 
35 | <style lang="scss" scoped>
36 | 
37 | </style>
38 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { createApp } from 'vue'
 2 | import App from './App.vue'
 3 | import './assets/tailwind.css'
 4 | import shell, { ipcRenderer } from 'electron'
 5 | import { handleExternalRoutes } from './controllers/externalRoutes'
 6 | import Vue3Toasity from 'vue3-toastify'
 7 | import 'vue3-toastify/dist/index.css'
 8 | 
 9 | const app = createApp(App)
10 |     .use(Vue3Toasity)
11 |     .mount('#app')
12 | 
13 | document.addEventListener('keydown', function (e) {
14 |     if (e.which === 123) {
15 |         shell.remote.getCurrentWindow().webContents.toggleDevTools()
16 |     } else if (e.which === 116) {
17 |         location.reload()
18 |     }
19 | })
20 | 
21 | ipcRenderer.on('data', async function (evt, message) {
22 |     if (message.externalRoute) {
23 |         await handleExternalRoutes(app, message.externalRoute)
24 |     }
25 | })
26 | 


--------------------------------------------------------------------------------
/src/components/misc/Error.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="key-description bg-red-100 border border-red-300 text-red-700 px-4 py-3 rounded relative">
 3 |         <span class="block sm:inline">{{ value }}</span>
 4 |     </div>
 5 | </template>
 6 | 
 7 | <script lang='ts'>
 8 |     import { defineComponent } from "vue"
 9 | 
10 |     export default defineComponent({
11 |         props: {
12 |             value: {
13 |                 type: String,
14 |                 default: () => 'Warning!'
15 |             },
16 | 
17 |         },
18 |         components: {
19 | 
20 |         },
21 |         data() {
22 |             return {
23 | 
24 |             }
25 |         },
26 |         computed: {
27 | 
28 |         },
29 |         methods: {
30 | 
31 |         },
32 |     })
33 | 
34 |     </script>
35 | 
36 | <style lang="scss" scoped>
37 | 
38 | </style>
39 | 


--------------------------------------------------------------------------------
/src/components/misc/Warning.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="key-description bg-yellow-100 border border-yellow-300 text-yellow-700 px-4 py-3 rounded relative">
 3 |         <span class="block sm:inline" v-if="!$slots.default">{{ value }}</span>
 4 |         <slot v-else></slot>
 5 |     </div>
 6 | </template>
 7 | 
 8 | <script lang='ts'>
 9 |     import { defineComponent } from "vue"
10 | 
11 |     export default defineComponent({
12 |         props: {
13 |             value: {
14 |                 type: String,
15 |                 default: () => 'Warning!'
16 |             },
17 | 
18 |         },
19 |         components: {
20 | 
21 |         },
22 |         data() {
23 |             return {
24 | 
25 |             }
26 |         },
27 |         computed: {
28 | 
29 |         },
30 |         methods: {
31 | 
32 |         },
33 |     })
34 | 
35 |     </script>
36 | 
37 | <style lang="scss" scoped>
38 | 
39 | </style>
40 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "esnext",
 4 |     "module": "esnext",
 5 |     "strict": false,
 6 |     "jsx": "preserve",
 7 |     "importHelpers": true,
 8 |     "moduleResolution": "node",
 9 |     "skipLibCheck": true,
10 |     "esModuleInterop": true,
11 |     "allowSyntheticDefaultImports": true,
12 |     "noStrictGenericChecks": true,
13 |     "sourceMap": true,
14 |     "baseUrl": ".",
15 |     "types": [
16 |       "webpack-env"
17 |     ],
18 |     "paths": {
19 |       "@/*": [
20 |         "src/*"
21 |       ]
22 |     },
23 |     "lib": [
24 |       "esnext",
25 |       "dom",
26 |       "dom.iterable",
27 |       "scripthost"
28 |     ]
29 |   },
30 |   "include": [
31 |     "src/**/*.ts",
32 |     "src/**/*.tsx",
33 |     "src/**/*.vue",
34 |     "tests/**/*.ts",
35 |     "tests/**/*.tsx"
36 |   ],
37 |   "exclude": [
38 |     "node_modules",
39 |     "helpers/node_gm.js"
40 |   ]
41 | }
42 | 


--------------------------------------------------------------------------------
/src/components/insight/ProjectsList.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <Accordeon class="projects-list" title="Project lists">
 3 |         <List>
 4 | 
 5 |         </List>
 6 |     </Accordeon>
 7 | </template>
 8 | 
 9 | <script lang='ts'>
10 |     import { defineComponent, PropType } from 'vue'
11 | 
12 |     import Accordeon from '@/components/misc/Accordeon.vue'
13 |     import List from '@/components/misc/list/List.vue'
14 | 
15 |     export default defineComponent({
16 |         props: {
17 | 
18 |         },
19 |         components: {
20 |             Accordeon,
21 |             List,
22 | 
23 |         },
24 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
25 |         data() {
26 |             return {
27 | 
28 |             }
29 |         },
30 |         computed: {
31 | 
32 |         },
33 |         methods: {
34 | 
35 |         },
36 |     })
37 | 
38 |     </script>
39 | 
40 | <style lang="scss" scoped>
41 | 
42 | </style>
43 | 


--------------------------------------------------------------------------------
/src/components/misc/InputApiKey.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="input-api-key">
 3 |         <InputText
 4 |             class="mb-2"
 5 |             v-model:value="apiKey"
 6 |             :error="!apiKey"
 7 |             label="API Key"
 8 |             @update:value="val => (ls('apiKey', val), $emit('update:value', val))"  />
 9 |     </div>
10 | </template>
11 | 
12 | <script lang='ts'>
13 |     import { defineComponent, PropType } from 'vue'
14 |     import ls from 'local-storage'
15 |     import InputText from './InputText.vue'
16 | 
17 |     export default defineComponent({
18 |         props: {
19 | 
20 |         },
21 |         components: {
22 |             InputText
23 |         },
24 |         data() {
25 |             return {
26 |                 apiKey: ls("apiKey") as unknown as string || '' || process.env.OPENAI_KEY,
27 |                 ls
28 |             }
29 |         },
30 |         computed: {
31 | 
32 |         },
33 |         methods: {
34 | 
35 |         },
36 |     })
37 | 
38 |     </script>
39 | 
40 | <style lang="scss" scoped>
41 | 
42 | </style>
43 | 


--------------------------------------------------------------------------------
/src/components/Info.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="stat flex flex mt-2 text-sm">
 3 |         <div class="mr-4" >
 4 |             Tokens: ~{{ promptSize }}
 5 |         </div>
 6 |         <div>
 7 |             Remaining: ~{{ maxTokens - promptSize }}
 8 |         </div>
 9 |         <!-- <div class="ml-4">
10 |             Price: ${{ price.toFixed(2) }}
11 |         </div> -->
12 |     </div>
13 | </template>
14 | 
15 | <script lang='ts'>
16 |     import { defineComponent, PropType } from 'vue'
17 | 
18 |     export default defineComponent({
19 |         props: {
20 |             promptSize: Number,
21 |             maxTokens: Number,
22 |             price: Number,
23 | 
24 |         },
25 |         components: {
26 | 
27 |         },
28 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
29 |         data() {
30 |             return {
31 | 
32 |             }
33 |         },
34 |         computed: {
35 | 
36 |         },
37 |         methods: {
38 | 
39 |         },
40 |     })
41 | 
42 |     </script>
43 | 
44 | <style lang="scss" scoped>
45 | 
46 | </style>
47 | 


--------------------------------------------------------------------------------
/src/components/ProjectDescription.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <Accordeon class="project-description bg-gray-100" title="Project Description">
 3 |         <InputTextarea
 4 |             class="w-full"
 5 |             v-model="projectDescription"
 6 |             autoResize="true"
 7 |             rows="5"
 8 |         />
 9 |     </Accordeon>
10 | </template>
11 | 
12 | <script lang='ts'>
13 |     import { defineComponent, PropType } from 'vue'
14 |     import Accordeon from './misc/Accordeon.vue'
15 |     import InputTextarea from './misc/InputTextarea.vue'
16 | 
17 |     export default defineComponent({
18 |         props: {
19 | 
20 |         },
21 |         components: {
22 |             Accordeon,
23 |             InputTextarea
24 |         },
25 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
26 |         data() {
27 |             return {
28 |                 projectDescription: "",
29 | 
30 |             }
31 |         },
32 |         computed: {
33 | 
34 |         },
35 |         methods: {
36 | 
37 |         },
38 |     })
39 | 
40 |     </script>
41 | 
42 | <style lang="scss" scoped>
43 | 
44 | </style>
45 | 


--------------------------------------------------------------------------------
/engine/cli_insight.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import { program } from 'commander'
 3 | import { Insight } from './insight'
 4 | 
 5 | program
 6 |     .option('--fileNames <fileNames>', 'The list of file names')
 7 |     .option('--mode <mode>', 'The mode of insight')
 8 |     .parse(process.argv)
 9 | 
10 | const prompt = process.argv[3]
11 | const apiKey = process.argv[2]
12 | 
13 | async function main(prompt: string) {
14 |     const cliOptions = program.opts()
15 |     const fileNames = cliOptions?.fileNames.split(",")
16 |     const mode = cliOptions?.mode
17 | 
18 |     const options = {
19 |         apiKey,
20 |         cli: true,
21 |         fileNames,
22 |         mode
23 |     }
24 | 
25 |     const insight = new Insight([], options)
26 |     const res = await insight.insight(prompt, options)
27 |     console.log("The result:", res)
28 | }
29 | 
30 | // Wrap your async function in an async IIFE
31 | (async () => {
32 |     try {
33 |         await main(prompt)
34 |     } catch (error) {
35 |         console.error('Error occurred:', error)
36 |         process.exit(1)
37 |     }
38 |     console.log('Async function completed successfully')
39 |     process.exit(0)
40 | })()
41 | 


--------------------------------------------------------------------------------
/src/components/misc/list/Loader.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="loader-wrapper">
 3 |         <div class="loader"></div>
 4 |     </div>
 5 | </template>
 6 | 
 7 | <script lang='ts'>
 8 |     import { defineComponent } from "vue"
 9 | 
10 |     export default defineComponent({
11 |         props: {
12 | 
13 |         },
14 |         components: {
15 | 
16 |         },
17 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
18 |         data() {
19 |             return {
20 | 
21 |             }
22 |         },
23 |         computed: {
24 | 
25 |         },
26 |         methods: {
27 | 
28 |         },
29 |     })
30 | 
31 |     </script>
32 | 
33 | <style lang="scss" scoped>
34 |     .loader-wrapper {
35 |         display: flex;
36 |         justify-content: center;
37 |         align-items: center;
38 |         height: 100%;
39 |     }
40 | 
41 |     .loader {
42 |         border: 8px solid #f3f3f3;
43 |         border-top: 8px solid #46a575;
44 |         border-radius: 50%;
45 |         width: 60px;
46 |         height: 60px;
47 |         animation: spin 1s linear infinite;
48 |     }
49 | 
50 |     @keyframes spin {
51 |         0% { transform: rotate(0deg); }
52 |         100% { transform: rotate(360deg); }
53 |     }
54 | 
55 | </style>
56 | 


--------------------------------------------------------------------------------
/docs.ai.config.json:
--------------------------------------------------------------------------------
1 | {"excludes":"*.ps1, .vscode, assets, out, .browserslistrc, .editorconfig, .eslintrc.js, .gitignore, .vscode\\settings.json, babel.config.js, build.ps1, build_engine.ps1, postcss.config.js, dist, docs.ai.config.json, docs.ai.json, public\\favicon.ico, public\\icon.png, public\\index.html, serve.ps1, data\\res.json, src\\assets\\logo.png, src\\assets\\tailwind.css, src\\shims-vue.d.ts, tailwind.config.js, tsconfig.json, vue.config.js, components\\common\\Accordeon.vue, components\\common\\Dropdown.vue, components\\common\\InputCheckbox.vue, components\\common\\list\\ListAdd.vue, components\\common\\list\\ListAddLine.vue, components\\common\\list\\List.vue, i18n\\en.json, i18n.ts, shims-vue.d.ts, src\\components\\misc\\Accordeon.vue, src\\components\\misc\\FileTree.vue, src\\components\\misc\\IconFolder.vue, src\\components\\misc\\InputText.vue, src\\components\\Result.vue, pyScripts\\countTokens.py, src\\components\\misc\\list\\List.vue, src\\components\\misc\\list\\ListAdd.vue, src\\components\\misc\\list\\ListAddLine.vue, src\\components\\misc\\list\\Loader.vue, src\\components\\misc\\ToggleSwitch.vue, src\\components\\misc\\Warning.vue, src\\components\\misc\\Error.vue, src\\components\\misc\\InputApiKey.vue, .vsixmanifest, *.png, *.svg, webpack.config.js","temperature":0.2,"model":"gpt-4","maxTokensModel":8192,"maxTokensDir":400,"maxTokensFile":200,"documentationTimeout":40000,"insightTimeout":300000}


--------------------------------------------------------------------------------
/src/components/Examples.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="examples-wrap">
 3 |         <div>
 4 |             <button @click="showExamples = !showExamples" class="underline text-sm" >{{showExamples ? 'Hide' : 'Show'}} examples</button>
 5 |         </div>
 6 |         <div class="examples text-sm" v-if="showExamples">
 7 |             <div class="example" v-for="(item, i) in examples" :key="i">
 8 |                 <div class="cursor-pointer" @click="$emit('apply', item)">{{item}}</div>
 9 |             </div>
10 |         </div>
11 |     </div>
12 | </template>
13 | 
14 | <script lang='ts'>
15 |     import { defineComponent, PropType } from 'vue'
16 | 
17 |     export default defineComponent({
18 |         props: {
19 | 
20 |         },
21 |         components: {
22 | 
23 |         },
24 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
25 |         data() {
26 |             return {
27 |                 showExamples: false,
28 |                 examples: [
29 |                     'Make the footer sticky',
30 |                     'How to install the project',
31 |                     'How to create a script: npm run ',
32 |                     'Create README.md and its content',
33 |                 ],
34 |             }
35 |         },
36 |         computed: {
37 | 
38 |         },
39 |         methods: {
40 | 
41 |         },
42 |     })
43 | 
44 |     </script>
45 | 
46 | <style lang="scss" scoped>
47 | 
48 | </style>
49 | 


--------------------------------------------------------------------------------
/src/components/misc/list/ListAdd.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="list-add input-form flex-center">
 3 |         <!-- @keydown.tab.exact.prevent="(name = suggestionsFiltred[0])" -->
 4 |         <input
 5 |             type="text"
 6 |             v-model="name"
 7 |             :placeholder="placeholder"
 8 |             class="border-2 border-gray-300 p-1 flex-grow text-black rounded-l"
 9 |             @keypress.enter="add"/>
10 |         <button class="bg-gray-300 p-1 text-black border-2 border-gray-300 rounded-r" :disabled="!name" @click="add">Add</button>
11 |         <!-- <Suggestions :items="suggestionsFiltred" :all="suggestions" @select="val => (name = val.name)"/> -->
12 |     </div>
13 | </template>
14 | 
15 | <script lang='ts'>
16 |     import { defineComponent, PropType } from 'vue'
17 | 
18 |     export default defineComponent({
19 |         props: {
20 |             placeholder: {
21 |                 type: String,
22 |                 default: () => "Name"
23 |             },
24 | 
25 |         },
26 |         components: {
27 | 
28 |         },
29 |         data() {
30 |             return {
31 |                 name: "",
32 | 
33 |             }
34 |         },
35 |         computed: {
36 | 
37 |         },
38 |         methods: {
39 |             add() {
40 |                 this.name && this.$emit('add', this.name)
41 |                 this.name = ''
42 |             },
43 | 
44 |         },
45 |     })
46 | 
47 |     </script>
48 | 
49 | <style lang="scss" scoped>
50 | 
51 | </style>
52 | 


--------------------------------------------------------------------------------
/src/components/misc/FileTree.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <ul :class="'ml-' + 2 * level" class="flex flex-col items-start" >
 3 |         <li v-for="item in items" :key="item.fullPath"  class="flex flex-col items-start" :class="item.children && 'mb-2'">
 4 |             <div class="item flex-center gap-2" :title="item.path">
 5 |                 <input class="mr-2" :checked="value === null || value.includes(item.path) || checked" type="checkbox" @change="onSelect(item)" />
 6 |                 <span >{{ item.name + (item.children ? "/" : "") }}</span>
 7 |             </div>
 8 |             <template v-if="item.children">
 9 |                 <file-tree :items="item.children" @select="onSelect" :level="level + 1" :checked="value === null || value.includes(item.path) || checked"/>
10 |             </template>
11 |         </li>
12 |     </ul>
13 | </template>
14 | 
15 |   <script lang="ts">
16 |     import { NestedFile } from 'helpers'
17 |     import { PropType } from 'vue'
18 | 
19 |     export default {
20 |         name: 'FileTree',
21 |         props: {
22 |             checked: {
23 |                 type: Boolean,
24 |                 default: () => false
25 |             },
26 |             level: {
27 |                 type: Number,
28 |                 default: () => 0
29 |             },
30 |             items: {
31 |                 type: Array as PropType<NestedFile[]>,
32 |                 default: () => [],
33 |             },
34 |             value: {
35 |                 type: Array as PropType<string[]>,
36 |                 default: () => null,
37 |             },
38 |         },
39 |         methods: {
40 |             onSelect(item) {
41 |                 this.$emit('update:value', item.path)
42 |             },
43 |         },
44 |     }
45 |   </script>
46 | 


--------------------------------------------------------------------------------
/src/controllers/externalRoutes.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentOptionsBase, ComponentPublicInstance } from "vue"
 2 | import ls from 'local-storage'
 3 | 
 4 | function getQueryParams(url) {
 5 |     const params = {}
 6 |     const queryString = url.split("?")[1]
 7 |     if (!queryString) {
 8 |         return params
 9 |     }
10 |     const keyValuePairs = queryString.split("&")
11 |     keyValuePairs.forEach(keyValuePair => {
12 |         const [key, value] = keyValuePair.split("=")
13 |         params[key] = decodeURIComponent(value)
14 |     })
15 |     return params
16 | }
17 | 
18 | export async function handleExternalRoutes(app: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, route: string) {
19 |     const path = route.replace('gptpi://', '')
20 |     const parts = path.split('/')
21 |     const params = getQueryParams(path) as any
22 |     if (params.dir) {
23 |         ls("dir", params.dir);
24 |         (app.$root as any).dir = params.dir;
25 |         (app.$root as any).updateFilesSync(params.dir)
26 |     }
27 |     if ((params.result && app.$root.$refs?.tabInsight as any)?.loadResult) {
28 |         setTimeout(() => {
29 |             (app.$root.$refs.tabInsight as any).loadResult(params.result)
30 |         }, 0)
31 |     }
32 |     if (params.config) {
33 |         setTimeout(() => {
34 |             (app.$root as any).loadConfigRaw(params.config)
35 |         }, 0)
36 |     }
37 |     if (params.prompt) {
38 |         setTimeout(() => {
39 |             (app.$root.$refs.tabInsight as any).prompt = params.prompt
40 |         }, 500)
41 |     }
42 |     if (params.filesContent) {
43 |         setTimeout(() => {
44 |             (app.$root.$refs.tabInsight as any).includeFilesContent(params.filesContent.split(','))
45 |         }, 0)
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/components/misc/list/ListAddLine.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="list-add-line" :class="{closed: !showInput}">
 3 |         <div v-if="!showInput" @click="showInput = true" class="cursor-pointer flex plus-wrap">
 4 |             <hr class="flex-grow border-2"/>
 5 |             <button class="bg-gray-300 px-2 plus-button">+</button>
 6 |         </div>
 7 |         <div v-if="$slots.default" v-show="showInput">
 8 |             <slot/>
 9 |         </div>
10 |         <ListAdd v-show="showInput" @add="add" :placeholder="placeholder"/>
11 |     </div>
12 | </template>
13 | 
14 | <script lang='ts'>
15 |     import { defineComponent } from 'vue'
16 |     import ListAdd from './ListAdd.vue'
17 | 
18 |     export default defineComponent({
19 |         props: {
20 |             placeholder: {
21 |                 type: String,
22 |                 default: () => "Name"
23 |             },
24 |             index: Number,
25 | 
26 |         },
27 |         components: {
28 |             ListAdd,
29 | 
30 |         },
31 |         data() {
32 |             return {
33 |                 showInput: false,
34 | 
35 |             }
36 |         },
37 |         computed: {
38 | 
39 |         },
40 |         methods: {
41 |             add(val: string) {
42 |                 this.$emit('add', val)
43 |                 this.showInput = false
44 |             },
45 |         },
46 |     })
47 | 
48 |     </script>
49 | 
50 | <style lang="scss" scoped>
51 |     .list-add-line{
52 |         &.closed{
53 | 
54 |             height: 10px;
55 |         }
56 |     }
57 |     .plus-wrap{
58 |         // margin-top: 2px;
59 |         opacity: 0;
60 |         &:hover{
61 |             opacity: 1;
62 |         }
63 |     }
64 |     .plus-button{
65 |         line-height: 1;
66 |         border-bottom-left-radius: 4px;
67 |         border-bottom-right-radius: 4px;
68 |     }
69 | </style>
70 | 


--------------------------------------------------------------------------------
/src/components/misc/IconFolder.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <svg
 3 |         xmlns="http://www.w3.org/2000/svg"
 4 |         xmlns:xlink="http://www.w3.org/1999/xlink"
 5 |         version="1.1"
 6 |         width="18"
 7 |         height="18"
 8 |         viewBox="0 0 256 256"
 9 |         xml:space="preserve">
10 | 
11 |         <defs>
12 |         </defs>
13 |         <g style="stroke: none; stroke-width: 0; stroke-dasharray: none; stroke-linecap: butt; stroke-linejoin: miter; stroke-miterlimit: 10; fill: none; fill-rule: nonzero; opacity: 1;" transform="translate(1.4065934065934016 1.4065934065934016) scale(2.81 2.81)">
14 |             <path d="M 73.538 35.162 l -52.548 1.952 c -1.739 0 -2.753 0.651 -3.232 2.323 L 6.85 76.754 c -0.451 1.586 -2.613 2.328 -4.117 2.328 h 0 C 1.23 79.082 0 77.852 0 76.349 l 0 -10.458 V 23.046 v -2.047 v -6.273 c 0 -2.103 1.705 -3.808 3.808 -3.808 h 27.056 c 1.01 0 1.978 0.401 2.692 1.115 l 7.85 7.85 c 0.714 0.714 1.683 1.115 2.692 1.115 H 69.73 c 2.103 0 3.808 1.705 3.808 3.808 v 1.301 C 73.538 26.106 73.538 35.162 73.538 35.162 z" style="stroke: none; stroke-width: 1; stroke-dasharray: none; stroke-linecap: butt; stroke-linejoin: miter; stroke-miterlimit: 10; fill: rgb(224,173,49); fill-rule: nonzero; opacity: 1;" transform=" matrix(1 0 0 1 0 0) " stroke-linecap="round"/>
15 |             <path d="M 2.733 79.082 L 2.733 79.082 c 1.503 0 2.282 -1.147 2.733 -2.733 l 10.996 -38.362 c 0.479 -1.672 2.008 -2.824 3.748 -2.824 h 67.379 c 1.609 0 2.765 1.546 2.311 3.09 L 79.004 75.279 c -0.492 1.751 -1.571 3.818 -3.803 3.803 C 75.201 79.082 2.733 79.082 2.733 79.082 z" style="stroke: none; stroke-width: 1; stroke-dasharray: none; stroke-linecap: butt; stroke-linejoin: miter; stroke-miterlimit: 10; fill: rgb(255,200,67); fill-rule: nonzero; opacity: 1;" transform=" matrix(1 0 0 1 0 0) " stroke-linecap="round"/>
16 |         </g>
17 |     </svg>
18 | </template>
19 | 


--------------------------------------------------------------------------------
/src/components/insight/FileInsight.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="flex-center-between mt-2 w-full file-insight" :class="{'bg-white':!(index%2)}">
 3 |         <div class="flex-grow file p-2">
 4 |             <div class="">{{file.path}}</div>
 5 |             <div class="text-xs" v-if="file.size">{{file.size}} bytes</div>
 6 |         </div>
 7 |         <div class="flex-grow-0">
 8 |             <div v-if="showDescription">
 9 |                 <span class="text-xs">{{file.description}}</span>
10 |             </div>
11 |             <div class="flex-center mr-2">
12 |                 <button class="text-sm underline mr-2" v-if="file.description"  @click="showDescription = !showDescription" >{{showDescription ? 'Hide' : 'Show'}} description</button>
13 |                 <button class="text-sm underline"  @click="toggleDescription" >{{file.description ? 'Remove' : 'Add'}} description</button>
14 |             </div>
15 |         </div>
16 |     </div>
17 | </template>
18 | 
19 | <script lang='ts'>
20 |     import { IFile } from 'types'
21 |     import { defineComponent, PropType } from 'vue'
22 | 
23 |     export default defineComponent({
24 |         props: {
25 |             file: Object as PropType<IFile>,
26 |             index: Number,
27 | 
28 |         },
29 |         components: {
30 | 
31 |         },
32 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
33 |         data() {
34 |             return {
35 |                 showDescription: false,
36 |             }
37 |         },
38 |         computed: {
39 | 
40 |         },
41 |         methods: {
42 |             toggleDescription() {
43 |                 if (this.file.description) {
44 |                     this.$emit('removeDescription')
45 |                 } else {
46 |                     this.$emit('addDescription')
47 |                 }
48 |             },
49 | 
50 |         },
51 |     })
52 | 
53 |     </script>
54 | 
55 | <style lang="scss" scoped>
56 | 
57 | </style>
58 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "recursive-documentation",
 3 |   "version": "0.1.0",
 4 |   "private": true,
 5 |   "scripts": {
 6 |     "serve": "vue-cli-service serve",
 7 |     "build": "vue-cli-service build",
 8 |     "lint": "vue-cli-service lint",
 9 |     "electron:build": "vue-cli-service electron:build",
10 |     "electron:serve": "vue-cli-service electron:serve",
11 |     "postinstall": "electron-builder install-app-deps",
12 |     "postuninstall": "electron-builder install-app-deps"
13 |   },
14 |   "main": "background.js",
15 |   "dependencies": {
16 |     "autoprefixer": "^9.8.8",
17 |     "commander": "^10.0.0",
18 |     "core-js": "^3.6.5",
19 |     "eventsource-parser": "^1.0.0",
20 |     "gpt-simple-api-ts": "^1.0.37",
21 |     "https-browserify": "^1.0.0",
22 |     "local-storage": "^2.0.0",
23 |     "postcss": "^7.0.39",
24 |     "prismjs": "^1.29.0",
25 |     "readline": "^1.3.0",
26 |     "stream-http": "^3.2.0",
27 |     "tailwindcss": "npm:@tailwindcss/postcss7-compat@^2.2.17",
28 |     "vue": "^3.0.0",
29 |     "vue-draggable-next": "^2.2.0",
30 |     "vue3-toastify": "^0.1.11"
31 |   },
32 |   "devDependencies": {
33 |     "@types/electron-devtools-installer": "^2.2.0",
34 |     "@typescript-eslint/eslint-plugin": "^4.18.0",
35 |     "@typescript-eslint/parser": "^4.18.0",
36 |     "@vue/cli-plugin-babel": "~4.5.0",
37 |     "@vue/cli-plugin-eslint": "~4.5.0",
38 |     "@vue/cli-plugin-typescript": "~4.5.0",
39 |     "@vue/cli-service": "~4.5.0",
40 |     "@vue/compiler-sfc": "^3.0.0",
41 |     "@vue/eslint-config-standard": "^5.1.2",
42 |     "@vue/eslint-config-typescript": "^7.0.0",
43 |     "electron": "^13.6.9",
44 |     "electron-devtools-installer": "^3.1.0",
45 |     "eslint": "^6.7.2",
46 |     "eslint-plugin-import": "^2.20.2",
47 |     "eslint-plugin-node": "^11.1.0",
48 |     "eslint-plugin-promise": "^4.2.1",
49 |     "eslint-plugin-standard": "^4.0.0",
50 |     "eslint-plugin-vue": "^7.0.0",
51 |     "sass": "^1.26.5",
52 |     "sass-loader": "^8.0.2",
53 |     "typescript": "~4.1.5",
54 |     "vue-cli-plugin-electron-builder": "~2.1.1",
55 |     "vue-cli-plugin-tailwind": "~3.0.0"
56 |   }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/components/Config.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="config">
 3 |         <div>
 4 |             <b>Config: </b>
 5 |         </div>
 6 |         <div class="config flex-center">
 7 |             <span class="text-sm" :class="{'underline cursor-pointer': config}" @click="openConfig"> {{ configSource }}</span>
 8 |             <button class="ml-1" v-if="config"  @click="$emit('delConfig')" >✕</button>
 9 |             <button class="px-3 py-1 text-sm rounded blue-button ml-2" @click="$emit('loadConfig')">Load config</button>
10 |             <button v-if="configChanged || !config" class="px-3 py-1 text-sm rounded blue-button ml-2" @click="$emit('saveConfig')">
11 |                 Save config <span v-if="configChanged">*</span>
12 |             </button>
13 |         </div>
14 |     </div>
15 | </template>
16 | 
17 | <script lang='ts'>
18 |     import { shell } from 'electron'
19 |     import { DocumentationGeneratorOptions } from 'engine'
20 |     import { defineComponent, PropType } from 'vue'
21 | 
22 |     export default defineComponent({
23 |         props: {
24 |             config: Object as PropType<DocumentationGeneratorOptions>,
25 |             configFile: String,
26 |             configChanged: Boolean,
27 | 
28 |         },
29 |         components: {
30 | 
31 |         },
32 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
33 |         data() {
34 |             return {
35 | 
36 |             }
37 |         },
38 |         computed: {
39 |             configSource(): string {
40 |                 if (this.configFile) {
41 |                     return `${this.configFile}`
42 |                 }
43 |                 return `localhost (${location.origin})`
44 |             },
45 |         },
46 |         methods: {
47 |             openConfig() {
48 |                 if (this.configFile) {
49 |                     shell.openPath(this.configFile)
50 |                 }
51 |             },
52 |         },
53 |     })
54 | 
55 |     </script>
56 | 
57 | <style lang="scss" scoped>
58 |     .blue-button{
59 |         color: white;
60 |         background: #204eb2;
61 |     }
62 | 
63 | </style>
64 | 


--------------------------------------------------------------------------------
/src/components/misc/Accordeon.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="" :class="{'bg-gray-100': ownValue  && !disabled}">
 3 |         <div class="tab__header w-full" :class="{'bg-gray-100': ownValue && !disabled}">
 4 |             <div
 5 |                 class="cursor-pointer tab__link py-1 px-2 block bg-blue-dark hover:bg-blue-darker no-underline flex flex-center justify-between"
 6 |                 @click.prevent="ownValue = !ownValue"
 7 |             >
 8 |                 <strong v-if="!$slots.title" class="text-lg">{{title}}</strong>
 9 |                 <slot name="title" v-else/>
10 |                 <span class="text-sm down-Arrow" v-show="!ownValue && !disabled && !hideToggler">
11 |                     <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-chevron-down" viewBox="0 0 16 16">
12 |                         <path fill-rule="evenodd" d="M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z"/>
13 |                     </svg>
14 |                 </span>
15 |                 <span class="text-sm up-Arrow" v-show="ownValue && !disabled && !hideToggler">
16 |                     <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-chevron-up" viewBox="0 0 16 16">
17 |                         <path fill-rule="evenodd" d="M7.646 4.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1-.708.708L8 5.707l-5.646 5.647a.5.5 0 0 1-.708-.708l6-6z"/>
18 |                     </svg>
19 | 
20 |                 </span>
21 |             </div>
22 |         </div>
23 |         <div class="tab__content p-2" v-show="ownValue && !disabled"><slot /></div>
24 |     </div>
25 | </template>
26 | 
27 | <script>
28 |     import { defineComponent, PropType } from 'vue'
29 | 
30 |     export default defineComponent({
31 |         props: [
32 |             "title",
33 |             "value",
34 |             "disabled",
35 |             "hideToggler"
36 |         ],
37 |         data() {
38 |             return {
39 |                 ownValue: this.value,
40 |             }
41 |         },
42 |         watch: {
43 |             ownValue(nV) {
44 |                 this.$emit("update:value", nV)
45 |             },
46 |             value(nV) {
47 |                 this.ownValue = nV
48 |             }
49 |         }
50 |     })
51 | </script>
52 | 


--------------------------------------------------------------------------------
/src/components/File.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <Accordeon class="file gap-4 w-full" :class="{'hover:bg-gray-50': !(!file.description && file.state !== 'error')}"  :disabled="!file.description && file.state !== 'error'">
 3 |         <template #title>
 4 |             <div class="flex items-center" >
 5 |                 <div class="path mr-4 text-sm" >
 6 |                     {{ file.path }}
 7 |                 </div>
 8 |                 <div class="text-sm" :class="{'text-green-500': file.state === 'done', 'text-red-500': file.state === 'error'}">
 9 |                     {{ file.state || 'queue' }}
10 |                 </div>
11 |                 <button class="ml-4" v-if="file.state === 'queued' || !file.state"  @click="$emit('del')" >✕</button>
12 |             </div>
13 |         </template>
14 |         <div>
15 |             <div class="underline cursor-pointer text-sm" v-if="file.prompt" @click="showPrompt = !showPrompt">{{showPrompt ? 'Hide' : 'Show'  }} the prompt </div>
16 |             <div class="text-sm" v-if="showPrompt">
17 |                 <b>Prompt</b>
18 |                 <div class="prompt" >
19 |                     {{ file.prompt }}
20 |                 </div>
21 |             </div>
22 |             <div class="text-sm mt-1" >
23 |                 <b>Response</b>
24 |                 <div>
25 |                     {{ file.description }}
26 |                 </div>
27 |             </div>
28 |         </div>
29 |     </Accordeon>
30 | </template>
31 | 
32 | <script lang='ts'>
33 |     import { IFile } from 'types'
34 |     import { defineComponent, PropType } from 'vue'
35 |     import Accordeon from './misc/Accordeon.vue'
36 | 
37 |     export default defineComponent({
38 |         props: {
39 |             file: Object as PropType<IFile>,
40 | 
41 |         },
42 |         components: {
43 |             Accordeon,
44 | 
45 |         },
46 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
47 |         data() {
48 |             return {
49 |                 showPrompt: false,
50 | 
51 |             }
52 |         },
53 |         computed: {
54 | 
55 |         },
56 |         methods: {
57 | 
58 |         },
59 |     })
60 | 
61 |     </script>
62 | 
63 | <style lang="scss" scoped>
64 |     .path{
65 |         min-width: 250px;
66 |     }
67 | 
68 |     .prompt{
69 |         white-space: pre-line;
70 |     }
71 | 
72 | </style>
73 | 


--------------------------------------------------------------------------------
/src/components/TheFooter.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="footer sticky flex items-center mt-6 px-2 py-1 justify-between">
 3 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" @click="reload">Reload</button>
 4 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" @click="openLink('https://platform.openai.com/account/usage')">OpenAI Page</button>
 5 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" @click="openLink('https://github.com/Kypaku/gpt-files-documentation')">Repo</button>
 6 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" @click="clearCache">Clear Cache</button>
 7 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" @click="openDevTools">Open Dev Tools</button>
 8 |         <button class="p-1 bg-gray-200 mr-2 rounded-sm" v-if="hasVSCode" @click="openVSCode">VSCode</button>
 9 |     </div>
10 | </template>
11 | 
12 | <script lang='ts'>
13 |     import { defineComponent, PropType } from 'vue'
14 |     import ls from 'local-storage'
15 |     import { remote, shell } from 'electron'
16 | 
17 |     export default defineComponent({
18 |         props: {
19 | 
20 |         },
21 |         components: {
22 | 
23 |         },
24 |         data() {
25 |             return {
26 |                 shell,
27 |                 hasVSCode: false,
28 |             }
29 |         },
30 |         computed: {
31 | 
32 |         },
33 |         methods: {
34 |             openVSCode() {
35 |                 const { exec } = require('child_process')
36 |                 exec('code .')
37 |             },
38 | 
39 |             openDevTools() {
40 |                 remote.getCurrentWindow().webContents.toggleDevTools()
41 |             },
42 | 
43 |             clearCache() {
44 |                 ls("dir", "")
45 |                 ls("apiKey", "")
46 |                 ls("excludes", "")
47 |                 ls("settings", "")
48 |                 ls("tab", "")
49 |             },
50 |             openLink(path: string) {
51 |                 shell.openExternal(path.replaceAll('&amp;', '&'))
52 |             },
53 |             reload() {
54 |                 location.reload()
55 |             },
56 |         },
57 | 
58 |         created () {
59 |             const { exec } = require('child_process')
60 | 
61 |             exec('which code', (error, stdout, stderr) => {
62 |                 if (error) {
63 |                     console.error(`exec error: ${error}`)
64 |                     return
65 |                 }
66 | 
67 |                 if (stdout.trim() !== '') {
68 |                     this.hasVSCode = true
69 |                 } else {
70 |                     this.hasVSCode = false
71 |                 }
72 |             })
73 |         },
74 |         mounted () {
75 | 
76 |         },
77 |     })
78 | 
79 |     </script>
80 | 
81 | <style lang="scss" scoped>
82 |     .footer{
83 |         bottom: 0;
84 |         background: white;
85 |     }
86 | 
87 | </style>
88 | 


--------------------------------------------------------------------------------
/src/components/misc/InputTextarea.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="input-textarea p-0">
 3 |         <label :for="id" class="mr-2" v-if="label">{{label}}</label>
 4 |         <textarea
 5 |             type="text"
 6 |             class="border-2 rounded p-1 w-full"
 7 |             ref="input"
 8 |             :id="id"
 9 |             :value="value"
10 |             v-bind="$attrs"
11 |             :placeholder="placeholder"
12 |             @keydown.tab.exact.prevent="suggestions && suggest(suggestionsFiltered[0])"
13 |             @keypress.enter="$emit('end')"
14 |             @input="ev => $emit('update:value', ev?.target?.value)"/>
15 |         <div class="suggestions suggestions-action cursor-pointer flex flex-wrap justify-center mt-1" v-if="false">
16 |             <div class="dummy">Dummy</div>
17 |             <div
18 |                 class="suggestion mr-2 text-sm"
19 |                 v-for="(item, i) in suggestionsFiltered.slice(0, 7)"
20 |                 :class="{first: !i}"
21 |                 :key="i"
22 |                 @click="$emit('update:value', item.value)">
23 |                 {{item.name}}
24 |             </div>
25 |         </div>
26 |     </div>
27 | </template>
28 | 
29 | <script lang='ts'>
30 |     import { localeIncludes, localeStart } from "@/../helpers/node_gm"
31 |     import { defineComponent, PropType } from "vue"
32 | 
33 |     export interface InputTextSuggestion {
34 |         name: string
35 |         value: string
36 |     }
37 | 
38 |     export default defineComponent({
39 |         props: {
40 | 
41 |             placeholder: String,
42 |             label: String,
43 |             value: String,
44 |             suggestions: Object as PropType<InputTextSuggestion[]>,
45 |         },
46 |         components: {
47 | 
48 |         },
49 |         data() {
50 |             return {
51 |                 id: "input-text" + +new Date()
52 |             }
53 |         },
54 |         computed: {
55 |             suggestionsFiltered() {
56 |                 if (!this.suggestions) return []
57 |                 const byStart = this.suggestions.filter((el) => this.value ? localeStart(el.name, this.value) : true)
58 |                 const byInclude = this.suggestions.filter((el) => this.value ? localeIncludes(el.name, this.value) : true)
59 |                 return [...byStart, ...byInclude]
60 |             },
61 |         },
62 |         methods: {
63 |             suggest(suggestion: InputTextSuggestion) {
64 |                 this.$emit("update:value", suggestion.value)
65 |                 this.$emit("suggest", suggestion)
66 |             },
67 |         },
68 | 
69 |         mounted () {
70 |             this.$emit("mounted", this.$refs.input)
71 |         },
72 |     })
73 | 
74 |     </script>
75 | 
76 | <style lang="scss" scoped>
77 |     .first{
78 |         font-weight: 700;
79 |     }
80 |     .suggestion{
81 | 
82 |     }
83 |     .dummy{
84 |         opacity: 0;
85 |     }
86 | </style>
87 | 


--------------------------------------------------------------------------------
/src/components/insight/Cycles.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <Accordeon class="cycles" title="Cycles">
 3 |         <button
 4 |             class="px-4 py-1 rounded mb-2 mr-2 btn-run"
 5 |             :disabled="isLoading"
 6 |             @click="run">
 7 |             <b>{{isLoading ? 'Stop' : 'Run'}} <span v-show="loadingTime" class="font-normal" >
 8 |                 ({{ loadingTime.toFixed(1) }}s)</span>
 9 |             </b>
10 |         </button>
11 |         <List :items="filteredFiles">
12 |             <template #default="{item, index}">
13 |                 <div class="flex-center-between">
14 |                     {{ index }}
15 |                     {{ item.path }}
16 |                 </div>
17 |             </template>
18 |         </List>
19 |     </Accordeon>
20 | </template>
21 | 
22 | <script lang='ts'>
23 |     import { filter } from 'lodash'
24 |     import { defineComponent, PropType } from 'vue'
25 | 
26 |     import List from '@/components/misc/list/List.vue'
27 |     import Accordeon from '@/components/misc/Accordeon.vue'
28 |     import { IFile } from 'types'
29 |     import FileInsight from './FileInsight.vue'
30 |     import { exclude } from '@/../helpers'
31 | 
32 |     export default defineComponent({
33 |         props: {
34 |             files: {
35 |                 type: Array as PropType<IFile[]>,
36 |                 default: () => []
37 |             },
38 |             config: {
39 |                 type: Object,
40 |                 default: () => {}
41 |             },
42 |         },
43 |         components: {
44 |             FileInsight,
45 |             List,
46 |             Accordeon,
47 | 
48 |         },
49 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
50 |         data() {
51 |             return {
52 |                 loadingTime: 0,
53 |                 isLoading: false,
54 | 
55 |             }
56 |         },
57 |         computed: {
58 |             filteredFiles(): IFile[] {
59 |                 const excludes = this.config.excludes
60 |                 return exclude(this.files, excludes || '', { maxTokens: this.config.maxTokensModel || 4097, bytesPerToken: 4, maxTokensFile: this.config.maxTokensFile })
61 |             },
62 | 
63 |         },
64 |         methods: {
65 |             run() {
66 |                 this.isLoading = true
67 |                 try {
68 |                     this.filterFiles.forEach((filterFile) => {
69 |                         // need to use api instance
70 |                     })
71 |                 } catch (e) {
72 |                     console.error('Cycle run error:', e)
73 |                     const { toast } = require("vue3-toastify")
74 |                     toast.error('Cycle run error: ' + e.message)
75 |                 } finally {
76 |                     this.isLoading = false
77 |                 }
78 |             },
79 | 
80 |         },
81 |     })
82 | 
83 |     </script>
84 | 
85 | <style lang="scss" scoped>
86 | 
87 | </style>
88 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |     root: true,
 3 |     env: {
 4 |         node: true
 5 |     },
 6 |     extends: [
 7 |         'plugin:vue/vue3-essential',
 8 |         'plugin:vue/essential',
 9 |         '@vue/standard',
10 |         '@vue/typescript/recommended'
11 |     ],
12 |     parserOptions: {
13 |         ecmaVersion: 2020
14 |     },
15 |     rules: {
16 |         "vue/this-in-template": ["error", "never"],
17 |         indent: ['warn', 4],
18 |         "vue/script-indent": ["warn", 4, {
19 |             baseIndent: 1,
20 |             switchCase: 0,
21 |             ignores: []
22 |         }],
23 |         quotes: 'off',
24 |         'no-throw-literal': 'off',
25 |         'vue/no-v-for-template-key-on-child': 'off',
26 |         'vue/no-v-for-template-key': 'off',
27 |         semi: 'warn',
28 |         // 'no-explicit-any': 'on',
29 |         "@typescript-eslint/ban-types": "warn",
30 |         "no-constant-condition": "warn",
31 |         "@typescript-eslint/no-explicit-any": "warn",
32 |         '@typescript-eslint/ban-ts-comment': 'warn',
33 |         '@typescript-eslint/no-empty-function': 'warn',
34 |         'vue/no-v-model-argument': 'off',
35 |         'import/no-duplicates': 'warn',
36 |         'no-trailing-spaces': 'warn',
37 |         camelcase: 'warn',
38 |         'object-curly-spacing': 'warn',
39 |         'spaced-comment': 'warn',
40 |         'vue/no-unused-vars': 'warn',
41 |         'quote-props': 'warn',
42 |         'no-prototype-builtins': 'warn',
43 |         'vue/no-unused-components': 'warn',
44 |         'vue/html-indent': ['warn', 4],
45 |         'comma-dangle': 'off',
46 |         'vue/html-self-closing': 'off',
47 |         'vue/custom-event-name-casing': 'off',
48 |         'vue/singleline-html-element-content-newline': 'off',
49 |         'vue/attributes-order': 'off',
50 |         'vue/order-in-components': 'off',
51 |         'space-before-function-paren': 'off',
52 |         '@typescript-eslint/camelcase': 'off',
53 |         '@typescript-eslint/no-var-requires': 'warn',
54 |         'no-multiple-empty-lines': 'warn',
55 |         'eqeqeq': 'warn',
56 |         'no-cond-assign': 'off',
57 |         'no-useless-escape': 'off',
58 |         'no-useless-return': 'off',
59 |         'no-debugger': 'off',
60 |         'no-unused-expressions': 'off',
61 |         "vue/max-attributes-per-line": ["warn", {
62 |             "singleline": {
63 |               "max": 3
64 |             },      
65 |             "multiline": {
66 |               "max": 1
67 |             }
68 |           }],
69 |     },
70 |     overrides: [
71 |         {
72 |             files: [
73 |                 '**/__tests__/*.{j,t}s?(x)',
74 |                 '**/tests/unit/**/*.spec.{j,t}s?(x)'
75 |             ],
76 |             env: {
77 |                 jest: true
78 |             }
79 |         },
80 |         {
81 |             files: ["*.vue"],
82 |             rules: {
83 |                 indent: "off"
84 |             }
85 |         }
86 |     ]
87 | }
88 | 


--------------------------------------------------------------------------------
/engine/api.ts:
--------------------------------------------------------------------------------
 1 | import SimpleAPI from 'gpt-simple-api-ts'
 2 | // import SimpleAPIBrowser from 'gpt-simple-api-ts/lib/browser'
 3 | import { IFile } from '../types'
 4 | 
 5 | export const gptAPI = new SimpleAPI({ key: '' })
 6 | export const gptAPIBrowser = new SimpleAPI({ key: '' })
 7 | 
 8 | export interface IFileDescription {
 9 |     fileName: string
10 |     description: string
11 | }
12 | 
13 | export interface DescriptionResponse {
14 |     prompt: string
15 |     description: string
16 | }
17 | const timeout = 30000
18 | 
19 | const timeoutPromise = (timeout) => {
20 |     return new Promise((resolve, reject) => {
21 |         setTimeout(() => {
22 |             reject(new Error('Timeout'))
23 |         }, timeout)
24 |     })
25 | }
26 | 
27 | export const getFileDescription = async (file: IFile, content: string, opts?: any): Promise<DescriptionResponse> => {
28 |     const api = opts?.browser ? gptAPIBrowser : gptAPI
29 |     const prompt = `Create a short description for the file ${file.path}:
30 |     ${content}
31 | 
32 |     ${opts?.language ? 'Use the language: ' + opts.language : ''}
33 |     `
34 |     const gptOpts = { max_tokens: opts?.maxTokens || 150, temperature: opts?.temperature || 0.01 } as any
35 |     if (opts?.model) {
36 |         gptOpts.model = opts?.model
37 |     }
38 |     const gptRequest = api.getFirst(prompt, gptOpts)
39 |     const description = (await Promise.race([gptRequest, timeoutPromise(opts?.timeout || timeout)])) as any || ""
40 |     return { description, prompt }
41 | }
42 | 
43 | export const getFolderDescription = async (file: IFile, descriptions: IFileDescription[], opts?: any): Promise<DescriptionResponse> => {
44 |     const api = opts?.browser ? gptAPIBrowser : gptAPI
45 | 
46 |     const prompt = `I will send you the directory name and files it contains and their's descriptions and you will have to create a short description for the directory:
47 |         Directory name: ${file.path}
48 |         ${descriptions.map(desc => `
49 |         ${desc.fileName}: 
50 |         ${desc.description}`).join("\n")}
51 | 
52 |         ${opts?.language ? 'Use the language: ' + opts.language : ''}
53 |     `
54 |     const gptOpts = { max_tokens: opts?.maxTokens || 300, temperature: opts?.temperature || 0.01 } as any
55 |     if (opts?.model) {
56 |         gptOpts.model = opts?.model
57 |     }
58 |     const gptRequest = api.getFirst(prompt, gptOpts)
59 |     const description = await Promise.race([gptRequest, timeoutPromise(opts?.timeout || timeout)]) as any || ""
60 |     return { description, prompt }
61 | }
62 | 
63 | export const getAnswer = async (prompt: string, opts?: any): Promise<string> => {
64 |     const api = opts?.browser ? gptAPIBrowser : gptAPI
65 |     const gptRequest = opts?.stream === false ? api.getFirst(prompt, opts) : api.getStream(prompt, opts?.fData, opts?.fEnd, opts)
66 |     // const answer = await Promise.race([gptRequest, timeoutPromise(opts?.timeout || timeout)]) as any || ""
67 |     const answer = await gptRequest || ''
68 |     return answer
69 | }
70 | 


--------------------------------------------------------------------------------
/src/components/misc/ToggleSwitch.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="flex items-center space-x-2">
  3 |         <label :for="id" class="text-sm">{{ label }}</label>
  4 |         <div class="relative inline-block w-9 align-middle select-none" :class="{disabled}">
  5 |             <input
  6 |                 type="checkbox"
  7 |                 :id="id"
  8 |                 :name="name"
  9 |                 v-model="checked"
 10 |                 :disabled="disabled"
 11 |                 @change="updateValue"
 12 |                 class="toggle-checkbox hidden"
 13 |             />
 14 |             <label
 15 |                 :for="id"
 16 |                 class="toggle-label block overflow-hidden h-5 rounded-full bg-gray-300 cursor-pointer"
 17 |             ></label>
 18 |         </div>
 19 |     </div>
 20 | </template>
 21 | 
 22 |   <script lang="ts">
 23 |     import { defineComponent, computed } from 'vue'
 24 | 
 25 |     export default defineComponent({
 26 |         name: 'ToggleSwitch',
 27 |         props: {
 28 |             disabled: {
 29 |                 type: Boolean,
 30 |                 default: () => false
 31 |             },
 32 |             value: {
 33 |                 type: Boolean,
 34 |                 default: false,
 35 |             },
 36 |             label: {
 37 |                 type: String,
 38 |                 default: '',
 39 |             },
 40 |             name: {
 41 |                 type: String,
 42 |                 default: '',
 43 |             },
 44 |         },
 45 |         setup(props, { emit }) {
 46 |             const checked = computed({
 47 |                 get: () => props.value,
 48 |                 set: (value) => emit('update:value', value),
 49 |             })
 50 | 
 51 |             function updateValue() {
 52 |                 emit('change', checked.value)
 53 |             }
 54 | 
 55 |             return { checked, updateValue }
 56 |         },
 57 |         data() {
 58 |             return {
 59 |                 id: `toggle-${Math.random().toString(36).slice(2, 10)}`,
 60 |             }
 61 |         },
 62 |         computed: {
 63 | 
 64 |         },
 65 |         methods: {
 66 | 
 67 |         },
 68 |     })
 69 |   </script>
 70 | 
 71 |   <style lang="scss" scoped>
 72 |     .disabled{
 73 |         pointer-events: none;
 74 |         opacity: 0.4;
 75 |     }
 76 | 
 77 |   .toggle-checkbox:checked + .toggle-label {
 78 |     background: #204eb2;
 79 |   }
 80 | 
 81 |   .toggle-checkbox:checked + .toggle-label::before {
 82 |     @apply transform translate-x-4;
 83 |   }
 84 | 
 85 |   .toggle-checkbox:focus + .toggle-label {
 86 |     @apply ring-2;
 87 |     background: #204eb2;
 88 |   }
 89 | 
 90 |   .toggle-label {
 91 |     @apply transition ease-in duration-200;
 92 |   }
 93 | 
 94 |   .toggle-label:before {
 95 |     content: "";
 96 |     position: absolute;
 97 |     top: 1px;
 98 |     left: 1px;
 99 |     height: 1.1rem;
100 |     width: 1.1rem;
101 |     background-color: white;
102 |     border-radius: 9999px;
103 |     box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
104 |     transform: translateX(0);
105 |     transition: transform 200ms ease-in;
106 | }
107 | 
108 |   </style>
109 | 


--------------------------------------------------------------------------------
/src/components/Files.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <div class="files w-full">
 3 |         <div class="mb-2 text-lg">
 4 |             <b  >Files:</b>
 5 |         </div>
 6 |         <div class="flex items-center">
 7 |             <InputTextarea
 8 |                 class="text-sm w-full"
 9 |                 :value="excludes"
10 |                 label="Excludes"
11 |                 placeholder="dir1,dir2,file3,*.png"
12 |                 @update:value="val => $emit('updateExcludes', val)"/>
13 |         </div>
14 |         <div class="selected-files flex flex-col items-start my-4">
15 |             <File :file="item"  v-for="(item, i) in files" :key="`${item.path}_${item.state}`" @del="del(item)"/>
16 |         </div>
17 |         <!-- <FileTree :items="nestedFiles" /> -->
18 |     </div>
19 | </template>
20 | 
21 | <script lang='ts'>
22 |     import { defineComponent, PropType } from 'vue'
23 | 
24 |     import { IFile } from '@/../types'
25 |     import { generateNestedFiles, NestedFile, getParentFolders, getUpdatedParentFolders } from '@/../helpers'
26 |     import FileTree from './misc/FileTree.vue'
27 |     import InputTextarea from './misc/InputTextarea.vue'
28 |     import Accordeon from './misc/Accordeon.vue'
29 |     import ls from 'local-storage'
30 |     import File from '@/components/File.vue'
31 |     import { DocumentationGeneratorOptions } from 'engine'
32 | 
33 |     export default defineComponent({
34 |         props: {
35 |             isUpdateLoading: {
36 |                 type: Boolean,
37 |                 default: () => false
38 |             },
39 |             dir: {
40 |                 type: String,
41 |                 default: () => ''
42 |             },
43 |             prevResult: {
44 |                 type: Array as PropType<IFile[]>,
45 |                 default: () => []
46 |             },
47 |             files: Array as PropType<IFile[]>,
48 |             config: {
49 |                 type: Object as PropType<DocumentationGeneratorOptions>,
50 |                 default: () => null
51 |             },
52 |             defaultConfig: {
53 |                 type: Object as PropType<DocumentationGeneratorOptions>,
54 |                 default: () => null
55 |             },
56 |         },
57 |         components: {
58 |             File,
59 |             InputTextarea,
60 |             FileTree,
61 |             Accordeon,
62 |         },
63 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
64 |         data() {
65 |             return {
66 |                 ls,
67 |             }
68 |         },
69 |         computed: {
70 |             excludes(): string {
71 |                 return (this.config as any)?.excludes || ''
72 |             },
73 | 
74 |             // nestedFiles(): NestedFile[] {
75 |             //     const res = generateNestedFiles(this.files)
76 |             //     return res
77 |             // },
78 | 
79 |         },
80 |         methods: {
81 |             del(item: IFile) {
82 |                 this.$emit('updateExcludes', (this.excludes ? this.excludes + ', ' : '') + item.path)
83 |             },
84 | 
85 |         },
86 |     })
87 | 
88 |     </script>
89 | 
90 | <style lang="scss" scoped>
91 |     .path{
92 |         min-width: 250px;
93 |         text-align: left;
94 |     }
95 | 
96 | </style>
97 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # GPT Project Insight
  2 | * [Project setup](#project-setup)
  3 | * [Run Electron app](#run-electron-app)
  4 | * [Generate using CLI](#generate-using-cli)
  5 | * [Config and Settings](#config-and-options)
  6 | * [Examples](#examples)
  7 | 
  8 | An engine for generating recursive documentation and using it to work on a project with ChatGPT. To use this application, you need to have an API Key for the [Open AI API](https://platform.openai.com/)
  9 | 
 10 | ## How it works
 11 | 
 12 | ### Documentation
 13 | <img src="https://i.ibb.co/Vxt6v4g/68747470733a2f2f646f776e6c6f616465722e6469736b2e79616e6465782e72752f707265766965772f3232393838316162.webp" width="440">
 14 | 
 15 | ### Insight
 16 | <img src="https://i.ibb.co/6Yfn6Mb/2023-04-26-21-42-05.png" width="440">
 17 | 
 18 | ## Project setup
 19 | ```
 20 | npm install
 21 | ```
 22 | 
 23 | ## Run Electron app
 24 | ```
 25 | npm run electron:serve
 26 | ```
 27 | ### Open By deeplink
 28 | 
 29 | ```
 30 | gptpi://index?dir=C:/path/to/project&config=C:/path/to/config.json&result=C:/path/to/result.json&prompt=PROMPT
 31 | ```
 32 | 
 33 | <img src="https://i.ibb.co/Lr54gDg/localhost-8088-5.png" width="500">
 34 | 
 35 | ## Generate using CLI
 36 | 
 37 | ### npx
 38 | 
 39 | ```
 40 | npx tsx .\engine\cli.ts YOUR_API_KEY C:/directory/
 41 | ```
 42 | 
 43 | ### help
 44 | ```
 45 | npx tsx .\engine\cli.ts --help
 46 | ```
 47 | 
 48 | ### Build the engine and run
 49 | 
 50 | ```
 51 | tsc ./engine/cli.ts --outDir ./out_engine
 52 | ```
 53 | ```
 54 | node .\out_engine\engine\cli.js YOUR_API_KEY C:/directory/
 55 | ```
 56 | 
 57 | ### help
 58 | ```
 59 | node .\out_engine\engine\cli.js --help
 60 | ```
 61 | 
 62 | ## Config and options
 63 | ### Config:
 64 | You can load config from CLI using --config option
 65 | 
 66 | Config loads automatically from file "SELECTED_DIR/docs.ai.config.json" in the electron app
 67 | ### Options:
 68 | *  --maxTokens <maxTokens>          the maximum number of tokens that the model can accept
 69 | *  --bytesPerToken <bytesPerToken>  approximate number of bytes in 
 70 | one token
 71 | *  --maxQueries <maxQueries>        Maximum number of requests simultaneously
 72 | *  --outFile <outFile>              The file to write the result   
 73 | *  --config <config>                The file to read the config from
 74 | *  --maxTokensFile <maxTokensFile>  The max tokens values for files  --maxTokensDir <maxTokensDir>    The max tokens values for directories
 75 | *  --bytesPerToken <bytesPerToken>  approximate number of bytes in 
 76 | one token
 77 | *  --temperature <temperature>      The temperature of the model   
 78 | *  --excludes <excludes>            The pattern to exclude files. Example: dir1,dir2,file3,*.png
 79 | *  --model <model>                  The model to use
 80 | *  -h, --help                       display help for command
 81 |   
 82 | ## Examples
 83 | ### Prompt: 
 84 | ```
 85 | Make the footer sticky
 86 | ```
 87 | ### Model: GPT-4
 88 | <img src="https://i.ibb.co/X3G0VRb/localhost-8083-2.png" width="500">
 89 |   
 90 | ### Prompt: 
 91 | ```
 92 | How to install the project?
 93 | ```
 94 | ### Model: GPT-4
 95 | <img src="https://i.ibb.co/K2K7bCK/localhost-8083-3.png" width="500">
 96 |   
 97 | ### Prompt: 
 98 | ```
 99 | How to create a script: npm run build_engine
100 | ```
101 | ### Model: GPT-3.5
102 | <img src="https://i.ibb.co/sjYgBmf/localhost-8083-4.png" width="500">
103 |   
104 | 


--------------------------------------------------------------------------------
/src/components/insight/SavedResults.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <Accordeon class="saved-results" title="Saved results">
 3 |         <input
 4 |             type="search"
 5 |             v-model="searchQuery"
 6 |             placeholder="Search files..."
 7 |             class="search-files w-full mb-2 py-2 px-2" />
 8 |         <button @click="(showAll = !showAll, updateResults())" class="underline" > {{ showAll  ? 'Only for current dir' : 'Show all' }}</button>
 9 |         <List :items="filteredResults" hideTopAdd="1">
10 |             <template #default="{item, index}">
11 |                 <div class="saved-result cursor-pointer w-full mt-2 flex-center gap-2 justify-center" @click="$emit('select', item)">
12 |                     <div class="saved-result__name">
13 |                         {{item.name}}
14 |                     </div>
15 | 
16 |                     <div class="saved-result__date">
17 |                         {{item.date}}
18 |                     </div>
19 |                     <!-- <div class="saved-result__result">
20 |                         {{item.result}}
21 |                     </div>
22 |                     <div class="saved-result__prompt">
23 |                         {{item.prompt}}
24 |                     </div> -->
25 |                 </div>
26 |             </template>
27 |         </List>
28 |     </Accordeon>
29 | </template>
30 | 
31 | <script lang='ts'>
32 |     import { ROOT_DIR } from '@/helpers'
33 |     import { getBasename, getFileDate, getFilesFull, readFileJSON } from '@/../helpers/node_gm'
34 |     import { defineComponent, PropType } from 'vue'
35 |     import Accordeon from '@/components/misc/Accordeon.vue'
36 |     import List from '@/components/misc/list/List.vue'
37 | 
38 |     export interface IResult {
39 |         dir: string,
40 |         result: string,
41 |         prompt?: string,
42 |         name?: string,
43 |         date?: string,
44 |     }
45 | 
46 |     export default defineComponent({
47 |         props: {
48 |             dir: String,
49 |         },
50 |         components: {
51 |             List,
52 |             Accordeon,
53 | 
54 |         },
55 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
56 |         data() {
57 |             return {
58 |                 showAll: false,
59 |                 searchQuery: '',
60 |                 results: [],
61 |             }
62 |         },
63 |         computed: {
64 |             filteredResults(): IResult[] {
65 |                 if (!this.searchQuery) return this.results
66 |                 const query = this.searchQuery.toLowerCase()
67 |                 return this.results.filter((file: IResult) => file.name.toLowerCase().includes(query))
68 |             },
69 |         },
70 |         methods: {
71 |             updateResults() {
72 |                 getFilesFull(ROOT_DIR + '/data/').forEach((file) => {
73 |                     if (getBasename(file).startsWith('result_')) {
74 |                         const content = readFileJSON(file)
75 |                         if (content && (this.showAll ? true : content.dir === this.dir)) {
76 |                             this.results.push({ ...content, name: getBasename(file), date: getFileDate(file).toLocaleString() })
77 |                         }
78 |                     }
79 |                 })
80 |             }
81 |         },
82 |         created() {
83 |             this.updateResults()
84 |         }
85 |     })
86 | 
87 |     </script>
88 | 
89 | <style lang="scss" scoped>
90 | 
91 | </style>
92 | 


--------------------------------------------------------------------------------
/src/components/misc/InputText.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="input-text">
  3 |         <div class="text-left" >
  4 |             <label :for="id" class="mr-2">{{label}}</label>
  5 |         </div>
  6 |         <div class="text-left">
  7 |             <input
  8 |                 type="text"
  9 |                 class="border-2 ym-disable-keys text-sm py-1 px-2 rounded"
 10 |                 :class="{error}"
 11 |                 ref="input"
 12 |                 :id="id"
 13 |                 :value="value"
 14 |                 v-bind="$attrs"
 15 |                 :placeholder="placeholder"
 16 |                 @keydown.tab.exact.prevent="suggestions && suggest(suggestionsFiltered[0])"
 17 |                 @keypress.enter="$emit('end')"
 18 |                 @input="ev => $emit('update:value', ev?.target?.value)"/>
 19 |             <div class="suggestions suggestions-action cursor-pointer flex flex-wrap justify-center mt-1" v-if="suggestionsFiltered.length">
 20 |                 <div class="dummy">Dummy</div>
 21 |                 <div
 22 |                     class="suggestion mr-2 text-sm"
 23 |                     v-for="(item, i) in suggestionsFiltered.slice(0, 7)"
 24 |                     :class="{first: !i}"
 25 |                     :key="i"
 26 |                     @click="$emit('update:value', item.value)">
 27 |                     {{item.name}}
 28 |                 </div>
 29 |             </div>
 30 |         </div>
 31 |     </div>
 32 | </template>
 33 | 
 34 | <script lang='ts'>
 35 |     import { localeIncludes, localeStart } from '@/../helpers/node_gm'
 36 |     import { defineComponent, PropType } from 'vue'
 37 |     import { uniq } from 'lodash'
 38 | 
 39 |     export interface InputTextSuggestion {
 40 |         name: string
 41 |         value: string
 42 |     }
 43 | 
 44 |     export default defineComponent({
 45 |         props: {
 46 |             error: {
 47 |                 type: Boolean,
 48 |                 default: () => false
 49 |             },
 50 |             placeholder: String,
 51 |             label: String,
 52 |             value: String,
 53 |             suggestions: Object as PropType<InputTextSuggestion[]>,
 54 |         },
 55 |         components: {
 56 | 
 57 |         },
 58 |         data() {
 59 |             return {
 60 |                 id: 'input-text' + +new Date()
 61 |             }
 62 |         },
 63 |         computed: {
 64 |             suggestionsFiltered() {
 65 |                 if (!this.suggestions) return []
 66 |                 const byStart = this.suggestions.filter((el) => this.value ? localeStart(el?.name || '', this.value) : true)
 67 |                 const byInclude = this.suggestions.filter((el) => this.value ? localeIncludes(el?.name || '', this.value) : true)
 68 |                 return uniq([...byStart, ...byInclude])
 69 |             },
 70 |         },
 71 |         methods: {
 72 |             suggest(suggestion: InputTextSuggestion) {
 73 |                 this.$emit('update:value', suggestion.value)
 74 |                 this.$emit('suggest', suggestion)
 75 |             },
 76 |         },
 77 | 
 78 |         mounted () {
 79 |             this.$emit('mounted', this.$refs.input)
 80 |         },
 81 |     })
 82 | 
 83 |     </script>
 84 | 
 85 | <style lang="scss" scoped>
 86 |     .error{
 87 |         @apply border-red-400;
 88 |     }
 89 | 
 90 |     .first{
 91 |         font-weight: 700;
 92 |     }
 93 |     .suggestion{
 94 | 
 95 |     }
 96 |     .dummy{
 97 |         opacity: 0;
 98 |     }
 99 | </style>
100 | 


--------------------------------------------------------------------------------
/src/components/misc/list/List.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="list-comp flex flex-col items-center">
  3 |         <div class="search pb-2 w-full" v-if="showSearch">
  4 |             <input class="w-full py-1"  type="search" placeholder="Search" v-model="search"/>
  5 |         </div>
  6 |         <div class="list-add-wrapper" v-if="$slots.add" v-show="!hideTopAdd">
  7 |             <slot name="add" :add="val => $emit('add', {name: val, pos: 0})" :index="0"/>
  8 |         </div>
  9 |         <ListAdd
 10 |             v-else
 11 |             @add="val => $emit('add', {name: val, pos: 0})"
 12 |             v-show="!hideTopAdd"
 13 |             :placeholder="addPlaceholder"/>
 14 |         <Loader v-if="loading"/>
 15 |         <template v-else>
 16 |             <template v-for="(item, i) in filteredItems" :key="i">
 17 |                 <slot
 18 |                     v-if="$slots.default"
 19 |                     :item="item"
 20 |                     :index="i"
 21 |                     @click="$emit('select', item)"/>
 22 |                 <button class="notebook bg-blue-500 p-1" @click="$emit('select', item)" v-else>
 23 |                     {{item.name}}
 24 |                 </button>
 25 |                 <ListAddLine
 26 |                     class="w-full"
 27 |                     v-if="addInPos"
 28 |                     @add="val => $emit('add', {name: val, pos: i + 1})"
 29 |                     :index="i"
 30 |                     :ref="'addLine' + (i + 1)"
 31 |                     :placeholder="addPlaceholder"
 32 |                 >
 33 |                     <slot
 34 |                         name="add"
 35 |                         v-if="$slots.add"
 36 |                         :add="val => addFromSlot(val, i + 1)"
 37 |                         :index="i"/>
 38 |                 </ListAddLine>
 39 |             </template>
 40 |         </template>
 41 | 
 42 |     </div>
 43 | </template>
 44 | 
 45 | <script lang='ts'>
 46 |     import { defineComponent, PropType } from "vue"
 47 |     import ListAdd from "./ListAdd.vue"
 48 |     import ListAddLine from "./ListAddLine.vue"
 49 |     import Loader from "./Loader.vue"
 50 |         import { localeIncludes } from "@/../helpers/node_gm"
 51 | 
 52 |     export default defineComponent({
 53 |         props: {
 54 |             searchField: {
 55 |                 type: String,
 56 |             },
 57 |             showSearch: {
 58 |                 type: Boolean,
 59 |             },
 60 |             addPlaceholder: {
 61 |                 type: String,
 62 |                 default: () => "Name"
 63 |             },
 64 |             loading: {
 65 |                 type: Boolean,
 66 |                 default: () => false
 67 |             },
 68 |             items: Array,
 69 |             addInPos: Boolean,
 70 |             hideTopAdd: Boolean
 71 |         },
 72 |         components: {
 73 |             Loader,
 74 |             ListAddLine,
 75 |             ListAdd,
 76 | 
 77 |         },
 78 |         data() {
 79 |             return {
 80 |                 search: '',
 81 | 
 82 |             }
 83 |         },
 84 |         computed: {
 85 |             filteredItems(): any[] {
 86 |                 return this.items?.filter((item: any) => this.search ? localeIncludes(item[this.searchField || 'name'], this.search) : true)
 87 |             },
 88 | 
 89 |         },
 90 |         methods: {
 91 |             addFromSlot(val: string, index: number) {
 92 |                 this.$emit("add", { name: val, pos: index });
 93 |                 (this.$refs["addLine" + index] as any)[0].showInput = false
 94 |             },
 95 |         },
 96 |     })
 97 | 
 98 |     </script>
 99 | 
100 | <style lang="scss">
101 | 
102 | </style>
103 | 


--------------------------------------------------------------------------------
/engine/cli.ts:
--------------------------------------------------------------------------------
 1 | import { DocumentationGenerator, DocumentationGeneratorOptions } from "."
 2 | import { exclude, getFilesInDirectory } from "../helpers"
 3 | import { existFile, isDirectory, readFileJSON, writeFileJSON } from "../helpers/node_gm"
 4 | import * as path from 'path'
 5 | import { program } from 'commander'
 6 | 
 7 | program
 8 |     .option('--maxTokens <maxTokens>', 'the maximum number of tokens that the model can accept')
 9 |     .option('--bytesPerToken <bytesPerToken>', 'approximate number of bytes in one token')
10 |     .option('--maxQueries <maxQueries>', 'Maximum number of requests simultaneously')
11 |     .option('--outFile <outFile>', 'The file to write the result')
12 |     .option('--config <config>', 'The file to read the config from')
13 |     .option('--maxTokensFile <maxTokensFile>', 'The max tokens values for files')
14 |     .option('--maxTokensDir <maxTokensDir>', 'The max tokens values for directories')
15 |     .option('--bytesPerToken <bytesPerToken>', 'approximate number of bytes in one token')
16 |     .option('--temperature <temperature>', 'The temperature of the model')
17 |     .option('--excludes <excludes>', 'The pattern to exclude files. Example: dir1,dir2,file3,*.png')
18 |     .option('--model <model>', 'The model to use')
19 |     .parse(process.argv)
20 | 
21 | const rootDirOrSelectedFile = process.argv[3]
22 | const apiKey = process.argv[2]
23 | 
24 | async function main(rootDirOrSelectedFile: string) {
25 |     const isDir = isDirectory(rootDirOrSelectedFile)
26 |     const cliOptions = program.opts()
27 |     const configFile = cliOptions?.config || (isDir ? path.resolve(rootDirOrSelectedFile, "docs.ai.config.json") : path.resolve(__dirname, "docs.ai.config.json"))
28 |     const config: DocumentationGeneratorOptions & {outFile?: string, excludes?: string} = existFile(configFile) ? readFileJSON(configFile) : null
29 | 
30 |     const maxQueries = +cliOptions?.maxQueries || config?.maxQueries || 5
31 |     const maxTokens = +cliOptions?.maxTokens || config?.maxTokens || 4097
32 |     const bytesPerToken = +cliOptions?.bytesPerToken || config?.bytesPerToken || 4
33 |     const temperature = +cliOptions?.temperature || config?.temperature
34 |     const model = cliOptions?.model || config?.model
35 |     const maxTokensFile = +cliOptions?.maxTokensFile || config?.maxTokensFile
36 |     const maxTokensDir = +cliOptions?.maxTokensDir || config?.maxTokensDir
37 |     const excludes = cliOptions?.excludes || config?.excludes
38 | 
39 |     const options = {
40 |         maxQueries,
41 |         apiKey,
42 |         cli: true,
43 |         maxTokens,
44 |         bytesPerToken,
45 |         temperature,
46 |         model,
47 |         maxTokensFile,
48 |         maxTokensDir
49 |     }
50 | 
51 |     // console.log("main", {options})
52 | 
53 |     let files = isDir ? getFilesInDirectory(rootDirOrSelectedFile, rootDirOrSelectedFile) : readFileJSON(rootDirOrSelectedFile)
54 |     if (excludes) {
55 |         files = exclude(files, excludes, {...options})
56 |     }
57 |     const generator = new DocumentationGenerator(files, options)
58 |     await generator.start()
59 |     const resFile = cliOptions?.outFile || config?.outFile || (isDir ? path.resolve(rootDirOrSelectedFile, "docs.ai.json") : path.resolve(__dirname, "docs.ai.json"))
60 |     writeFileJSON(resFile, files.map((selectedFile) => ({ path: selectedFile.path, description: selectedFile.description, size: selectedFile.size })))
61 |     console.log("Done! The result in the file:", resFile)
62 | }
63 | 
64 | // Wrap your async function in an async IIFE
65 | (async () => {
66 |     try {
67 |         await main(rootDirOrSelectedFile)
68 |     } catch (error) {
69 |         console.error('Error occurred:', error)
70 |         process.exit(1)
71 |     }
72 |     console.log('Async function completed successfully')
73 |     process.exit(0)
74 | })()
75 | 


--------------------------------------------------------------------------------
/src/components/insight/FilesInsight.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <Accordeon title="Files" class="bg-gray-100 rounded mt-2 files-accorderon">
  3 |         <div class="w-full text-right px-2">
  4 |             <button class="text-sm underline"  @click="showRaw = !showRaw" >{{showRaw ? 'Hide' : 'Show'}} raw text</button>
  5 |         </div>
  6 |         <!-- <ToggleSwitch
  7 |             label="Only files from documentation"
  8 |             v-model="onlyDocsFiles"
  9 |         /> -->
 10 |         <!-- <input
 11 |             type="search"
 12 |             v-model="searchQuery"
 13 |             placeholder="Search files..."
 14 |             class="search-files w-full mb-2 py-2 px-2" /> -->
 15 |         <div class="files-editor" v-if="!showRaw">
 16 |             <List :items="filteredFiles" :show-search="true" :searchField="'path'" @add="val => $emit('update:value', val.name + '\n' + value)" :add-placeholder="'relative/path/to/file'">
 17 |                 <template #default="{item, index}">
 18 |                     <FileInsight
 19 |                         :file="item"
 20 |                         :index="index"
 21 |                         @addDescription="$emit('toggleDescription', {file: item.path, value: true})"
 22 |                         @removeDescription="$emit('toggleDescription', {file: item.path, value: false})"
 23 |                     />
 24 |                 </template>
 25 |             </List>
 26 |         </div>
 27 |         <InputTextarea
 28 |             v-else
 29 |             :value="value"
 30 |             class="mt-2 w-full"
 31 |             :rows="10"
 32 |             @update:value="val => $emit('update:value', val)" />
 33 |     </Accordeon>
 34 | </template>
 35 | 
 36 | <script lang='ts'>
 37 |     import { defineComponent, PropType } from 'vue'
 38 |     import Accordeon from '../misc/Accordeon.vue'
 39 |     import List from '../misc/list/List.vue'
 40 |     import InputTextarea from '../misc/InputTextarea.vue'
 41 |     import { IFile } from '@/../types'
 42 |     import FileInsight from './FileInsight.vue'
 43 |     import ToggleSwitch from '../misc/ToggleSwitch.vue'
 44 | 
 45 |     export default defineComponent({
 46 |         props: {
 47 |             value: String,
 48 | 
 49 |         },
 50 |         components: {
 51 |             FileInsight,
 52 |             Accordeon,
 53 |             InputTextarea,
 54 |             List,
 55 |             ToggleSwitch
 56 |         },
 57 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
 58 |         data() {
 59 |             return {
 60 |                 onlyDocsFiles: false,
 61 |                 showRaw: false,
 62 |                 searchQuery: '',
 63 | 
 64 |             }
 65 |         },
 66 |         computed: {
 67 |             files(): IFile[] {
 68 |                 return this.value.split("\n").map((file: string, i) => {
 69 |                     return {
 70 |                         path: file.split(" ")?.[0],
 71 |                         size: file.match(/(\d+)bytes/)?.[1],
 72 |                         description: file.match(/\sDescription:\s(.+)$/)?.[1]
 73 |                     }
 74 |                 })
 75 |             },
 76 |             filteredFiles(): IFile[] {
 77 |                 if (!this.searchQuery) return this.files
 78 |                 const query = this.searchQuery.toLowerCase()
 79 |                 return this.files.filter(file => file.path.toLowerCase().includes(query))
 80 |             },
 81 |         },
 82 |         methods: {
 83 | 
 84 |         },
 85 |     })
 86 | 
 87 |     </script>
 88 | 
 89 | <style lang="scss" scoped>
 90 |     .search-files{
 91 |         border-bottom: 1px solid #ccc;
 92 |     }
 93 | 
 94 |     .files-editor{
 95 |         max-height: 400px;
 96 |         overflow-y: scroll;
 97 |     }
 98 | 
 99 |     ::v-deep.files-accorderon{
100 |         .tab__content {
101 |             padding: 0;
102 |         }
103 |     }
104 | 
105 |     .file{
106 |         width: 200px;
107 |         min-width: 200px;
108 |     }
109 | 
110 | </style>
111 | 


--------------------------------------------------------------------------------
/engine/insight.ts:
--------------------------------------------------------------------------------
  1 | import { lengthToTokensCount } from "../helpers"
  2 | import { readFileJSON } from "../helpers/node_gm"
  3 | import { IFile } from "../types"
  4 | import { getAnswer, gptAPI, gptAPIBrowser } from "./api"
  5 | 
  6 | export interface InsightOptions {
  7 |     apiKey?: string
  8 |     cli?: boolean
  9 |     fileNames?: string[]
 10 |     filesStr?: string
 11 |     contentStr?: string
 12 |     mode?: 'singlePrompt' | 'chat'
 13 |     maxTokensShift?: number
 14 |     timeout?: number
 15 |     maxTokensModel?: number
 16 |     maxTokensAnswer?: number
 17 |     rawPrompt?: string
 18 |     stream?: boolean
 19 |     fData?: any
 20 |     browser?: boolean
 21 |     language?: string
 22 | }
 23 | 
 24 | export function getMaxTokens (promtL: number, opts: InsightOptions): number {
 25 |     const maxTokens = Math.floor((opts?.maxTokensModel || 4097) - lengthToTokensCount(promtL) - (opts?.maxTokensShift || 300))
 26 |     return opts?.maxTokensAnswer ? (maxTokens > opts.maxTokensAnswer ? opts.maxTokensAnswer : maxTokens) : maxTokens
 27 | }
 28 | 
 29 | export class Insight {
 30 |     private documentation: IFile[];
 31 |     private opts: Partial<InsightOptions>;
 32 |     private isStopped: boolean;
 33 | 
 34 |     constructor(documentation: IFile[], opts?: InsightOptions) {
 35 |         this.documentation = documentation
 36 |         this.opts = opts || {}
 37 |         this.isStopped = false
 38 |     }
 39 | 
 40 |     public async askFiles(prompt: string, opts?: InsightOptions): Promise<string> {
 41 |         if (this.opts.apiKey) {
 42 |             gptAPI.setApiKey(this.opts.apiKey)
 43 |             gptAPIBrowser.setApiKey(this.opts.apiKey)
 44 |         }
 45 |         const thePrompt = `I give a question: "${prompt}"
 46 | And the list of files:
 47 | ${opts?.filesStr || (opts?.fileNames || []).join('\n')}
 48 | 
 49 | You need to ask me about descriptions or content of which exactly files you need to answer the question.
 50 | Use the format: file1, file2, ...
 51 | `
 52 | // If you don't know which exactly files you need, you have to suggest.
 53 | // If you don't have enough information,
 54 | // You need to decide whether you have enough information to answer the question or not.
 55 | // If you have enough information, you can answer the question.
 56 |         // call the first prompt
 57 |         console.log("insight.askFiles", { thePromptLength: lengthToTokensCount(thePrompt.length) })
 58 |         const res = await getAnswer(thePrompt, { timeout: 120000, max_tokens: getMaxTokens(thePrompt.length, opts as InsightOptions), ...opts })
 59 |         return res || ''
 60 |     }
 61 | 
 62 |     public async ask(prompt: string, opts?: InsightOptions): Promise<string> {
 63 |         if (this.opts.apiKey) {
 64 |             gptAPI.setApiKey(this.opts.apiKey)
 65 |             gptAPIBrowser.setApiKey(this.opts.apiKey)
 66 |         }
 67 | 
 68 |         const thePrompt = opts?.rawPrompt || this.generatePrompt(prompt, opts)
 69 |         console.log("insight.ask", { thePromptLength: lengthToTokensCount(thePrompt.length) })
 70 |         const res = this.getAnswer(thePrompt, opts)
 71 |         return res || ''
 72 |     }
 73 | 
 74 |     public async getAnswer(prompt: string, opts?: InsightOptions): Promise<string> {
 75 |         const max_tokens = getMaxTokens(prompt.length, opts as InsightOptions)
 76 |         console.log("getAnswer", { max_tokens })
 77 |         return await getAnswer(prompt, { timeout: 120000, max_tokens, ...opts })
 78 |     }
 79 | 
 80 |     public generatePrompt(prompt: string, opts?: InsightOptions): string {
 81 |         const filesStr = opts?.filesStr || (opts?.fileNames || []).join('\n')
 82 |         const contentStr = opts?.contentStr || ''
 83 | 
 84 |         return `${prompt}
 85 |         ${(filesStr || contentStr) ? 'To answer' : ''}
 86 |         ${filesStr ? 'Use the list of files:\n' + filesStr : ''}
 87 |         ${contentStr ? 'Use the content:\n' + contentStr : ''}
 88 |         ${opts?.language ? 'Use the language: ' + opts.language : ''}
 89 |         `
 90 |     }
 91 | 
 92 |     public parseFiles(res: string): string[] {
 93 |         const result = [] as string[]
 94 |         res.match(/needFilesDescriptions: \[(.*?)\]/g)?.forEach((match) => {
 95 |             const files = match.replace('needFilesDescriptions: [', '').replace(']', '').split(', ')
 96 |             result.push(...files)
 97 |         })
 98 |         return result
 99 |     }
100 | 
101 |     public stop(): void {
102 |         this.isStopped = true
103 |     }
104 | 
105 |     // abort
106 |     public abort(): void {
107 |         gptAPI?.abortStream()
108 |         gptAPIBrowser?.abortStream()
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/src/components/insight/ContentInsight.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <Accordeon title="Content" class="bg-gray-100 rounded mt-2">
  3 |         <div class="w-full text-right px-2">
  4 |             <button class="text-sm underline"  @click="showRaw = !showRaw" >{{showRaw ? 'Hide' : 'Show'}} raw text</button>
  5 |         </div>
  6 |         <input
  7 |             type="search"
  8 |             v-model="searchQuery"
  9 |             placeholder="Search files..."
 10 |             class="search-files w-full mb-2 py-1 px-2" />
 11 |         <div class="files-editor" v-if="!showRaw">
 12 |             <List :items="filteredFiles" @add="val => $emit('update:value', val.name + '\n' + value)" :hideTopAdd="true">
 13 |                 <template #default="{item, index}">
 14 |                     <div class="flex-center-between w-full">
 15 |                         <div class="flex-grow file p-2">
 16 |                             <div class="">{{item.path}}</div>
 17 |                             <div class="text-xs" v-if="item.size">{{lengthToTokensCount(item.size)}} tokens</div>
 18 |                         </div>
 19 |                         <div class="flex-grow-0">
 20 |                             <button class="text-sm underline"  @click="toggleContent(item)" >{{item.content ? 'Remove' : 'Add'}} content</button>
 21 | 
 22 |                         </div>
 23 |                     </div>
 24 |                 </template>
 25 |             </List>
 26 |         </div>
 27 |         <InputTextarea
 28 |             v-else
 29 |             :value="value"
 30 |             @update:value="val => $emit('update:value', val)"
 31 |             class="mt-2 w-full text-xs"
 32 |             :rows="10"/>
 33 |     </Accordeon>
 34 | </template>
 35 | 
 36 | <script lang='ts'>
 37 |     import { defineComponent, PropType } from 'vue'
 38 |     import Accordeon from '../misc/Accordeon.vue'
 39 |     import InputTextarea from '../misc/InputTextarea.vue'
 40 |     import { IFile } from 'types'
 41 |     import List from '../misc/list/List.vue'
 42 |     import { getFileSize, readFile } from '@/../helpers/node_gm'
 43 |     import path from 'path'
 44 |     import { ENDOFFILE } from '../TabInsight.vue'
 45 |     import { lengthToTokensCount } from '@/../helpers'
 46 | 
 47 |     export default defineComponent({
 48 |         props: {
 49 |             value: String,
 50 |             documentation: {
 51 |                 type: Array as PropType<IFile[]>,
 52 |                 default: () => []
 53 |             },
 54 |             dir: {
 55 |                 type: String,
 56 |                 default: () => ''
 57 |             },
 58 |         },
 59 |         components: {
 60 |             Accordeon,
 61 |             InputTextarea,
 62 |             List
 63 |         },
 64 |         // emits: ['update:modelValue'], this.$emit('update:modelValue', title)
 65 |         data() {
 66 |             return {
 67 |                 lengthToTokensCount,
 68 |                 showRaw: false,
 69 |                 searchQuery: '',
 70 |             }
 71 |         },
 72 |         computed: {
 73 |             files(): IFile[] {
 74 |                 return this.documentation.map((file: IFile, i) => {
 75 |                     const index = this.value.indexOf(file.path + ":")
 76 |                     return {
 77 |                         path: file.path,
 78 |                         size: file.fullPath ? getFileSize(file.fullPath) : file.size,
 79 |                         content: index !== -1
 80 |                     }
 81 |                 })
 82 |             },
 83 |             filteredFiles(): IFile[] {
 84 |                 if (!this.searchQuery) return this.files
 85 |                 const query = this.searchQuery.toLowerCase()
 86 |                 return this.files.filter(file => file.path.toLowerCase().includes(query))
 87 |             },
 88 |         },
 89 |         methods: {
 90 |             toggleContent(item: IFile) {
 91 |                 if (item.content) {
 92 |                     const index = this.value.indexOf(item.path + ":")
 93 |                     const slicedValue = this.value.slice(0, index)
 94 |                     const nextIndex = this.value.indexOf(ENDOFFILE, index)
 95 |                     const slicedNextValue = this.value.slice(nextIndex + ENDOFFILE.length, -1)
 96 |                     this.$emit('update:value', slicedValue + slicedNextValue)
 97 |                 } else {
 98 |                     this.$emit('update:value', this.value + '\n' + item.path + ":\n" + readFile(path.resolve(this.dir, item.path)) + '\n' + ENDOFFILE)
 99 |                 }
100 |             },
101 | 
102 |         },
103 |     })
104 | 
105 |     </script>
106 | 
107 | <style lang="scss" scoped>
108 |     .search-files{
109 |         border-bottom: 1px solid #ccc;
110 |     }
111 | 
112 |     .files-editor{
113 |         max-height: 400px;
114 |     overflow-y: scroll;
115 |     }
116 | 
117 | </style>
118 | 


--------------------------------------------------------------------------------
/src/background.ts:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | import { app, protocol, BrowserWindow } from 'electron'
  4 | import { createProtocol } from 'vue-cli-plugin-electron-builder/lib'
  5 | import installExtension, { VUEJS3_DEVTOOLS } from 'electron-devtools-installer'
  6 | import * as path from 'path'
  7 | const isDevelopment = process.env.NODE_ENV !== 'production'
  8 | const lockApp = app.requestSingleInstanceLock()
  9 | const { dialog } = require('electron')
 10 | let mainWindow // Keep a global reference to avoid being garbage collected
 11 | 
 12 | // Scheme must be registered before the app is ready
 13 | protocol.registerSchemesAsPrivileged([
 14 |     { scheme: 'gptpi', privileges: { secure: true, standard: true } }
 15 | ])
 16 | 
 17 | function createWindowOne () {
 18 |     const iconPath = path.join(__dirname, '..', 'public', 'icon.png')
 19 | 
 20 |     return new BrowserWindow({
 21 |         width: 600,
 22 |         height: 800,
 23 |         icon: iconPath,
 24 |         webPreferences: {
 25 |             enableRemoteModule: true,
 26 |             contextIsolation: false,
 27 |             nodeIntegration: true,
 28 |         }
 29 |     })
 30 | }
 31 | 
 32 | async function createWindow () {
 33 |     // Create the browser window.
 34 |     const win = createWindowOne()
 35 |     mainWindow = win
 36 |     win.setMenuBarVisibility(false)
 37 |     if (!lockApp) {
 38 |         app.quit()
 39 |     } else {
 40 |         app.on('second-instance', async (ev, argv, workDir) => {
 41 |             const win = createWindowOne()
 42 |             win.setMenuBarVisibility(false)
 43 |             await win.loadURL(process.env.WEBPACK_DEV_SERVER_URL as string)
 44 |             win.webContents.send('data', { externalRoute: argv[argv.length - 1] })
 45 |             if (win) {
 46 |                 if (win.isMinimized()) win.restore()
 47 |                 win.focus()
 48 |             }
 49 |         })
 50 |     }
 51 |     if (process.env.WEBPACK_DEV_SERVER_URL) {
 52 |     // Load the url of the dev server if in development mode
 53 |         await win.loadURL(process.env.WEBPACK_DEV_SERVER_URL as string)
 54 |         // if (!process.env.IS_TEST) win.webContents.openDevTools()
 55 |     } else {
 56 |         createProtocol('gptpi')
 57 |         // Load the index.html when not in development
 58 |         win.loadURL('gptpi://./index.html')
 59 |     }
 60 | }
 61 | 
 62 | if (process.defaultApp) {
 63 |     if (process.argv.length >= 2) {
 64 |         app.setAsDefaultProtocolClient('gptpi', process.execPath, [path.resolve(process.argv[1])])
 65 |     }
 66 | } else {
 67 |     app.setAsDefaultProtocolClient('gptpi')
 68 | }
 69 | 
 70 | // Quit when all windows are closed.
 71 | app.on('window-all-closed', (event) => {
 72 |     // On macOS it is common for applications and their menu bar
 73 |     // to stay active until the user quits explicitly with Cmd + Q
 74 |     if (process.platform !== 'darwin') {
 75 |         app.quit()
 76 |     }
 77 |     // event.preventDefault() // Prevents the default behaviour
 78 | })
 79 | 
 80 | // app.on('before-quit', async (event) => {
 81 | //     event.preventDefault() // Prevents the default quit
 82 | //     const option = {
 83 | //         type: 'question',
 84 | //         buttons: ['Yes', 'No'],
 85 | //         title: 'Confirm',
 86 | //         message: 'Unsaved data will be lost. Are you sure you want to quit?'
 87 | //     }
 88 | 
 89 | //     const response = await dialog.showMessageBox(mainWindow, option)
 90 | //     console.log("before-quit event triggered", { response })
 91 | //     if (response.response == 0) { // If 'Yes' is clicked
 92 | //         mainWindow = null // Dereference the window object
 93 | //         app.quit() // Quit the app
 94 | //     }
 95 | // })
 96 | 
 97 | app.on('activate', () => {
 98 |     // On macOS it's common to re-create a window in the app when the
 99 |     // dock icon is clicked and there are no other windows open.
100 |     if (BrowserWindow.getAllWindows().length === 0) createWindow()
101 | })
102 | 
103 | // This method will be called when Electron has finished
104 | // initialization and is ready to create browser windows.
105 | // Some APIs can only be used after this event occurs.
106 | app.on('ready', async () => {
107 |     if (isDevelopment && !process.env.IS_TEST) {
108 |     // Install Vue Devtools
109 |         try {
110 |             await installExtension(VUEJS3_DEVTOOLS)
111 |         } catch (e) {
112 |             console.error('Vue Devtools failed to install:', e.toString())
113 |         }
114 |     }
115 |     createWindow()
116 | })
117 | 
118 | // Exit cleanly on request from parent process in development mode.
119 | if (isDevelopment) {
120 |     if (process.platform === 'win32') {
121 |         process.on('message', (data) => {
122 |             if (data === 'graceful-exit') {
123 |                 app.quit()
124 |             }
125 |         })
126 |     } else {
127 |         process.on('SIGTERM', () => {
128 |             app.quit()
129 |         })
130 |     }
131 | }
132 | 


--------------------------------------------------------------------------------
/engine/cli_update.ts:
--------------------------------------------------------------------------------
 1 | import { DocumentationGenerator, DocumentationGeneratorOptions } from "."
 2 | import { exclude, getFilesInDirectory } from "../helpers"
 3 | import { existFile, getFileDate, isDirectory, readFileJSON, writeFileJSON } from "../helpers/node_gm"
 4 | import * as path from 'path'
 5 | import { program } from 'commander'
 6 | import { IFile } from "../types"
 7 | 
 8 | program
 9 |     .option('--maxTokens <maxTokens>', 'the maximum number of tokens that the model can accept')
10 |     .option('--bytesPerToken <bytesPerToken>', 'approximate number of bytes in one token')
11 |     .option('--maxQueries <maxQueries>', 'Maximum number of requests simultaneously')
12 |     .option('--outFile <outFile>', 'The file to write the result')
13 |     .option('--config <config>', 'The file to read the config from')
14 |     .option('--maxTokensFile <maxTokensFile>', 'The max tokens values for files')
15 |     .option('--maxTokensDir <maxTokensDir>', 'The max tokens values for directories')
16 |     .option('--bytesPerToken <bytesPerToken>', 'approximate number of bytes in one token')
17 |     .option('--temperature <temperature>', 'The temperature of the model')
18 |     .option('--excludes <excludes>', 'The pattern to exclude files. Example: dir1,dir2,file3,*.png')
19 |     .option('--model <model>', 'The model to use')
20 |     .parse(process.argv)
21 | 
22 | const rootDirOrSelectedFile = process.argv[3]
23 | const apiKey = process.argv[2]
24 | 
25 | async function update(rootDirOrSelectedFile: string) {
26 |     const isDir = isDirectory(rootDirOrSelectedFile)
27 |     const cliOptions = program.opts()
28 |     const configFile = cliOptions?.config || (isDir ? path.resolve(rootDirOrSelectedFile, "docs.ai.config.json") : path.resolve(__dirname, "docs.ai.config.json"))
29 |     const config: DocumentationGeneratorOptions & {outFile?: string, excludes?: string} = existFile(configFile) ? readFileJSON(configFile) : null
30 | 
31 |     const maxQueries = +cliOptions?.maxQueries || config?.maxQueries || 5
32 |     const maxTokens = +cliOptions?.maxTokens || config?.maxTokens || 4097
33 |     const bytesPerToken = +cliOptions?.bytesPerToken || config?.bytesPerToken || 4
34 |     const temperature = +cliOptions?.temperature || config?.temperature
35 |     const model = cliOptions?.model || config?.model
36 |     const maxTokensFile = +cliOptions?.maxTokensFile || config?.maxTokensFile
37 |     const maxTokensDir = +cliOptions?.maxTokensDir || config?.maxTokensDir
38 |     const excludes = cliOptions?.excludes || config?.excludes
39 | 
40 |     const options = {
41 |         maxQueries,
42 |         apiKey,
43 |         cli: true,
44 |         maxTokens,
45 |         bytesPerToken,
46 |         temperature,
47 |         model,
48 |         maxTokensFile,
49 |         maxTokensDir
50 |     } 
51 | 
52 |     let files: IFile[] = isDir ? getFilesInDirectory(rootDirOrSelectedFile, rootDirOrSelectedFile) : readFileJSON(rootDirOrSelectedFile)
53 |     if (excludes) {
54 |         files = exclude(files, excludes, {...options})
55 |     }
56 | 
57 |     // Only files that have not descriptions
58 |     const prevResultFile = cliOptions?.outFile || config?.outFile || (isDir ? path.resolve(rootDirOrSelectedFile, "docs.ai.json") : path.resolve(__dirname, "docs.ai.json"))
59 |     const prevResultDate = +(getFileDate(prevResultFile) || 0)
60 |     const prevResult = existFile(prevResultFile) ? readFileJSON(prevResultFile).filter((prevResultFileOne) => prevResultFileOne.description) : []
61 |     files = files.filter((file) => {
62 |         const prevFile = prevResult.find((prevFile) => prevFile.path === file.path)
63 |         const dateCond = (file.fullPath && !isDirectory(file.fullPath) && +(getFileDate(file?.fullPath) || 0) > (prevResultDate || 0))
64 |         return !prevFile || !prevFile.description || dateCond
65 |     })
66 |     const generator = new DocumentationGenerator(files, options, prevResult)
67 |     await generator.start()
68 |     const resFile = cliOptions?.outFile || config?.outFile || (isDir ? path.resolve(rootDirOrSelectedFile, "docs.ai.json") : path.resolve(__dirname, "docs.ai.json"))
69 |     const resFiles = files.map((selectedFile) => ({ path: selectedFile.path, description: selectedFile.description, size: selectedFile.size }))
70 |     const prevResFiles = prevResult
71 |         .map((prevResultFileOne) => ({ path: prevResultFileOne.path, description: prevResultFileOne.description, size: prevResultFileOne.size }))
72 |         .filter((prevResultFileOne) => !resFiles.find((resFileOne) => resFileOne.path === prevResultFileOne.path))
73 |     const mergedFiles = [...prevResFiles, ...resFiles]
74 |     writeFileJSON(resFile, mergedFiles)
75 |     console.log("Done! The result in the file:", resFile)
76 | }
77 | 
78 | // Wrap your async function in an async IIFE
79 | (async () => {
80 |     try {
81 |         await update(rootDirOrSelectedFile)
82 |     } catch (error) {
83 |         console.error('Error occurred:', error)
84 |         process.exit(1)
85 |     }
86 |     console.log('Async function completed successfully')
87 |     process.exit(0)
88 | })()
89 | 


--------------------------------------------------------------------------------
/helpers/index.ts:
--------------------------------------------------------------------------------
  1 | import * as fs from 'fs'
  2 | import * as path from 'path'
  3 | import { getFileSize } from './node_gm'
  4 | import { IFile } from '../types'
  5 | import { DocumentationGeneratorOptions } from '../engine';
  6 | 
  7 | export interface NestedFile extends IFile {
  8 |     name: string;
  9 |     path: string;
 10 |     children: NestedFile[] | null;
 11 | }
 12 | 
 13 | export function getFilesInDirectory(rootDir, directory, excludes: string[] = ['node_modules', ".git", "dist"]): IFile[] {
 14 |     let files = [] as IFile[]
 15 | 
 16 |     fs.readdirSync(directory).forEach(file => {
 17 |         const absolutePath = path.join(directory, file)
 18 |         if (fs.statSync(absolutePath).isDirectory()) {
 19 |             if (!excludes.includes(file)) {
 20 |                 files = files.concat(getFilesInDirectory(rootDir, absolutePath))
 21 |             }
 22 |         } else {
 23 |             files.push({
 24 |                 path: path.relative(rootDir, absolutePath),
 25 |                 fullPath: path.resolve(absolutePath),
 26 |                 size: getFileSize(absolutePath) || 0,
 27 |                 state: undefined,
 28 |                 description: ''
 29 |              })
 30 |         }
 31 |     })
 32 | 
 33 |     return files
 34 | }
 35 | 
 36 | export function generateNestedFiles(files: IFile[]): NestedFile[] {
 37 |     const root: NestedFile = { path: '', fullPath: '', size: 0, name: '', children: [] }
 38 | 
 39 |     files.forEach(file => {
 40 |         const parts = file.path.split(path.sep)
 41 |         let current = root
 42 | 
 43 |         parts.forEach((part, index) => {
 44 |             const isFile = index === parts.length - 1
 45 | 
 46 |             if (isFile) {
 47 |                 current.children?.push({ ...file, name: part, path: parts.slice(0, index + 1).join(path.sep), children: null })
 48 |             } else {
 49 |                 let dir = current.children?.find(child => child.name === part)
 50 | 
 51 |                 if (!dir) {
 52 |                     dir = { path: '', fullPath: '', size: 0, name: part, children: [] }
 53 |                     current.children?.push(dir)
 54 |                 }
 55 | 
 56 |                 current = dir
 57 |             }
 58 |         })
 59 |     })
 60 | 
 61 |     return root.children || []
 62 | }
 63 | 
 64 | export function getParentFolders(fileList: string[]): string[] {
 65 |     const fileCounts: Record<string, number> = {}
 66 |     const newFileList = [...fileList]
 67 | 
 68 |     for (const filePath of newFileList) {
 69 |         const dirPath = path.dirname(filePath)
 70 |         fileCounts[dirPath] = (fileCounts[dirPath] || 0) + 1
 71 |         if (!newFileList.includes(dirPath)) {
 72 |             newFileList.push(dirPath)
 73 |         }
 74 |     }
 75 | 
 76 |     const parentFolders = Object.keys(fileCounts).filter((dirPath) => {
 77 |         return fileCounts[dirPath] > 1
 78 |     })
 79 |     return [...parentFolders].reverse()
 80 | }
 81 | 
 82 | export function getUpdatedParentFolders(fileList: string[], prevList: string[]): string[] {
 83 |     const fileCounts: Record<string, number> = {}
 84 |     const prevFileCounts: Record<string, number> = {}
 85 | 
 86 |     const newFileList = [...fileList]
 87 |     const newPrevFileList = [...prevList]
 88 | 
 89 |     for (const filePath of newFileList) {
 90 |         const dirPath = path.dirname(filePath)
 91 |         fileCounts[dirPath] = (fileCounts[dirPath] || 0) + 1
 92 |         if (!newFileList.includes(dirPath)) {
 93 |             newFileList.push(dirPath)
 94 |         }
 95 |     }
 96 |     for (const filePath of newPrevFileList) {
 97 |         const dirPath = path.dirname(filePath)
 98 |         prevFileCounts[dirPath] = (prevFileCounts[dirPath] || 0) + 1
 99 |         if (!newPrevFileList.includes(dirPath)) {
100 |             newPrevFileList.push(dirPath)
101 |         }
102 |     }
103 | 
104 |     const parentFolders = Object.keys(fileCounts).filter((dirPath) => {
105 |         return fileCounts[dirPath] + prevFileCounts[dirPath] > 1
106 |     })
107 |     return [...parentFolders].reverse()
108 | }
109 | 
110 | export function exclude (files: IFile[], excludes: string, opts: Partial<DocumentationGeneratorOptions>): IFile[] {
111 |     return files.filter((file) => {
112 |         const excludesCondition = excludes
113 |             .split(",")
114 |             .map((el) => el.trim())
115 |             .every((exclude) => {
116 |                 if (exclude.startsWith("*")) {
117 |                     if (exclude.endsWith("*")) {
118 |                         return !file.path.includes(exclude.slice(1, -1))
119 |                     }
120 |                     return !file.path.endsWith(exclude.slice(1))
121 |                 } else {
122 |                     return !file.path.startsWith(exclude)
123 |                 }
124 |             })
125 |         const maxSizeCondition = ((file.size || 0) <= ((opts?.maxTokens || 4097) - (opts?.maxTokensFile || 150)) * (opts?.bytesPerToken || 4))
126 |         return maxSizeCondition && ((!excludes) || excludesCondition)
127 |     })
128 | }
129 | 
130 | export function lengthToTokensCount(l: number): number {
131 |     return Math.ceil(l / 4)
132 | }
133 | 
134 | export const copyToClipboard = (str: string) => {
135 |     const el = document.createElement("textarea")
136 |     el.value = str
137 |     el.setAttribute("readonly", "")
138 |     el.style.position = "absolute"
139 |     el.style.left = "-9999px"
140 |     document.body.appendChild(el)
141 |     let selected: Range|boolean = false
142 |     const selection = document.getSelection()
143 |     if (selection != null) {
144 |         selected = selection.rangeCount > 0 ? selection.getRangeAt(0) : false
145 |     }
146 |     el.select()
147 |     document.execCommand("copy")
148 |     document.body.removeChild(el)
149 |     if (selected && selection) {
150 |         selection.removeAllRanges()
151 |         selection.addRange(selected)
152 |     }
153 | }
154 | 
155 | export const copy = (content: string) => {
156 |     const { toast } = require("vue3-toastify")
157 |     if (navigator.clipboard) {
158 |         navigator.clipboard.writeText(content || "")
159 |             .then(() => {
160 |                 console.log("Text copied to clipboard")
161 |                 toast("The link copied in to clipboard", { position: "bottom-right", theme: "colored" })
162 |             })
163 |             .catch((error) => {
164 |                 console.error("Error copying text: ", error)
165 |             })
166 |     } else {
167 |         copyToClipboard(content || "")
168 |     }
169 | }
170 | 


--------------------------------------------------------------------------------
/engine/index.ts:
--------------------------------------------------------------------------------
  1 | import { getFileDescription, getFolderDescription, gptAPI } from "./api"
  2 | import * as path from 'path'
  3 | import { isDirectory, readFile, readFileJSON, sleep, writeFileJSON } from "../helpers/node_gm"
  4 | import { IFile } from "../types"
  5 | import { getParentFolders, getUpdatedParentFolders } from "../helpers"
  6 | 
  7 | export interface DocumentationGeneratorOptions {
  8 |     maxQueries?: number
  9 |     maxTokensModel?: number
 10 |     maxTokensAnswer?: number
 11 |     apiKey?: string
 12 |     cli?: boolean
 13 |     maxTokens?: number
 14 |     maxTokensFile?: number
 15 |     maxTokensDir?: number
 16 |     bytesPerToken?: number
 17 |     temperature?: number
 18 |     model?: string
 19 |     timeout?: number
 20 |     language?: string
 21 | }
 22 | export class DocumentationGenerator {
 23 |     private files: IFile[];
 24 |     private prevResult: IFile[];
 25 |     private opts: DocumentationGeneratorOptions;
 26 |     private isStopped: boolean;
 27 | 
 28 |     constructor(files: IFile[], opts?: DocumentationGeneratorOptions, prevResult?: IFile[]) {
 29 |         this.files = files
 30 |         this.opts = opts || {}
 31 |         this.isStopped = false
 32 |         this.prevResult = prevResult || []
 33 |     }
 34 | 
 35 |     public async start(): Promise<IFile[] | undefined> {
 36 |         // Set apiKey if provided
 37 |         if (this.opts.apiKey) {
 38 |             gptAPI.setApiKey(this.opts.apiKey)
 39 |         }
 40 |         if (this.opts.cli) {
 41 |             if (this.prevResult.length) {
 42 |                 const parentFolders = getUpdatedParentFolders(this.files.map((file) => file.path), this.prevResult.map((file) => file.path))
 43 |                 const parentItems = parentFolders
 44 |                     .map(folder => ({ path: folder }))
 45 |                 this.files.push(...parentItems)
 46 |             } else {
 47 |                 const parentFolders = getParentFolders(this.files.map(file => file.path)).filter((pathOne) => this.files.find((file) => file.path === pathOne) === undefined)
 48 |                 this.files.push(...parentFolders.map(folder => ({ path: folder })))
 49 |             }
 50 |         }
 51 | 
 52 |         const queryFn = async (file: IFile) => {
 53 |             try {
 54 |                 if (file.state === 'done' || file.state === 'error' || file.state === 'stopped') {
 55 |                     return
 56 |                 }
 57 |                 file.state = 'pending'
 58 |                 let res = {} as any
 59 |                 if (file.fullPath && !isDirectory(file.fullPath)) {
 60 |                     const fileOpts = { maxTokens: this.opts.maxTokensFile, temperature: this.opts.temperature, model: this.opts.model, ...this.opts }
 61 |                     file.promise = getFileDescription(file, readFile(file.fullPath) || '', fileOpts)
 62 |                     this.opts?.cli && console.log("start: " + file.fullPath)
 63 |                     res = await file.promise
 64 |                 } else {
 65 |                     const children = this.files.filter(res => ((res.path && res.path.startsWith(file.path)) || file.path === ".") && res.path !== file.path && !res.used)
 66 |                     const prevChildren = this.prevResult.filter(res => ((res.path && res.path.startsWith(file.path)) || file.path === ".") && res.path !== file.path && !res.used)
 67 |                     const childrenPromises = children.map((child) => child.promise)
 68 |                     while (children.some((el) => el.state !== 'done' && el.state !== 'error')) {
 69 |                         file.promise = Promise.allSettled(childrenPromises) as any
 70 |                         await file.promise
 71 |                         await sleep(0)
 72 |                     }
 73 |                     const childrenWithDescriptions = [...prevChildren, ...children].filter(res => (res.description || res.state === 'error') && !res.used)
 74 |                     const descriptions = childrenWithDescriptions.map((pathOne) => ({ fileName: pathOne.path, description: (pathOne.description || `Size: ${pathOne.size} bytes`) || '' }))
 75 |                     const dirOpts = { maxTokens: this.opts.maxTokensDir, temperature: this.opts.temperature, model: this.opts.model, ...this.opts }
 76 |                     this.opts?.cli && console.log("start folder: " + file.path)
 77 |                     file.promise = getFolderDescription(file, descriptions, dirOpts)
 78 |                     childrenWithDescriptions.forEach((pathOne) => {
 79 |                         pathOne.used = true
 80 |                     })
 81 |                     res = await file.promise
 82 |                 }
 83 |                 file.description = res?.description
 84 |                 file.prompt = res.prompt
 85 |                 file.state = 'done'
 86 |             } catch (e) {
 87 |                 console.error('catch', file.path, e.message)
 88 |                 file.state = 'error'
 89 |             }
 90 |         }
 91 | 
 92 |         // const beforeEnd = () => {
 93 |         //     const parentFolders = getParentFolders(this.files.map(file => file.path)).filter((pathOne) => this.files.find((file) => file.path === pathOne) === undefined)
 94 |         //     this.files.push(...parentFolders.map(folder => ({ path: folder })))
 95 |         // }
 96 | 
 97 |         await this.semaphore(this.files, queryFn, this.opts.maxQueries || 5)
 98 | 
 99 |         return this.files
100 |     }
101 | 
102 |     public stop(): void {
103 |         this.isStopped = true
104 |     }
105 | 
106 |     private async semaphore(files: IFile[], queryFn: (file: IFile) => Promise<void>, maxSimultaneous: number): Promise<void> {
107 |         const results = new Array(files.length)
108 |         let activeQueries = 0
109 |         let currentIndex = 0
110 | 
111 |         return new Promise((resolve) => {
112 |             const enqueue = async () => {
113 |                 // if (currentIndex === files.length) {
114 |                 //     beforeEnd()
115 |                 // }
116 |                 if (currentIndex === files.length) {
117 |                     if (activeQueries === 0) {
118 |                         resolve()
119 |                     }
120 |                     return
121 |                 }
122 | 
123 |                 if (this.isStopped) {
124 |                     files.forEach((file) => {
125 |                         (!file.state || file.state === 'queued') && (file.state = 'stopped')
126 |                     })
127 |                     resolve()
128 |                     return
129 |                 }
130 | 
131 |                 const index = currentIndex++
132 |                 const query = files[index]
133 |                 activeQueries++
134 | 
135 |                 await queryFn(query)
136 |                 activeQueries--
137 | 
138 |                 enqueue()
139 |             }
140 | 
141 |             for (let i = 0; i < maxSimultaneous; i++) {
142 |                 enqueue()
143 |             }
144 |         })
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/src/components/insight/ResultFiles.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="result-files">
  3 |         <b>Ask for files result:</b>
  4 |         <div class="content text-sm">
  5 |             <template v-for="(segment, i) in segments">
  6 |                 <div :key="i" class="code-block  mb-1" v-if="segment.isCode">
  7 |                     <pre class="overflow-auto max-h-80"><code>{{ segment.text.trim()}}</code></pre>
  8 |                 </div>
  9 |                 <span :key="i + 'text'" v-else>{{ segment.text }}</span>
 10 |             </template>
 11 |         </div>
 12 |         <div class="actions flex-center flex-wrap mt-2">
 13 |             <button
 14 |                 class="action text-sm px-2 py-1 rounded-lg mb-2 mr-2"
 15 |                 v-for="(action, i) in actions"
 16 |                 :key="i"
 17 |                 @click="action.handler">
 18 |                 {{ action.name }}
 19 |             </button>
 20 |         </div>
 21 |     </div>
 22 | </template>
 23 | 
 24 | <script lang='ts'>
 25 |     import { sortByReverse } from '@/../helpers/node_gm'
 26 |     import { defineComponent, PropType } from 'vue'
 27 |     import { indexesOf } from '@/helpers'
 28 |     import { IFile } from 'types'
 29 |     import { lengthToTokensCount } from '@/../helpers'
 30 | 
 31 |     export interface Action{
 32 |         name: string
 33 |         handler: () => void
 34 |     }
 35 | 
 36 |     export interface StringIndexes {
 37 |         string: string
 38 |         indexes: number[]
 39 |     }
 40 | 
 41 |     export default defineComponent({
 42 |         props: {
 43 |             contentStr: {
 44 |                 type: String,
 45 |                 default: () => ''
 46 |             },
 47 |             documentation: {
 48 |                 type: Array as PropType<IFile[]>,
 49 |                 default: () => []
 50 |             },
 51 |             filesStr: {
 52 |                 type: String,
 53 |                 default: () => ''
 54 |             },
 55 |             files: {
 56 |                 type: Array as PropType<string[]>,
 57 |                 default: () => []
 58 |             },
 59 |             content: String,
 60 | 
 61 |         },
 62 |         components: {
 63 | 
 64 |         },
 65 |         data() {
 66 |             return {
 67 | 
 68 |             }
 69 |         },
 70 |         computed: {
 71 |             actions(): Action[] {
 72 |                 const filesLines = this.filesStr.split('\n')
 73 |                 return this.uniqMatchedFiles.map((matchedFile) => {
 74 |                     const fileHasDescription = filesLines.some((fileLine) => {
 75 |                         const fileLineParts = fileLine.split(' ')
 76 |                         const fileLinePath = fileLineParts[0]
 77 |                         return fileLinePath === matchedFile.string && fileLine.includes(' Description: ')
 78 |                     })
 79 |                     const doc = this.documentation.find((docFile) => docFile.path === matchedFile.string)
 80 |                     const description = doc?.description
 81 |                     const descriptionTokens = lengthToTokensCount(description?.length || 0)
 82 |                     const fileHasContent = this.contentStr.includes(matchedFile.string + ':')
 83 |                     return [!fileHasDescription && descriptionTokens && {
 84 |                                 name: `Add ${matchedFile.string} Description (+${descriptionTokens} tokens)`,
 85 |                                 handler: () => {
 86 |                                     this.$emit('updateFilesStr', { field: 'description', file: matchedFile.string })
 87 |                                 }
 88 |                             },
 89 |                             !fileHasContent && doc.size && {
 90 |                                 name: `Add ${matchedFile.string} Content (+${lengthToTokensCount(doc.size)} tokens))`,
 91 |                                 handler: () => {
 92 |                                     this.$emit('addFileContent', matchedFile.string)
 93 |                                 }
 94 |                             }].filter(Boolean) as Action[]
 95 |                 }).flat()
 96 |             },
 97 | 
 98 |             sortedFiles(): string[] {
 99 |                 return sortByReverse(this.files.filter((file) => file !== '.'), (f) => f.length)
100 |             },
101 |             matchedFiles(): StringIndexes[] {
102 |                 const content = this.content // For tests: `I need a description of the file "src\\components\\TheFooter.vue" to determine how "src\\components\\TheFooter.vue to make "engine\\index.ts" the footer sticky. "src\\components"`
103 |                 const res = []
104 |                 this.sortedFiles.forEach((sortedFile) => {
105 |                     const indexes = indexesOf(content.replaceAll('\\', '/'), sortedFile.replaceAll('\\', '/'))
106 |                     if (indexes.length) {
107 |                         res.push({
108 |                             string: sortedFile,
109 |                             indexes
110 |                         })
111 |                     }
112 |                 })
113 |                 return res
114 |             },
115 |             uniqMatchedFiles(): StringIndexes[] {
116 |                 return this.matchedFiles.filter((matchedFile, i) => {
117 |                     const prevMatchedFiles = this.matchedFiles.slice(0, i)
118 |                     const condition = prevMatchedFiles.some(prevEl => {
119 |                         return matchedFile.indexes.every(index => {
120 |                             return prevEl.indexes.some(prevIndex => {
121 |                                 return (prevIndex <= index && index < prevIndex + prevEl.string.length)
122 |                             })
123 |                         })
124 |                     })
125 |                     if (condition) {
126 |                         return false
127 |                     } else {
128 |                         return true
129 |                     }
130 |                 })
131 |             },
132 |             segments(): {isCode?: boolean, text: string}[] {
133 |                 const divider = "`" + "`" + "`"
134 |                 return this.content?.split(divider)?.map((dividerOne, i) => ({ isCode: !!(i % 2), text: dividerOne.trim() })) || []
135 |             },
136 |         },
137 |         methods: {
138 | 
139 |         },
140 |     })
141 | 
142 |     </script>
143 | 
144 | <style lang="scss" scoped>
145 |     .action{
146 |         background: rgb(219, 235, 240);
147 |     }
148 | 
149 |     .button-copy{
150 | 
151 | border-bottom-left-radius: 0.5rem;
152 | border-bottom-right-radius: 0.5rem;
153 | }
154 | 
155 | .result-body{
156 | white-space: pre-wrap;
157 | }
158 | 
159 | .code-block {
160 | display: flex;
161 | flex-direction: column;
162 |     .language {
163 |     font-size: 0.8rem;
164 |     color: #6b7280;
165 |     }
166 |     pre {
167 |     background-color: #202124;
168 |     color: beige;
169 |     border-top-left-radius: 0.5rem;
170 |     border-top-right-radius: 0.5rem;
171 |     padding: 0 1rem;
172 |     overflow-x: auto;
173 |     }
174 |     code {
175 |     font-family: "Fira Code", monospace;
176 |     font-size: 0.9rem;
177 |     line-height: 1.2rem;
178 |     white-space: pre-wrap;
179 |     word-break: break-word;
180 |     }
181 | }
182 | </style>
183 | 


--------------------------------------------------------------------------------
/src/components/Settings.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div>
  3 |         <Accordeon class="settings bg-gray-100 rounded" title="Settings">
  4 |             <InputText
  5 |                 class="mb-2 max-queries"
  6 |                 :value="(config as any)?.maxQueries || (defaultConfig as any).maxQueries"
  7 |                 :placeholder="(defaultConfig as any).maxQueries || 5"
  8 |                 label="Maximum number of requests simultaneously"
  9 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), maxQueries: +val})"  />
 10 |             <InputText
 11 |                 class="mt-2"
 12 |                 label="Model"
 13 |                 :value="(config as any)?.model || (defaultConfig as any).model"
 14 |                 :placeholder="(defaultConfig as any).model || 'gpt-3.5-turbo-0301'"
 15 |                 :suggestions="modelSuggestions"
 16 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), model: val} )" />
 17 |             <InputText
 18 |                 class="mt-2"
 19 |                 label="Max Tokens Model"
 20 |                 :value="(config as any)?.maxTokensModel || (defaultConfig as any).maxTokensModel"
 21 |                 :placeholder="(defaultConfig as any).maxTokensModel || 4097"
 22 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), maxTokensModel: +val} )" />
 23 |             <InputText
 24 |                 class="mt-2"
 25 |                 label="Max Tokens Answer"
 26 |                 :value="(config as any)?.maxTokensAnswer || (defaultConfig as any).maxTokensAnswer"
 27 |                 :placeholder="(defaultConfig as any).maxTokensAnswer || 4097"
 28 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), maxTokensAnswer: +val} )" />
 29 |             <InputText
 30 |                 class="mt-2"
 31 |                 label="Max Tokens File"
 32 |                 :value="(config as any)?.maxTokensFile || (defaultConfig as any).maxTokensFile"
 33 |                 :placeholder="(defaultConfig as any).maxTokensFile || 150"
 34 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), maxTokensFile: +val} )" />
 35 |             <InputText
 36 |                 class="mt-2"
 37 |                 label="Max Tokens Directory"
 38 |                 :value="(config as any)?.maxTokensDir || (defaultConfig as any).maxTokensDir"
 39 |                 :placeholder="(defaultConfig as any).maxTokensDir || 300"
 40 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), maxTokensDir: +val} )" />
 41 |             <InputText
 42 |                 class="mt-2"
 43 |                 label="Temperature"
 44 |                 :value="(config as any)?.temperature || (defaultConfig as any).temperature"
 45 |                 :placeholder="(defaultConfig as any).temperature || 0"
 46 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), temperature: +val} )" />
 47 |             <InputText
 48 |                 class="mt-2"
 49 |                 label="Language"
 50 |                 :value="(config as any)?.language || (defaultConfig as any).language"
 51 |                 :placeholder="(defaultConfig as any).language || 'en'"
 52 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), language: val} )" />
 53 |             <!-- <ToggleSwitch
 54 |                 class="mt-2"
 55 |                 v-model:value="enableAccurateTokenCounting"
 56 |                 :disabled="!isPythonInstalled || isNaN(+couldNotRunScript)"
 57 |                 :label="`Enable accurate token counting`"
 58 |                 @update:value="val => ls('enableAccateTokenCounting', val)" />
 59 |             <Warning value="The system cannot run 'python'. The accurate token counting needs it" class="mt-2" v-if="!isPythonInstalled" />
 60 |             <Warning :value="`The system cannot run 'pyScript/countTokens.py:' ${couldNotRunScript}`" class="mt-2" v-if="isNaN(+couldNotRunScript)" />
 61 |             -->
 62 |             <InputText
 63 |                 class="mt-2"
 64 |                 label="Max Tokens Shift (Increase this value if you get 'Max tokens exceeded' error)"
 65 |                 :value="maxTokensShift + ''"
 66 |                 :placeholder="'100'"
 67 |                 @update:value="val =>  ls('maxTokensShift', +val)" />
 68 |             <InputText
 69 |                 class="mt-2"
 70 |                 label="Documentation Timeout (ms)"
 71 |                 :value="(config as any)?.documentationTimeout || (defaultConfig as any).documentationTimeout"
 72 |                 :placeholder="(defaultConfig as any).documentationTimeout || 30000"
 73 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), documentationTimeout: +val} )" />
 74 |             <InputText
 75 |                 class="mt-2"
 76 |                 label="Insight Timeout (ms)"
 77 |                 :value="(config as any)?.insightTimeout || (defaultConfig as any).insightTimeout"
 78 |                 :placeholder="(defaultConfig as any).insightTimeout || 120000"
 79 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), insightTimeout: +val} )" />
 80 |             <ToggleSwitch
 81 |                 class="mt-2"
 82 |                 :value="(config as any)?.stream || (defaultConfig as any).stream || true"
 83 |                 :label="`Enable streams`"
 84 |                 @update:value="val => $emit('update:value', {...(config || defaultConfig), stream: val})" />
 85 |             <div class="dirs mt-4">
 86 |                 <b class="" >Allowed directories:</b>
 87 |                 <List
 88 |                     :addPlaceholder="'/path/to/dir'"
 89 |                     :items="config?.allowedDirs || (defaultConfig as any)?.allowedDirs || []"
 90 |                 >
 91 |                     <template #default="{item}">
 92 |                         <!-- @add="({name, pos}) => setSettings('dirs', [name, ...(settings?.dirs || defaultSettings?.dirs || [])])"> -->
 93 |                         {{ item  }}
 94 |                     </template>
 95 |                 </List>
 96 |             </div>
 97 |         </Accordeon>
 98 |     </div>
 99 | </template>
100 | 
101 | <script lang='ts'>
102 |     import { DocumentationGeneratorOptions } from 'engine'
103 |     import { defineComponent, PropType } from 'vue'
104 |     import InputText, { InputTextSuggestion } from './misc/InputText.vue'
105 |     import Accordeon from './misc/Accordeon.vue'
106 |     import ToggleSwitch from './misc/ToggleSwitch.vue'
107 |     import ls from 'local-storage'
108 |     import { callPySync, isPythonInstalled } from '@/../helpers/node_gm'
109 |     import Warning from './misc/Warning.vue'
110 |     import * as path from 'path'
111 |     import List from './misc/list/List.vue'
112 |     import { InsightOptions } from 'engine/insight'
113 | 
114 |     export default defineComponent({
115 |         props: {
116 |             models: {
117 |                 type: Array as PropType<string[]>,
118 |                 default: () => []
119 |             },
120 |             config: {
121 |                 type: Object as PropType<DocumentationGeneratorOptions & InsightOptions>,
122 |                 default: () => null
123 |             },
124 |             defaultConfig: Object as PropType<DocumentationGeneratorOptions & InsightOptions>,
125 |         },
126 |         components: {
127 |             List,
128 |             InputText,
129 |             Accordeon,
130 |             ToggleSwitch,
131 |             Warning
132 |         },
133 |         data() {
134 |             return {
135 |                 maxTokensShift: +(ls as any)('maxTokensShift') || 300,
136 |                 couldNotRunScript: '',
137 |                 isPythonInstalled: false,
138 |                 enableAccurateTokenCounting: (ls as any)('enableAccurateTokenCounting') || false,
139 |                 ls
140 | 
141 |             }
142 |         },
143 |         computed: {
144 |             modelSuggestions(): InputTextSuggestion[] {
145 |                 return this.models.map(model => ({ value: model, name: model }))
146 |             },
147 | 
148 |         },
149 |         methods: {
150 | 
151 |         },
152 | 
153 |         created () {
154 |             // const scriptPath = path.resolve('pyScripts', 'countTokens.py')
155 |             // this.isPythonInstalled = isPythonInstalled()
156 |             // this.couldNotRunScript = this.isPythonInstalled && callPySync(scriptPath, 'Sample text to count tokens. Sample text to count tokens.')
157 |             // if (this.isPythonInstalled && !isNaN(+this.couldNotRunScript) && !(ls as any)('enableAccurateTokenCounting') && window.localStorage.getItem('enableAccurateTokenCounting') !== 'false') {
158 |             //     this.enableAccurateTokenCounting = true
159 |             //     ls('enableAccurateTokenCounting', true)
160 |             // }
161 |         },
162 |     })
163 | 
164 |     </script>
165 | 
166 | <style lang="scss" scoped>
167 |     ::v-deep .settings{
168 |         width: 100%;
169 |     }
170 | 
171 | </style>
172 | 


--------------------------------------------------------------------------------
/src/components/insight/Result.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div>
  3 |         <b>Result: </b>
  4 |         <div class="result-header flex-center-between  mt-2">
  5 |             <div></div>
  6 |             <!-- underline toggler "edit result / hide edit" -->
  7 |             <button class="underline text-sm px-2 py-1 rounded-lg" @click="isEditing = !isEditing">
  8 |                 {{ isEditing ? 'Hide Edit' : 'Edit Result' }}
  9 |             </button>
 10 |         </div>
 11 |         <div class="edit-result" v-if="isEditing">
 12 |             <InputTextarea :value="content" @update:value="val => $emit('update:value', val)" />
 13 |         </div>
 14 |         <div class="result text-sm bg-yellow-50 p-2 rounded" ref="resultWrap" v-else>
 15 |             <template v-for="(segment, i) in segments">
 16 |                 <div :key="i" class="code-block mb-1" v-if="segment.isCode">
 17 |                     <pre class="overflow-auto max-h-80"><code v-html="highlightCode(segment.text.trim())"></code></pre>
 18 |                 </div>
 19 |                 <span :key="i + 'text'" v-else v-html="renderLinks(segment.text)"></span>
 20 |             </template>
 21 |         </div>
 22 |         <div class="actions flex-center flex-wrap mt-2">
 23 |             <button
 24 |                 class="action text-sm px-2 py-1 rounded-lg mb-2 mr-2"
 25 |                 v-for="(action, i) in actions"
 26 |                 :key="i"
 27 |                 @click="action.handler">
 28 |                 {{ action.name }}
 29 |             </button>
 30 |         </div>
 31 |         <button
 32 |             class="action text-sm px-2 py-1 rounded-lg mb-2 mr-2"
 33 |             @click="copyResult">
 34 |             Copy Result
 35 |         </button>
 36 |     </div>
 37 | </template>
 38 | 
 39 | <script lang='ts'>
 40 |     import { defineComponent, PropType } from 'vue'
 41 |     import InputTextarea from '../misc/InputTextarea.vue'
 42 |     import { StringIndexes, Action } from './ResultFiles.vue'
 43 |     import { openFile, sortByReverse } from '@/../helpers/node_gm'
 44 |     import { indexesOf } from '@/helpers'
 45 |     import Prism from 'prismjs'
 46 |     import 'prismjs/themes/prism-tomorrow.css'
 47 |     import path from 'path'
 48 |     import { copy } from '@/../helpers'
 49 |     import { IFile } from 'types'
 50 | 
 51 |     export default defineComponent({
 52 |         props: {
 53 |             dir: {
 54 |                 type: String,
 55 |                 default: () => ''
 56 |             },
 57 |             content: String,
 58 |             files: {
 59 |                 type: Array as PropType<IFile[]>,
 60 |                 default: () => []
 61 |             },
 62 |         },
 63 |         components: {
 64 |             InputTextarea
 65 |         },
 66 |         data() {
 67 |             return {
 68 |                 isEditing: false,
 69 | 
 70 |             }
 71 |         },
 72 |         computed: {
 73 |             escapedContent(): string {
 74 |                 return this.content //.replace(/</g, '&lt;').replace(/>/g, '&gt;')
 75 |             },
 76 |             actions(): Action[] {
 77 |                 return this.uniqMatchedFiles.map((matchedFile) => {
 78 |                     return {
 79 |                         name: `Open ${matchedFile.string}`,
 80 |                         handler: () => {
 81 |                             openFile(path.resolve(this.dir, matchedFile.string))
 82 |                         }
 83 |                     }
 84 |                 })
 85 |             },
 86 |             sortedFiles(): IFile[] {
 87 |                 return sortByReverse(this.files.filter((file) => file !== '.'), (f) => f.path.length)
 88 |             },
 89 |             matchedFiles(): StringIndexes[] {
 90 |                 const content = this.escapedContent
 91 |                 const res = []
 92 |                 this.sortedFiles.forEach((sortedFile) => {
 93 |                     const indexes = indexesOf(content, sortedFile.path)
 94 |                     if (indexes.length) {
 95 |                         res.push({
 96 |                             string: sortedFile.path,
 97 |                             indexes
 98 |                         })
 99 |                     }
100 |                 })
101 |                 return res
102 |             },
103 |             uniqMatchedFiles(): StringIndexes[] {
104 |                 return this.matchedFiles.filter((matchedFile, i) => {
105 |                     const prevMatchedFiles = this.matchedFiles.slice(0, i)
106 |                     const condition = prevMatchedFiles.some(prevEl => {
107 |                         return matchedFile.indexes.every(index => {
108 |                             return prevEl.indexes.some(prevIndex => {
109 |                                 return (prevIndex <= index && index < prevIndex + prevEl.string.length)
110 |                             })
111 |                         })
112 |                     })
113 |                     if (condition) {
114 |                         return false
115 |                     } else {
116 |                         return true
117 |                     }
118 |                 })
119 |             },
120 |             segments(): {isCode?: boolean, text: string}[] {
121 |                 const divider = "`" + "`" + "`"
122 |                 return this.escapedContent?.split(divider)?.map((dividerOne, i) => ({ isCode: !!(i % 2), text: dividerOne.trim() })) || []
123 |             },
124 |         },
125 |         methods: {
126 |             copyResult() {
127 |                 copy(this.content)
128 |             },
129 |             // renderLinks(text) {
130 |             //     this.uniqMatchedFiles.forEach((matchedFile) => {
131 |             //         const fileRawPath = matchedFile.string
132 |             //         const filePath = path.resolve(this.dir, fileRawPath)
133 |             //         const link = `<a href="#" class="underline" @click.prevent="openFile('${filePath}')">${fileRawPath}</a>`
134 |             //         const replacers = [
135 |             //             fileRawPath,
136 |             //             fileRawPath.replaceAll('/', '\\'),
137 |             //             fileRawPath.replaceAll('\\', '/')
138 |             //         ]
139 |             //         console.log("After renderLinks function", {replacers});
140 |             //         replacers.forEach((replacer) => {
141 |             //             text = text.replaceAll(replacer, link)
142 |             //         })
143 |             //     })
144 |             //     return text
145 |             // },
146 |             renderLinks(text) {
147 |                 const replacedLinks = new Set() // set to keep track of replaced links
148 |                 this.uniqMatchedFiles.forEach((matchedFile) => {
149 |                     const fileRawPath = matchedFile.string
150 |                     const filePath = path.resolve(this.dir, fileRawPath)
151 |                     const link = `<a href="${filePath}" class="underline">${fileRawPath}</a>`
152 |                     const replacers = [
153 |                         fileRawPath,
154 |                         fileRawPath.replaceAll('/', '\\'),
155 |                         fileRawPath.replaceAll('\\', '/')
156 |                     ]
157 |                     console.log("After renderLinks function", { replacers })
158 |                     replacers.forEach((replacer) => {
159 |                         if (!replacedLinks.has(replacer)) { // check if link has already been replaced
160 |                             text = text.replaceAll(replacer, link)
161 |                             replacedLinks.add(replacer) // add link to set of replaced links
162 |                         }
163 |                     })
164 |                 })
165 |                 setTimeout(() => {
166 |                     this.$refs.resultWrap.querySelectorAll('a').forEach((link) => {
167 |                         link.addEventListener('click', (e) => {
168 |                             e.preventDefault()
169 |                             const filePath = link.getAttribute('href')
170 |                             openFile(filePath)
171 |                         })
172 |                     })
173 |                 }, 0)
174 |                 return text
175 |             },
176 | 
177 |             highlightCode(code): string {
178 |                 return Prism.highlight(code, Prism.languages.javascript, 'javascript').replace(/\w+/, "").trim()
179 |             },
180 |         },
181 |     })
182 | 
183 | </script>
184 | 
185 | <style lang="scss" scoped>
186 |     .result{
187 |         white-space: pre-wrap;
188 |     }
189 |     .action{
190 |         background: rgb(219, 235, 240);
191 |     }
192 |     .button-copy{
193 | 
194 |     border-bottom-left-radius: 0.5rem;
195 |     border-bottom-right-radius: 0.5rem;
196 |     }
197 | 
198 |     .result-body{
199 |     white-space: pre-line;
200 |     }
201 | 
202 |     .code-block {
203 |     display: flex;
204 |     flex-direction: column;
205 |         .language {
206 |         font-size: 0.8rem;
207 |         color: #6b7280;
208 |         }
209 |         pre {
210 |         background-color: #202124;
211 |         color: beige;
212 |         border-radius: 0.5rem;
213 |         border-radius: 0.5rem;
214 |         padding: 0 1rem;
215 |         overflow-x: auto;
216 |         }
217 |         code {
218 |         font-family: "Fira Code", monospace;
219 |         font-size: 0.9rem;
220 |         line-height: 1.2rem;
221 |         white-space: pre-wrap;
222 |         word-break: break-word;
223 |         }
224 |     }
225 | </style>
226 | 


--------------------------------------------------------------------------------
/src/App.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="app">
  3 |         <div class="header"></div>
  4 |         <div class="main flex flex-col items-start px-4 mt-4">
  5 |             <InputApiKey @update:value="updateModels" />
  6 |             <div class="flex items-center mb-4">
  7 |                 <InputText
  8 |                     v-model:value="dir"
  9 |                     placeholder="C:/Projects/sample-app/src"
 10 |                     :error="!dir || !existFile(dir)"
 11 |                     label="Project directory"
 12 |                     @update:value="updateFiles"  />
 13 |                 <button @click="selectFolder" class="btn-select bg-gray-100 mt-6" ><IconFolder/></button>
 14 |                 <button v-if="dir" @click="openFile(dir)" class="p-1 bg-gray-100 mt-6 text-sm ml-2">Open in Explorer</button>
 15 |                 <button v-if="dir" @click="openVSC(dir)" class="p-1 bg-gray-100 mt-6 text-sm ml-2">VSC</button>
 16 |             </div>
 17 |             <Config
 18 |                 :config="config"
 19 |                 :configFile="configFile"
 20 |                 @delConfig="() => (configFile = '', config = null)"
 21 |                 @loadConfig="loadConfig"
 22 |                 @saveConfig="saveConfig"
 23 |                 :configChanged="configChanged" />
 24 |             <Settings
 25 |                 class="mt-2 mb-2 w-1/2"
 26 |                 :defaultConfig="localStorageConfig"
 27 |                 :models="models"
 28 |                 :config="config"
 29 |                 @update:value="val => updateSettings(val)" />
 30 |             <div class="tabs w-full text-lg flex text-center mt-4 mb-4">
 31 |                 <div class="tab w-1/2 cursor-pointer py-2 text-lg" :class="{active: tab === 'docs' || !tab}" @click="() => (tab = '', ls('tab', ''))">Documentation</div>
 32 |                 <div class="tab w-1/2 cursor-pointer py-2 text-lg" :class="{active: tab === 'insight'}" @click="() => (tab = 'insight', ls('tab', 'insight'))">Insight</div>
 33 |             </div>
 34 |             <TabDocs
 35 |                 ref="tabDocs"
 36 |                 v-show="!tab || tab === 'docs' "
 37 |                 :files="files"
 38 |                 :dir="dir"
 39 |                 @updateSettings="val => updateSettings(val)"
 40 |                 :config="currentConfig"
 41 |                 :prevResult="prevResult"
 42 |             />
 43 |             <TabInsight
 44 |                 v-if="tab === 'insight'"
 45 |                 ref="tabInsight"
 46 |                 :documentation="insightDocumentation"
 47 |                 :config="currentConfig"
 48 |                 :dir="dir"
 49 |                 :key="dir"
 50 |             />
 51 |         </div>
 52 |         <TheFooter class="w-full" />
 53 |     </div>
 54 | </template>
 55 | 
 56 | <script lang="ts">
 57 |     import { debounce, size, includes } from 'lodash'
 58 |     import { defineComponent } from 'vue'
 59 |     import InputText from './components/misc/InputText.vue'
 60 |     import ls from 'local-storage'
 61 |     import Files from '@/components/Files.vue'
 62 |     import { IFile } from '@/../types'
 63 |     import { existFile, getFileDate, readFileJSON, run, dirname, total, openFile, writeFileJSON, isPythonInstalled, callPySync } from '@/../helpers/node_gm'
 64 |     import path from 'path'
 65 |     import Result from '@/components/Result.vue'
 66 |     import { exclude, getFilesInDirectory, getParentFolders, getUpdatedParentFolders } from '@/../helpers'
 67 |     import { DocumentationGenerator, DocumentationGeneratorOptions } from '@/../engine'
 68 |     import IconFolder from './components/misc/IconFolder.vue'
 69 |     import { remote, shell } from 'electron'
 70 |     import Settings from '@/components/Settings.vue'
 71 |     import TheFooter from '@/components/TheFooter.vue'
 72 |     import Config from '@/components/Config.vue'
 73 |     import InputApiKey from '@/components/misc/InputApiKey.vue'
 74 |     import TabDocs from '@/components/TabDocs.vue'
 75 |     import TabInsight from '@/components/TabInsight.vue'
 76 |     import SimpleGPT from 'gpt-simple-api-ts'
 77 | 
 78 |     export const resFile = path.resolve(dirname(), "./docs.ai.json")
 79 | 
 80 |     export default defineComponent({
 81 |         name: 'App',
 82 |         components: {
 83 |             TabInsight,
 84 |             TabDocs,
 85 |             InputApiKey,
 86 |             Config,
 87 |             TheFooter,
 88 |             Settings,
 89 |             IconFolder,
 90 |             Result,
 91 |             Files,
 92 |             InputText,
 93 |         },
 94 |         data() {
 95 |             return {
 96 |                 existFile,
 97 |                 tab: (ls as any)("tab") || "",
 98 |                 prevResult: [] as IFile[],
 99 |                 configChanged: false,
100 |                 configFile: "",
101 |                 config: null,
102 |                 localStorageConfig: (ls as any)("localStorageConfig") || {},
103 |                 total,
104 |                 openFile,
105 |                 generator: null as DocumentationGenerator | null,
106 |                 filesArr: [] as IFile[],
107 |                 maxQueries: +ls("maxQueries") as unknown as number || 6,
108 |                 res: null,
109 |                 files: [] as IFile[],
110 |                 dir: ls("dir") as unknown as string || '',
111 |                 ls,
112 |                 api: null,
113 |                 models: [] as string[],
114 |             }
115 |         },
116 |         computed: {
117 |             insightDocumentation(): IFile[] {
118 |                 const res = this.$refs?.tabDocs?.done ? this.$refs?.tabDocs?.mergedFiles : (this.prevResult.length ? this.prevResult : this.files)
119 |                 return [...res, ...this.files.filter((file) => res.map((re) => re.path).includes(file.path) === false)]
120 |             },
121 | 
122 |             currentConfig() {
123 |                 return {
124 |                     ...this.localStorageConfig,
125 |                     ...this.config,
126 |                 }
127 |             },
128 |         },
129 |         methods: {
130 |             async updateModels() {
131 |                 setTimeout(async () => {
132 |                     this.api = new SimpleGPT({ key: (ls as any)("apiKey") || '' })
133 |                     this.models = (await this.api.getModels()) || []
134 |                 }, 0)
135 |             },
136 | 
137 |             openVSC(dir: string) {
138 |                 const { exec } = require('child_process')
139 |                 exec(`code ${dir}`)
140 |             },
141 | 
142 |             saveConfig() {
143 |                 if (!this.config) {
144 |                     const configFile = this.dir + "/docs.ai.config.json"
145 |                     writeFileJSON(configFile, this.localStorageConfig)
146 |                     return
147 |                 }
148 |                 writeFileJSON(this.configFile, this.config)
149 |                 this.configChanged = false
150 |             },
151 | 
152 |             loadConfigRaw(_path: string) {
153 |                 this.configFile = _path
154 |                 this.config = readFileJSON(this.configFile)
155 |                 this.configChanged = false
156 |             },
157 | 
158 |             loadConfig() {
159 |                 const options = {
160 |                     defaultPath: path.resolve(this.dir),
161 |                     filters: [{ name: 'JSON', extensions: ['json'] }]
162 |                 }
163 |                 remote.dialog.showOpenDialog(options).then(result => {
164 |                     if (result.canceled) {
165 |                         return
166 |                     }
167 |                     this.loadConfigRaw(result.filePaths[0])
168 |                     console.log("loadConfig", { resFile })
169 |                 }).catch(err => {
170 |                     console.error(err)
171 |                 })
172 |             },
173 | 
174 |             updateSettings(val: DocumentationGeneratorOptions) {
175 |                 if (this.config) {
176 |                     this.config = { ...this.config, ...val }
177 |                     this.configChanged = true
178 |                 } else {
179 |                     this.localStorageConfig = { ...this.localStorageConfig, ...val }
180 |                     ls('localStorageConfig', val)
181 |                 }
182 |             },
183 | 
184 |             selectFolder() {
185 |                 remote.dialog.showOpenDialog({
186 |                     properties: ['openDirectory'],
187 |                 }).then(result => {
188 |                     if (!result.canceled && result.filePaths.length > 0) {
189 |                         console.log("selectFolder")
190 |                         this.dir = result.filePaths[0]
191 |                         this.updateFilesSync(this.dir)
192 |                         if (this.$refs.tabDocs) {
193 |                             this.$refs.tabDocs.saved = false
194 |                         }
195 |                     }
196 |                 }).catch(err => {
197 |                     console.log(err)
198 |                 })
199 |             },
200 |             updateFilesSync(dir) {
201 |                 ls("dir", dir)
202 |                 if (existFile(dir)) {
203 |                     this.files = getFilesInDirectory(dir, dir)
204 |                 }
205 |                 if (existFile(dir + "/docs.ai.config.json")) {
206 |                     this.loadConfigRaw(dir + "/docs.ai.config.json")
207 |                 }
208 |                 if (existFile(dir + "/docs.ai.json")) {
209 |                     this.prevResult = readFileJSON(dir + "/docs.ai.json").filter((prevResultFileOne) => prevResultFileOne.description)
210 |                 }
211 |             },
212 |             updateFiles: debounce(function(dir) {
213 |                 this.updateFilesSync(dir)
214 |             }, 300),
215 |         },
216 | 
217 |         created () {
218 |             this.api = new SimpleGPT({ key: (ls as any)("apiKey") || '' })
219 |             this.dir && this.updateFilesSync(this.dir)
220 |             this.updateModels()
221 |         },
222 | 
223 |         watch: {
224 | 
225 |         },
226 |     })
227 | </script>
228 | 
229 | <style lang="scss" scoped>
230 |     .tab{
231 |         background-color: rgb(241, 246, 248);
232 |         &.active, &:hover {
233 |             border-bottom: 2px solid #204eb2;
234 |             background-color: rgb(219, 235, 240);
235 |         }
236 |     }
237 |         .btn-select{
238 |         padding: 7px;
239 |     }
240 | 
241 | </style>
242 | 
243 | <style lang="scss">
244 |     .max-queries input{
245 |         max-width: 100px;
246 |     }
247 |     #app {
248 |         font-family: Avenir, Helvetica, Arial, sans-serif;
249 |         color: #2c3e50;
250 |         background: white;
251 |     }
252 |     .flex-center{
253 |         display: flex;
254 |         align-items: center;
255 |     }
256 |     .flex-center-between{
257 |         display: flex;
258 |         align-items: center;
259 |         justify-content: space-between;
260 |     }
261 | </style>
262 | 


--------------------------------------------------------------------------------
/src/components/TabDocs.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="tab-docs w-full">
  3 |         <div class="description text-sm">
  4 |             <div>
  5 |                 Count of requests: {{selectedFiles.length }}
  6 |             </div>
  7 |             <!-- <div v-if="">
  8 |                     Approximate tokens count: {{ cost }}$
  9 |                 </div> -->
 10 |         </div>
 11 |         <div class="flex items-center">
 12 |             <button
 13 |                 title="Generate documentation for all the following files"
 14 |                 class="px-4 py-1 rounded mb-2"
 15 |                 :disabled="isUpdateLoading"
 16 |                 :class="isLoading ? 'bg-red-500 text-white' : 'bg-green-300'"
 17 |                 @click="run(false)">
 18 |                 <b>{{isLoading ? 'Stop' : 'Generate'}}</b>
 19 |             </button>
 20 |             <button
 21 |                 title="Generate documentation for only files that have been changed since the last generation"
 22 |                 v-if="mergedFiles.find((selectedFile) => selectedFile.state !== 'done') && mergedFiles.filter((selectedFile) => selectedFile.state !== 'done').length !== mergedFiles.length"
 23 |                 class="px-4 py-1 ml-2 rounded mb-2"
 24 |                 :disabled="isLoading"
 25 |                 :class="isUpdateLoading? 'bg-red-500 text-white' : 'bg-yellow-300'"
 26 |                 @click="() => run(true)">
 27 |                 <b>{{isUpdateLoading ? 'Stop' : 'Update'}}</b>
 28 |             </button>
 29 |             <button v-if="done" class="px-4 py-1 rounded mb-2 bg-indigo-300 ml-2" @click="save(dir + '/docs.ai.json')" >Save docs.ai.json</button>
 30 |             <button v-if="done" class="px-4 py-1 rounded mb-2 bg-indigo-300 ml-2" @click="saveAs()">Save As...</button>
 31 |             <span v-if="saved" class="text-green-400 ml-2" >Saved!</span>
 32 |         </div>
 33 |         <Files
 34 |             :key="'files_' + filesI"
 35 |             :dir="dir"
 36 |             :files="mergedFiles"
 37 |             ref="files"
 38 |             class="mt-4"
 39 |             @updateExcludes="val => $emit('updateSettings', { excludes: val })"
 40 |             :prevResult="prevResult"
 41 |             :isUpdateLoading="isUpdateLoading"
 42 |             :config="config"/>
 43 |         <!-- <ProjectDescription/> -->
 44 |     </div>
 45 | </template>
 46 | 
 47 | <script lang='ts'>
 48 |     import { defineComponent, PropType } from 'vue'
 49 |     import Files from './Files.vue'
 50 |     import { IFile } from '@/../types'
 51 |     import { DocumentationGenerator, DocumentationGeneratorOptions } from '@/../engine'
 52 |     import { exclude, getParentFolders, getUpdatedParentFolders } from '@/../helpers'
 53 |     import { getFileDate, isDirectory, writeFileJSON } from '@/../helpers/node_gm'
 54 |     import path from 'path'
 55 |     import { remote } from 'electron'
 56 |     import { resFile } from '../App.vue'
 57 |     import ls from 'local-storage'
 58 |     import ProjectDescription from './ProjectDescription.vue'
 59 | 
 60 |     export const maxTokens = 4097
 61 |     export const bytesPerToken = 4
 62 | 
 63 |     export default defineComponent({
 64 |         props: {
 65 |             prevResult: {
 66 |                 type: Array as PropType<IFile[]>,
 67 |                 default: () => []
 68 |             },
 69 |             config: {
 70 |                 type: Object as PropType<DocumentationGeneratorOptions>,
 71 |                 default: () => null
 72 |             },
 73 |             dir: {
 74 |                 type: String,
 75 |                 default: () => ""
 76 |             },
 77 |             files: {
 78 |                 type: Array as PropType<IFile[]>,
 79 |                 default: () => []
 80 |             },
 81 | 
 82 |         },
 83 |         components: {
 84 |             ProjectDescription,
 85 |             Files
 86 |         },
 87 |         data() {
 88 |             return {
 89 |                 filesI: 0,
 90 |                 isUpdateLoading: false,
 91 |                 isLoading: false,
 92 |                 done: false,
 93 |                 saved: false,
 94 | 
 95 |             }
 96 |         },
 97 |         computed: {
 98 |             excludes(): string {
 99 |                 return this.config?.excludes || ''
100 |             },
101 |             // cost(): number {
102 |             //     const tokensFilesSend = total(this.$refs.files?.selectedFiles?.map((selectedFile) => selectedFile.size || 0)) / bytesPerToken
103 |             // },
104 |             excludedFiles(): IFile[] {
105 |                 return exclude(this.files, this.excludes, { maxTokens: this.config.maxTokensModel || maxTokens, bytesPerToken, maxTokensFile: this.config.maxTokensFile })
106 |             },
107 |             prevResultDate(): number {
108 |                 return +(getFileDate(this.dir + "/docs.ai.json") || 0)
109 |             },
110 |             needToUpdateFiles(): IFile[] {
111 |                 return this.excludedFiles.filter(file => {
112 |                     return this.isFileNeedUpdate(file)
113 |                 })
114 |             },
115 |             parentFolders(): string[] {
116 |                 const selectedPaths = this.excludedFiles.map(file => file.path)
117 |                 const parentFolders = getParentFolders(selectedPaths)
118 |                     .filter((pathOne) => !selectedPaths.includes(pathOne))
119 |                 return parentFolders
120 |             },
121 |             updatedParentFolders(): string[] {
122 |                 const undoneFiles = this.needToUpdateFiles.map((file) => file.path)
123 |                 const prevParentFolders = getUpdatedParentFolders(undoneFiles, this.prevResult.map((file) => file.path))
124 |                 return prevParentFolders
125 |             },
126 |             selectedFiles(): IFile[] {
127 |                 const selected: IFile[] = [...this.excludedFiles]
128 |                 if (this.prevResult.length) {
129 |                     selected.push(...this.parentFolders.map(folder => ({ path: folder, fullPath: path.resolve(this.dir, folder) })))
130 |                     console.log("selectedFiles", this.updatedParentFolders)
131 |                 } else {
132 |                     selected.push(...this.parentFolders.map(folder => ({ path: folder, fullPath: path.resolve(this.dir, folder) })))
133 |                 }
134 |                 return selected
135 |             },
136 |             mergedFiles(): IFile[] {
137 |                 if (this.prevResult.length) {
138 |                     if (true) { //! this.done! this.isUpdateLoading && !this.isLoading &&
139 |                         return this.selectedFiles.map((file) => {
140 |                             const prevFile = this.prevResult.find((prevFile) => prevFile.path === file.path)
141 |                             let needToUpdate = this.isFileNeedUpdate(file)
142 |                             if (isDirectory(file.fullPath)) {
143 |                                 needToUpdate = this.updatedParentFolders.includes(file.path)
144 |                             }
145 |                             return {
146 |                                 ...file,
147 |                                 state: needToUpdate ? undefined : "done",
148 |                                 description: (prevFile !== undefined && !needToUpdate) ? prevFile?.description : file.description,
149 |                             }
150 |                         })
151 |                     } else {
152 |                         return this.selectedFiles
153 |                     }
154 |                 } else {
155 |                     return this.selectedFiles
156 |                 }
157 |             }
158 |         },
159 |         methods: {
160 |             isFileNeedUpdate(file: IFile): boolean {
161 |                 const prevFile = this.prevResult.find((prevFile) => prevFile.path === file.path)
162 |                 const dateCond = (file.fullPath && !isDirectory(file.fullPath) && +(getFileDate(file?.fullPath) || 0) > this.prevResultDate)
163 |                 const needToUpdate = !prevFile || !prevFile.description || dateCond
164 |                 return needToUpdate
165 |             },
166 |             saveAs() {
167 |                 const options = {
168 |                     defaultPath: path.resolve(this.dir, "./docs.ai.json"),
169 |                     filters: [{ name: 'JSON', extensions: ['json'] }]
170 |                 }
171 |                 remote.dialog.showSaveDialog(options).then(result => {
172 |                     if (result.canceled) {
173 |                         return
174 |                     }
175 |                     this.save(result.filePath)
176 |                     this.saved = true
177 |                 }).catch(err => {
178 |                     console.error(err)
179 |                 })
180 |             },
181 | 
182 |             save(file: string) {
183 |                 this.saved = false
184 |                 const res = this.mergedFiles.map((selectedFile) => ({ path: selectedFile.path, description: selectedFile.description, size: selectedFile.size }))
185 |                 writeFileJSON(file, res)
186 |                 console.log("save", { resFile })
187 |                 this.saved = true
188 |             },
189 |             setLoading(value: boolean, isUpdate?: boolean) {
190 |                 if (isUpdate) {
191 |                     this.isUpdateLoading = value
192 |                 } else {
193 |                     this.isLoading = value
194 |                 }
195 |             },
196 |             async run(isUpdate?: boolean) {
197 |                 let intervalId: any = null
198 |                 try {
199 |                     if (isUpdate ? this.isUpdateLoading : this.isLoading) {
200 |                         this.generator.stop()
201 |                         this.setLoading(false, isUpdate)
202 |                         this.done = true
203 |                     } else {
204 |                         this.saved = false
205 |                         this.setLoading(true, isUpdate)
206 |                         // this.updateFilesSync(this.dir)
207 |                         const options = {
208 |                             apiKey: (ls as any)("apiKey"),
209 |                             maxQueries: this.maxQueries,
210 |                             ...this.config,
211 |                             timeout: this.config.documentationTimeout,
212 |                         }
213 |                         // this.filesArr = [...this.mergedFiles]
214 |                         const filesArr = [...this.mergedFiles]
215 |                         filesArr.forEach((filesArrOne) => {
216 |                             if (isUpdate) {
217 |                                 if (filesArrOne.state !== 'done') {
218 |                                     delete filesArrOne.description
219 |                                 }
220 |                             } else {
221 |                                 delete filesArrOne.description
222 |                                 filesArrOne.state = undefined
223 |                             }
224 |                         })
225 |                         this.generator = new DocumentationGenerator(filesArr, options)
226 |                         intervalId = setInterval(() => {
227 |                             this.filesI++
228 |                         }, 250)
229 |                         this.res = await this.generator.start()
230 |                         this.setLoading(false, isUpdate)
231 |                         this.done = true
232 |                     }
233 |                 } catch (e) {
234 |                     console.error("catch", { e })
235 |                 } finally {
236 |                     this.setLoading(false, isUpdate)
237 |                     this.filesI++
238 |                     clearInterval(intervalId)
239 |                 }
240 |             },
241 |         },
242 |     })
243 | 
244 |     </script>
245 | 
246 | <style lang="scss" scoped>
247 | 
248 | </style>
249 | 


--------------------------------------------------------------------------------
/docs.ai.json:
--------------------------------------------------------------------------------
1 | [{"path":"engine\\api.ts","description":"The engine\\api.ts file provides functions to generate short descriptions for files and folders using the GPT-Simple-API. It includes methods for getting file descriptions, folder descriptions, and answers to prompts with customizable options such as token limits, temperature, and model selection.","size":2243},{"path":"engine\\cli.ts","description":"The engine\\cli.ts file is a command-line interface script for generating documentation using the DocumentationGenerator class. It provides options for setting maximum tokens, bytes per token, maximum queries, output file, configuration file, and more. The script reads input files or directories and generates documentation based on the provided options.","size":3614},{"path":"engine\\cli_insight.ts","description":"The engine\\cli_insight.ts file is a command-line interface (CLI) script that allows users to run the Insight class with specified options, such as file names and mode, by providing the necessary arguments. The script handles errors and displays the results of the Insight operation.","size":1008},{"path":"engine\\cli_update.ts","description":"The engine\\cli_update.ts file is a script that updates the documentation of a given directory or file using the OpenAI API. It provides various options to configure the documentation generation process, such as maximum tokens, bytes per token, model temperature, and exclusion patterns. The script reads configuration from a JSON file and merges the generated documentation with existing descriptions in an output file.","size":4799},{"path":"engine\\index.ts","description":"The engine\\index.ts file contains the DocumentationGenerator class, which is responsible for generating documentation for a given set of files and folders. It provides options to configure the generation process, such as maximum queries, tokens, and API key. The class also supports stopping the generation process and handles errors during execution.","size":6356},{"path":"engine\\insight.ts","description":"The engine/insight.ts file contains the Insight class, which is responsible for interacting with the GPT API to ask questions and receive answers based on provided documentation. It supports various options such as API key, CLI mode, file names, content strings, and more. The class also includes methods for asking questions about files or content and parsing the results.","size":3162},{"path":"helpers\\index.ts","description":"The helpers\\index.ts file contains utility functions for working with files and directories, such as getting files in a directory, generating nested file structures, and filtering files based on exclusion rules and size limits. It also provides functions to manage parent folders and convert file lengths to token counts.","size":4634},{"path":"package.json","description":"The package.json file contains the configuration and dependency information for the \"recursive-documentation\" project, a Vue.js application with Electron integration. It includes scripts for serving, building, and linting the project, as well as a list of dependencies and development dependencies required for the application to function properly.","size":1689},{"path":"README.md","description":"\"GPT Project Insight\" is an engine for generating recursive documentation and working on projects using ChatGPT. It requires an API Key for the Open AI API and offers features like project setup, running an Electron app, generating documentation using CLI, and customizable configurations. The application also provides examples of prompts and model outputs.","size":2813},{"path":"src\\App.vue","description":"This file defines the main Vue.js component for the application, including the layout, input fields, and tabs for Documentation and Insight. It also handles loading and saving configuration files, updating settings, and managing the application's state.","size":8842},{"path":"src\\background.ts","description":"This file, src\\background.ts, sets up the Electron application's main process, including creating the browser window, handling window events, and registering Vue Devtools in development mode.","size":2774},{"path":"src\\components\\Config.vue","description":"This file defines a Vue component for managing configuration settings in the application. It allows users to load, save, and delete configurations, as well as display the current configuration source. The component also provides visual feedback for changes in the configuration state.","size":1904},{"path":"src\\components\\File.vue","description":"The File.vue component is a Vue.js component that displays a file's path, state, prompt, and description in an accordion format. It allows users to toggle the visibility of the prompt and delete queued files. The component uses the Accordeon.vue component for collapsible content display and emits an event when a file is deleted.","size":2111},{"path":"src\\components\\Files.vue","description":"The Files.vue component is a part of a documentation generator application. It displays a list of files and allows users to exclude specific files or directories from the documentation generation process. Users can also delete items from the list. The component includes InputTextarea, FileTree, and Accordeon subcomponents for better user experience and functionality.","size":2951},{"path":"src\\components\\insight\\ContentInsight.vue","description":"The ContentInsight.vue component is a part of the Insight application that allows users to search, add, and remove content from files. It provides an accordion-style interface with a search bar for filtering files, a list of files with their respective sizes in tokens, and buttons to add or remove content. Users can also toggle between raw text view and the default view. The component uses various helper functions and emits events for updating the content value.","size":4331},{"path":"src\\components\\insight\\FileInsight.vue","description":"\"FileInsight.vue is a Vue component that displays file information, such as file path, size, and description. It allows users to toggle the visibility of the description and add or remove descriptions for each file.\"","size":1749},{"path":"src\\components\\insight\\FilesInsight.vue","description":"The FilesInsight.vue component is a file management tool that allows users to search, view, and edit files in a list or raw text format. It features an accordion-style layout with a search bar, file list, and input textarea for editing. Users can toggle between the list view and raw text view, as well as add or remove descriptions for each file. The component is built using Vue.js and includes various sub-components such as Accordeon, List, InputTextarea, and FileInsight.","size":3233},{"path":"src\\components\\insight\\Result.vue","description":"The Result.vue component displays the result of a search query, including code segments and related actions. It allows users to open matched files directly from the results and supports syntax highlighting for better readability.","size":4893},{"path":"src\\components\\insight\\ResultFiles.vue","description":"The ResultFiles.vue component displays the result of requested files, including file descriptions and content, in a formatted manner. It also provides actions to add file descriptions and content to the result. The component handles the display of code blocks and text segments, as well as sorting and filtering matched files.","size":6504},{"path":"src\\components\\misc\\InputTextarea.vue","description":"This file defines a Vue component for an input textarea with optional label and suggestions. The component allows users to enter text, and it can display filtered suggestions based on the entered text. It also supports keyboard navigation and emits events for updating the value and handling suggestions.","size":2613},{"path":"src\\components\\ProjectDescription.vue","description":"This file defines a Vue component called ProjectDescription, which displays an accordion containing a textarea input for users to enter a project description. The component uses the Accordeon and InputTextarea components and has a responsive design with auto-resizing functionality.","size":955},{"path":"src\\components\\Settings.vue","description":"The Settings.vue component allows users to configure various settings related to the documentation generator, such as maximum number of requests, model, max tokens, temperature, and timeouts. It includes input fields for each setting and uses local storage to save the user's preferences.","size":6359},{"path":"src\\components\\TabDocs.vue","description":"TabDocs.vue is a Vue component that allows users to generate, update, and save documentation for selected files in a project. It displays the count of requests, provides buttons to generate or update documentation, and offers options to save the generated documentation as a JSON file. The component also handles loading states and manages the DocumentationGenerator instance for processing files.","size":10922},{"path":"src\\components\\TabInsight.vue","description":"The TabInsight.vue component is a user interface for interacting with the Insight engine, allowing users to input prompts, toggle options, and display results. Users can ask for files or run the engine with their chosen settings. The component also provides examples, error handling, and token counting to ensure a smooth experience.","size":15115},{"path":"src\\components\\TheFooter.vue","description":"TheFooter.vue is a Vue component that defines the footer section of the application, containing buttons for various actions such as reloading the page, opening external links, clearing cache, and opening developer tools. It also checks if VSCode is installed and provides a button to open it if available.","size":2583},{"path":"src\\helpers\\index.ts","description":"This file contains helper functions for wrapping file names in a string with HTML anchor tags and finding the indexes of a substring within a given string. It also imports necessary modules such as 'child_process', 'fs', and 'path'.","size":573},{"path":"src\\main.ts","description":"The src\\main.ts file initializes a Vue.js application with the imported App component, applies Tailwind CSS styling, and sets up keyboard event listeners for toggling Electron's developer tools and reloading the application.","size":382},{"path":"types\\index.ts","description":"The index.ts file in the types folder defines an IFile interface, which represents a file object with properties such as path, size, description, state, and more. This interface is used to manage and interact with files throughout the application.","size":342},{"path":"src\\components\\insight","description":"Directory name: src\\components\\insight\n\nThe Insight directory contains Vue components for managing and displaying file information, including search, editing, and result display functionalities. It features an accordion-style interface with search bars, file lists, and input textareas for easy navigation and editing. Components include ContentInsight.vue, FileInsight.vue, FilesInsight.vue, Result.vue, and ResultFiles.vue."},{"path":"src\\components","description":"The src\\components directory contains a collection of Vue components for managing various aspects of the application, such as configuration settings, file management, documentation generation, and user interface elements. These components provide functionalities like accordion-style interfaces, search bars, input textareas, and result displays. Key components include Config.vue, File.vue, Files.vue, and several Insight-related components for handling file information and search results."},{"path":"src","description":"Directory name: src\n\nThe src directory contains the core files and components for a Vue.js and Electron-based application. It includes the main Vue.js component (App.vue) for managing layout and state, background.ts for setting up the Electron main process, helper functions in index.ts, and main.ts for initializing the application. Additionally, it houses a collection of Vue components in the src\\components folder to handle various functionalities such as configuration settings, file management, documentation generation, and user interface elements."},{"path":".","description":"Directory name: .\n\nThe \".\" directory contains the core files and components for a Vue.js and Electron-based application called \"GPT Project Insight,\" which generates recursive documentation and insights using the GPT API. It includes engine scripts, command-line interfaces, helper functions, and types for managing files and directories. The src folder houses the main Vue.js component, Electron main process setup, and additional Vue components for handling various functionalities such as configuration settings, file management, documentation generation, and user interface elements."},{"path":"engine","description":"The \"engine\" directory contains scripts and classes for generating documentation and insights using the GPT API. It includes command-line interfaces for documentation generation, updating existing documentation, and running the Insight class with specified options. The core functionality is provided by the DocumentationGenerator and Insight classes, which interact with the GPT API to generate descriptions and answer questions based on provided documentation."}]


--------------------------------------------------------------------------------
/src/components/TabInsight.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |     <div class="tab-insight w-full">
  3 |         <SavedResults :dir="dir" @select="item => loadResultByName(item)"/>
  4 |         <ProjectsList/>
  5 |         <Examples @apply="val => (prompt = val)" />
  6 |         <b>Prompt</b>
  7 |         <InputTextarea v-model:value="prompt" class="w-full" :rows="5"/>
  8 |         <button @click="setToDefault" class="underline text-sm" >Set to default</button>
  9 |         <ToggleSwitch class="mt-2" v-model:value="includeFiles" :label="`Include files (+${lengthToTokensCount(filesStr.length)} tokens)`" />
 10 |         <ToggleSwitch
 11 |             class="mt-2"
 12 |             v-model:value="includeDescription"
 13 |             :label="`Include description (+${descriptionSize} tokens)`"
 14 |             @update:value="val => updateFilesStr('description', val)" />
 15 |         <ToggleSwitch class="mt-2" v-model:value="includeContent" :label="`Include content (+${lengthToTokensCount(contentStr.length)} tokens)`" />
 16 |         <ToggleSwitch class="mt-2" v-model:value="showCycles" :label="`Show cycles`" />
 17 |         <FilesInsight v-model:value="filesStr" v-if="includeFiles" @toggleDescription="({file, value}) => updateFilesStr('description', value, file)"/>
 18 |         <ContentInsight
 19 |             v-model:value="contentStr"
 20 |             v-if="includeContent"
 21 |             :documentation="documentation"
 22 |             :dir="dir"/>
 23 |         <Info :promptSize="promptSize" :maxTokens="maxTokens"  />
 24 |         <!-- :price="price" -->
 25 |         <Warning
 26 |             class="mt-2"
 27 |             :value="'To include descriptions in the prompt, you need to generate documentation.'"
 28 |             v-if="!descriptionSize" />
 29 |         <Cycles :files="files" v-if="showCycles" :config="config"/>
 30 |         <button @click="showRawPrompt = !showRawPrompt" class="underline text-sm"> {{ showRawPrompt ? 'Hide' : 'Show'  }} raw prompt</button>
 31 |         <InputTextarea
 32 |             v-if="showRawPrompt"
 33 |             v-model:value="rawPrompt"
 34 |             class="mt-2 w-full"
 35 |             :rows="10"
 36 |         />
 37 |         <div class="buttons mt-2">
 38 |             <button
 39 |                 class="px-2 py-1 rounded btn-run-files mb-2 mr-2"
 40 |                 :disabled="isFilesLoading || isLoading"
 41 |                 :class="isFilesLoading ? 'opacity-50' : ''"
 42 |                 @click="askInsight('files')">
 43 |                 Ask for files
 44 |                 <!-- {{isFilesLoading ? 'Stop' : 'Ask for files'}} -->
 45 |             </button>
 46 |             <button
 47 |                 class="px-4 py-1 rounded mb-2 mr-2 btn-run"
 48 |                 :disabled="isFilesLoading"
 49 |                 @click="askInsight('content')">
 50 |                 <b>{{isLoading ? 'Stop' : 'Run'}} <span v-show="loadingTime" class="font-normal" >
 51 |                     ({{ loadingTime.toFixed(1) }}s)</span>
 52 |                 </b>
 53 |             </button>
 54 |             <button
 55 |                 v-if="result"
 56 |                 class="px-2 py-1 rounded btn-save-result mb-2 mr-2 bg-blue-400"
 57 |                 :disabled="!result"
 58 |                 @click="saveResult()">
 59 |                 Save Result
 60 |             </button>
 61 |             <button
 62 |                 v-if="!result"
 63 |                 class="px-2 py-1 rounded btn-save-result mb-2 mr-2 bg-blue-400"
 64 |                 @click="loadResultDialog()">
 65 |                 Load Result
 66 |             </button>
 67 |         </div>
 68 |         <Warning
 69 |             class="mt-2"
 70 |             v-if="resultSaved"
 71 |             @click="clearSaveMessageTimeout()">
 72 |             The result saved in the file: <span class="underline cursor-pointer" @click="copy(resultSaved)" >{{resultSaved}}</span>
 73 |         </Warning>
 74 |         <Error :value="error" v-if="error" class="mt-2"  />
 75 |         <Warning
 76 |             class="mt-2"
 77 |             :value="'If you have not enough tokens for the prompt you need to increase \'Max Tokens Shift\' in the settings.'"
 78 |             v-if="notEnoughTokens" />
 79 | 
 80 |         <ResultFiles
 81 |             class="result mt-2"
 82 |             ref="resultFilesRef"
 83 |             :content="resultFiles"
 84 |             v-if="resultFiles"
 85 |             :files="files"
 86 |             :filesStr="filesStr"
 87 |             :documentation="documentation"
 88 |             :contentStr="contentStr"
 89 |             @updateFilesStr="({field, file}) => updateFilesStr(field, true, file)"
 90 |             @addFileContent="file => addFileToContentStr(file)"
 91 |         />
 92 |         <Result
 93 |             ref="resultRef"
 94 |             :content="result"
 95 |             v-if="result"
 96 |             class="mt-2"
 97 |             :files="files"
 98 |             :dir="dir"
 99 |             @update:value="val => updateResult(val)"
100 |         />
101 |     </div>
102 | </template>
103 | 
104 | <script lang='ts'>
105 |     import { ROOT_DIR } from './../helpers'
106 |     import { defineComponent, PropType } from 'vue'
107 | 
108 |     import InputTextarea from './misc/InputTextarea.vue'
109 |     import { Insight } from '@/../engine/insight'
110 |     import ls from 'local-storage'
111 |     import { bytesPerToken, maxTokens } from '@/components/TabDocs.vue'
112 |     import ToggleSwitch from '@/components/misc/ToggleSwitch.vue'
113 |     import Accordeon from './misc/Accordeon.vue'
114 |     import { IFile } from 'types'
115 |     import Error from './misc/Error.vue'
116 |     import Warning from './misc/Warning.vue'
117 |     import { copy, lengthToTokensCount } from '@/../helpers'
118 |     import { DocumentationGeneratorOptions } from 'engine'
119 |     import ResultFiles from '@/components/insight/ResultFiles.vue'
120 |     import { readFile, readFileJSON, writeFileJSON } from '@/../helpers/node_gm'
121 |     import Result from '@/components/insight/Result.vue'
122 |     import FilesInsight from '@/components/insight/FilesInsight.vue'
123 |     import ContentInsight from '@/components/insight/ContentInsight.vue'
124 |     import path from 'path'
125 |     import Examples from './Examples.vue'
126 |     import { remote } from 'electron'
127 |     import SavedResults, { IResult } from '@/components/insight/SavedResults.vue'
128 |     import ProjectsList from './insight/ProjectsList.vue'
129 |     import Cycles from './insight/Cycles.vue'
130 |     import Info from './Info.vue'
131 | 
132 |     export const ENDOFFILE = ' ###ENDOF' + 'FILE###'
133 | 
134 |     export default defineComponent({
135 |         props: {
136 |             dir: {
137 |                 type: String,
138 |                 default: () => ''
139 |             },
140 |             documentation: {
141 |                 type: Array as PropType<IFile[]>,
142 |                 default: () => []
143 |             },
144 |             config: {
145 |                 type: Object as PropType<DocumentationGeneratorOptions>,
146 |                 default: () => null
147 |             },
148 |         },
149 |         components: {
150 |             Info,
151 |             Cycles,
152 |             ProjectsList,
153 |             SavedResults,
154 |             Examples,
155 |             ContentInsight,
156 |             FilesInsight,
157 |             Result,
158 |             ResultFiles,
159 |             ToggleSwitch,
160 |             InputTextarea,
161 |             Accordeon,
162 |             Error,
163 |             Warning
164 |         },
165 |         data() {
166 |             return {
167 |                 copy,
168 |                 showCycles: false,
169 |                 rawPrompt: "",
170 |                 showRawPrompt: false,
171 |                 saveMessageTimeout: null,
172 |                 resultSaved: '',
173 |                 loadingInterval: null,
174 |                 resultFiles: "",
175 |                 error: "",
176 |                 contentStr: "",
177 |                 includeContent: false,
178 |                 includeDescription: false,
179 |                 includeSize: false,
180 |                 filesStr: "",
181 |                 includeFiles: false,
182 |                 result: "",
183 |                 isLoading: false,
184 |                 isFilesLoading: false,
185 |                 prompt: "",
186 |                 insight: null as Insight | null,
187 |                 bytesPerToken,
188 |                 notEnoughTokens: false,
189 |                 lengthToTokensCount,
190 |                 loadingTime: 0,
191 |             }
192 |         },
193 |         computed: {
194 |             maxTokens(): number {
195 |                 return this.config?.maxTokensModel || maxTokens
196 |             },
197 | 
198 |             files(): string[] {
199 |                 return this.documentation
200 |             },
201 | 
202 |             promptSize(): number {
203 |                 // return lengthToTokensCount((this.prompt.length + (this.includeFiles ? this.filesStr.length : 0) + (this.includeContent ? this.contentStr.length : 0))) + this.getTokensShift()
204 |                 return lengthToTokensCount(this.rawPrompt.length) + this.getTokensShift()
205 |             },
206 |             sizeSize(): number {
207 |                 const sizeLength = this.filesStr.split("\n").map(f => {
208 |                     const size = this.documentation.find(d => d.path === f.split(" ")[0])?.size
209 |                     return (size ? " " + size + "bytes" : "")
210 |                 }).join("").length
211 |                 return lengthToTokensCount(sizeLength)
212 |             },
213 |             descriptionSize(): number {
214 |                 const descriptionLength = this.filesStr.split("\n").map(f => {
215 |                     const description = this.documentation.find(d => d.path === f.split(" ")[0])?.description
216 |                     return (description ? " Description: " + description : "")
217 |                 }).join("").length
218 |                 return lengthToTokensCount(descriptionLength)
219 |             },
220 |             combinedWatchers(): string {
221 |                 return this.prompt + this.filesStr + this.contentStr + this.includeFiles + this.includeContent
222 |             },
223 |         },
224 |         methods: {
225 |             updateResult(val: string) {
226 |                 this.result = val
227 |             },
228 | 
229 |             includeFilesContent(files: string[]) {
230 |                 // edit contentStr
231 |                 // '\n' + item.path + ":\n" + readFile(path.resolve(this.dir, item.path)) + '\n' + ENDOFFILE
232 |                 this.contentStr = this.contentStr + files.map(f => '\n' + f + ":\n" + readFile(path.resolve(this.dir, f)) + '\n' + ENDOFFILE).join("")
233 |             },
234 |             updateTokensCount(rawPrompt: string) {
235 | 
236 |             },
237 | 
238 |             loadResultByName(item: IResult) {
239 |                 this.loadResult(path.resolve(ROOT_DIR, 'data', item.name))
240 |             },
241 | 
242 |             updateRawPrompt() {
243 |                 const options = {
244 |                     filesStr: this.includeFiles ? this.filesStr : undefined,
245 |                     contentStr: this.includeContent ? this.contentStr : undefined,
246 |                     ...this.config,
247 |                     timeout: this.config.insightTimeout || 120000,
248 |                 }
249 |                 this.insight = new Insight([], options)
250 |                 this.rawPrompt = this.insight.generatePrompt(this.prompt, options)
251 |             },
252 |             clearSaveMessageTimeout() {
253 |                 clearTimeout(this.saveMessageTimeout)
254 |             },
255 | 
256 |             loadResultDialog() {
257 |                 const file = remote.dialog.showOpenDialogSync({
258 |                     properties: ['openFile'],
259 |                     filters: [
260 |                         { name: 'JSON', extensions: ['json'] },
261 |                     ]
262 |                 })
263 |                 if (file) {
264 |                     this.loadResult(file[0])
265 |                 }
266 |             },
267 | 
268 |             saveResult() {
269 |                 const file = path.resolve(ROOT_DIR, 'data', `result_${+new Date()}.json`)
270 |                 writeFileJSON(file, {
271 |                     dir: this.dir,
272 |                     result: this.result,
273 |                     prompt: this.rawPrompt,
274 |                     filesStr: this.filesStr,
275 |                     contentStr: this.contentStr,
276 |                 } as IResult)
277 |                 this.resultSaved = file
278 |                 this.saveMessageTimeout = setTimeout(() => {
279 |                     this.resultSaved = ''
280 |                 }, 5000)
281 |             },
282 |             loadResult(file) {
283 |                 const data = readFileJSON(file)
284 |                 this.result = data.result
285 |                 setTimeout(() => {
286 |                     this.scrollToResult()
287 |                 }, 0)
288 |             },
289 |             scrollToResult() {
290 |                 if (this.result) {
291 |                     this.$refs.resultRef.$el.scrollIntoView({ behavior: 'smooth' })
292 |                 } else if (this.resultFiles) {
293 |                     this.$refs.resultFilesRef.$el.scrollIntoView({ behavior: 'smooth' })
294 |                 }
295 |             },
296 |             setToDefault() {
297 |                 this.includeContent = false
298 |                 this.includeDescription = false
299 |                 this.includeSize = false
300 |                 this.includeFiles = true
301 |                 this.contentStr = ""
302 |                 this.filesStr = this.files.map((file) => file.path).join("\n")
303 |                 this.prompt = ""
304 |                 this.result = ""
305 |                 this.resultFiles = ""
306 |                 this.error = ""
307 |             },
308 | 
309 |             addFileToContentStr(file) {
310 |                 if (!this.includeContent) {
311 |                     this.includeContent = true
312 |                 }
313 |                 this.contentStr += `\n${file}:\n`
314 |                 this.contentStr += readFile(path.resolve(this.dir, file)) + '\n' + ENDOFFILE
315 |             },
316 |             getTokensShift(): number {
317 |                 return +(ls as any)('maxTokensShift') || 300
318 |             },
319 |             updateFilesStr(field: string, value: boolean, file?: string) {
320 |                 if (field === 'size') {
321 |                     if (value) {
322 |                         this.filesStr = this.filesStr.split("\n").map(f => {
323 |                             const size = this.documentation.find(d => d.path === f.split(" ")[0])?.size
324 |                             return f + (size ? " " + size + "bytes" : "")
325 |                         }).join("\n")
326 |                     } else {
327 |                         this.filesStr = this.filesStr.split("\n").map(f => {
328 |                             return f.replace(/\s\d+bytes/, "")
329 |                         }).join("\n")
330 |                     }
331 |                 } else {
332 |                     if (value) {
333 |                         this.filesStr = this.filesStr.split("\n").map(f => {
334 |                             const filePath = f.split(" ")[0]
335 |                             const description = this.documentation.find(d => d.path === filePath)?.description
336 |                             return f + (description && (file ? filePath === file : true) ? " Description: " + description : "")
337 |                         }).join("\n")
338 |                     } else {
339 |                         this.filesStr = this.filesStr.split("\n").map(f => {
340 |                             const filePath = f.split(" ")[0]
341 |                             return (file ? filePath === file : true) ? f.replace(/\sDescription:\s.+/, "") : f
342 |                         }).join("\n")
343 |                     }
344 |                 }
345 |             },
346 |             async askInsight(type) {
347 |                 if (!this.isLoading) {
348 |                     try {
349 |                         if (type === 'files') {
350 |                             this.isFilesLoading = true
351 |                         } else {
352 |                             this.isLoading = true
353 |                             this.loadingTime = 0
354 |                             this.loadingInterval = setInterval(() => {
355 |                                 this.loadingTime += 0.1
356 |                             }, 100)
357 |                         }
358 |                         if (this.config.stream !== false) {
359 |                             this.result = ''
360 |                             this.resultFiles = ''
361 |                         }
362 |                         this.error = ''
363 |                         this.notEnoughTokens = false
364 | 
365 |                         const options = {
366 |                             apiKey: (ls as any)("apiKey"),
367 |                             ...this.config,
368 |                             timeout: this.config.insightTimeout,
369 |                             browser: true,
370 |                         }
371 |                         this.insight = new Insight([], options)
372 |                         const maxTokensShift = this.getTokensShift()
373 |                         let scrolled = false
374 | 
375 |                         if (type === 'files') {
376 |                             this.resultFiles = await this.insight.askFiles(this.prompt, { filesStr: this.filesStr, maxTokensShift, ...this.config, timeout: this.config.insightTimeout || 120000, })
377 |                         } else {
378 |                             const askOptions = {
379 |                                 browser: true,
380 |                                 filesStr: this.includeFiles ? this.filesStr : undefined,
381 |                                 contentStr: this.includeContent ? this.contentStr : undefined,
382 |                                 maxTokensShift,
383 |                                 ...this.config,
384 |                                 timeout: this.config.insightTimeout || 120000,
385 |                                 rawPrompt: this.rawPrompt,
386 |                                 fData: (delta) => {
387 |                                     this.result += delta
388 |                                     this.config.stream !== false && !scrolled && setTimeout(() => {
389 |                                         this.scrollToResult()
390 |                                         scrolled = true
391 |                                     }, 0)
392 |                                 }
393 |                             }
394 |                             const res = await this.insight.ask(this.prompt, askOptions)
395 |                             console.log("AFTER insight.ask", { res });
396 |                             (this.config.stream === false) && (this.result = '')
397 |                         }
398 | 
399 |                         setTimeout(() => {
400 |                             this.scrollToResult()
401 |                         }, 0)
402 |                     } catch (e) {
403 |                         console.error("catch askInsight", { e })
404 | 
405 |                         // Error handling code ...
406 |                     } finally {
407 |                         if (type === 'files') {
408 |                             this.isFilesLoading = false
409 |                         } else {
410 |                             clearInterval(this.loadingInterval)
411 |                             this.isLoading = false
412 |                         }
413 |                     }
414 |                 } else {
415 |                     this.insight.abort()
416 |                     this.isLoading = false
417 |                 }
418 |             },
419 | 
420 |         },
421 | 
422 |         created () {
423 |             this.filesStr = this.files.map((file) => file.path).join("\n")
424 |             console.log("After saveResult() in methods", { ROOT_DIR })
425 |         },
426 | 
427 |         watch: {
428 |             combinedWatchers: {
429 |                 handler (newVal) {
430 |                     setTimeout(() => {
431 |                         this.updateRawPrompt()
432 |                     }, 0)
433 |                 }
434 |             },
435 |         },
436 |     })
437 | 
438 |     </script>
439 | 
440 | <style lang="scss" scoped>
441 |     .btn-run-files{
442 |         background: #92d2c9;
443 |     }
444 | 
445 |     .btn-run{
446 |         background: #20b29e;
447 |         color: whitesmoke;
448 |     }
449 | 
450 |     .result{
451 |         white-space: pre-line;
452 |     }
453 | 
454 | </style>
455 | 


--------------------------------------------------------------------------------
/helpers/node_gm.ts:
--------------------------------------------------------------------------------
  1 | import * as _ from 'lodash'
  2 | import * as fs from 'fs'
  3 | import * as readline from 'readline'
  4 | import * as path from 'path'
  5 | import * as mkdirp from 'mkdirp'
  6 | import { exec, spawn, spawnSync } from 'child_process'
  7 | 
  8 | const { uniq, sortBy } = _
  9 | //* as fs
 10 | 
 11 | /* Consts */
 12 | 
 13 | /* General */
 14 | /* Arrays */
 15 | export function objectEach(obj: { [key: string]: unknown }, f: (el: unknown) => unknown) {
 16 |     for (const key in obj) {
 17 |         if (Object.prototype.hasOwnProperty.call(obj, key)) {
 18 |             obj[key] = f(obj[key])
 19 |         }
 20 |     }
 21 | }
 22 | 
 23 | export function objectMap(obj: { [key: string]: any }, f: (el: any, key: string) => any, level?: number) {
 24 |     if (level && level > 1) {
 25 |         const newObj = { ...obj }
 26 |         for (const key in obj) {
 27 |             if (Object.prototype.hasOwnProperty.call(obj, key)) {
 28 |                 newObj[key] = objectMap(obj[key], f, level - 1)
 29 |             }
 30 |         }
 31 |         return newObj
 32 |     } else {
 33 |         const newObj = { ...obj }
 34 |         for (const key in obj) {
 35 |             if (Object.prototype.hasOwnProperty.call(obj, key)) {
 36 |                 newObj[key] = f(obj[key], key)
 37 |             }
 38 |         }
 39 |         return newObj
 40 |     }
 41 | }
 42 | 
 43 | export function transpose<T>(matrix: T[][]): T[][] {
 44 |     return matrix[0].map((x, i) => matrix.map(x => x[i]))
 45 | }
 46 | 
 47 | export function last(arr: any[]) {
 48 |     return arr[arr.length - 1]
 49 | }
 50 | 
 51 | export function shrinkRight<T>(matrix: T[][]): T[][] {
 52 |     const len = Math.min(...matrix.map(el => el.length))
 53 |     return matrix.map(el => el.slice(0, len))
 54 | }
 55 | 
 56 | export function shrinkLeft<T>(matrix: T[][]): T[][] {
 57 |     const len = Math.min(...matrix.map(el => el.length))
 58 |     return matrix.map(el => el.slice(el.length - len))
 59 | }
 60 | 
 61 | export interface TallySortByItem<T, R> {
 62 |     baseValues: T[]
 63 |     value: R;
 64 |     count: number;
 65 | }
 66 | 
 67 | export interface TallySortItem {
 68 |     value: any;
 69 |     count: number;
 70 | }
 71 | export interface TallySortRelativeItem {
 72 |     value: any;
 73 |     percent: number;
 74 | }
 75 | 
 76 | export function tallySort<T>(arr: T[], f?: (el: T) => any, fInv?: (el: any) => any): TallySortItem[] {
 77 |     return Object.entries(_.countBy(arr, f))
 78 |         .map(el => { return { value: fInv ? fInv(el[0]) : el[0], count: el[1] as number } })
 79 |         .sort((a, b) => +b.count - +a.count)
 80 | }
 81 | 
 82 | export const tallySortJSON = (arr: any[]) => tallySort(arr, JSON.stringify, JSON.parse)
 83 | 
 84 | 
 85 | export function tallySortRelative(ts: TallySortItem[], totalValue?: number): TallySortRelativeItem[] {
 86 |     const _total = totalValue || total(ts, 'count')
 87 |     return ts.map(({ value, count }) => ({ value, percent: count / _total }))
 88 | }
 89 | 
 90 | export const total = function (arr: (any[]), key?: string): number {
 91 |     let _arr = arr
 92 |     if (key) {
 93 |         _arr = (arr as any[]).map((el) => el[key])
 94 |     }
 95 |     return _arr.reduce((a, b) => a + b, 0)
 96 | }
 97 | 
 98 | export const splitBy = function(arr: any[], f: (el: any, local: any[]) => boolean, g?: (local: any[]) => any) {
 99 |     const res = [] as any[]
100 |     let local: any[] = []
101 |     g = g || ((el) => el)
102 |     arr.forEach(el => {
103 |         // @ts-ignore
104 |         local.push(el)
105 |         if (f(el, local)) {
106 |             res.push(g && g(local))
107 |             local = []
108 |         }
109 |     })
110 |     if (local.length) {
111 |         res.push(g(local))
112 |     }
113 |     return res
114 | }
115 | 
116 | export const split = function(arr: any[], f: (el: any, local: any[]) => any, g?: (local: any[]) => any) {
117 |     const res = [] as any
118 |     let local: any[] = []
119 |     g = g || ((el) => el)
120 |     let testValue: any = null
121 |     arr.forEach((el, i) => {
122 |         if (i && testValue !== f(el, local)) {
123 |             res.push(g ? g(local) : local)
124 |             local = []
125 |         }
126 |         local.push(el)
127 |         testValue = f(el, local)
128 |     })
129 |     if (local.length) {
130 |         res.push(g(local))
131 |     }
132 |     return res
133 | }
134 | 
135 | export function sortSplit<T, R>(arr: T[], f:(el: T) => R): T[][] {
136 |     return split(sortBy(arr, f), f)
137 | }
138 | 
139 | // export const sortSplit = (arr: any[], f: (el: any, local: any[]) => any, g?: (local: any[]) => any) => split(sortBy(arr, f), f, g)
140 | export const sortSplitReverse = (arr: any[], f: (el: any, local: any[]) => any, g?: (local: any[]) => any) => split(sortByReverse(arr, f as any), f, g)
141 | 
142 | export const accamulateByKey = function(arr: any[], key: string) {
143 |     const res: any[] = []
144 |     arr.forEach(o => {
145 |         res.push({ date: o.date, [key]: last(res) ? last(res)[key] + o[key] : o[key] })
146 |     })
147 |     return res
148 | }
149 | 
150 | export const partition = function (arr: any[], n: number) {
151 |     let i = 0
152 |     const res = [] as any[]
153 |     let locale = [] as any[]
154 |     for (const el of arr) {
155 |         locale.push(el)
156 |         i++
157 |         if (!(i % n)) {
158 |             res.push(locale)
159 |             locale = []
160 |         }
161 |     }
162 |     locale.length && res.push(locale)
163 |     return res
164 | }
165 | 
166 | export const partitionShift = function (arr: any[], n: number, shift = 1) {
167 |     // now works only for shift == 1
168 |     const res = [] as any[]
169 |     let locale = [] as any[]
170 |     for (let i = 0; i < arr.length; i++) {
171 |         const el = arr[i]
172 |         locale.push(el)
173 |         if (!((i + 1) % (n + res.length))) {
174 |             res.push(locale)
175 |             locale = []
176 |             i = i - n + shift
177 |         }
178 |     }
179 |     locale.length && res.push(locale)
180 |     return res
181 | }
182 | 
183 | export function sortByReverse<T>(arr: T[], f: ((el: T) => any) | string): T[] {
184 |     return sortBy(arr, f).reverse()
185 | }
186 | 
187 | export function permutations(collection: any[], n: number) {
188 |     const array = _.values(collection)
189 |     if (array.length < n) {
190 |         return []
191 |     }
192 |     const recur = (array: any[], n: number) => {
193 |         if (--n < 0) {
194 |             return [[]]
195 |         }
196 |         const p: any[] = []
197 |         array.forEach((value, index, array) => {
198 |             array = array.slice()
199 |             array.splice(index, 1)
200 |             recur(array, n).forEach(permutation => {
201 |                 permutation.unshift(value)
202 |                 p.push(permutation)
203 |             })
204 |         })
205 |         return p
206 |     }
207 |     return recur(array, n)
208 | }
209 | /* Objects */
210 | /* String */
211 | export function toJSON(obj: {[key: string]: any}) {
212 |     return JSON.stringify(obj)
213 | }
214 | 
215 | export function fromJSON(json: string) {
216 |     return JSON.parse(json)
217 | }
218 | export function toCamelCase(str: string) {
219 |     return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
220 |         if (+match === 0) return '' // or if (/\s+/.test(match)) for white spaces
221 |         return index === 0 ? match.toLowerCase() : match.toUpperCase()
222 |     })
223 | }
224 | 
225 | export function pascalCase(str: string): string {
226 |     return _.upperFirst(_.camelCase(str))
227 | }
228 | 
229 | export function JSONKeysToCamel(o: any) {
230 |     let newO: any, origKey, newKey: string, value
231 |     if (o instanceof Array) {
232 |         return o.map(function(value) {
233 |             if (typeof value === 'object') {
234 |                 value = JSONKeysToCamel(value)
235 |             }
236 |             return value
237 |         })
238 |     } else {
239 |         newO = {}
240 |         for (origKey in o) {
241 |             if (o.hasOwnProperty(origKey)) {
242 |                 newKey = (origKey.charAt(0).toLowerCase() + origKey.slice(1) || origKey).toString()
243 |                 value = o[origKey]
244 |                 if (value instanceof Array || (value !== null && value.constructor === Object)) {
245 |                     value = JSONKeysToCamel(value)
246 |                 }
247 |                 newO[newKey] = value
248 |             }
249 |         }
250 |     }
251 |     return newO
252 | }
253 | 
254 | export const JSONtoURL = (data: any) => data && Object.keys(data).filter(k => data[k] !== undefined).map(function(k) {
255 |     return encodeURIComponent(k) + '=' + encodeURIComponent(data[k])
256 | }).join('&')
257 | 
258 | export function localeCompare(str1: string, str2: string) {
259 |     return (str1.toLocaleLowerCase && str1.toLocaleLowerCase()) === (str2.toLocaleLowerCase && str2.toLocaleLowerCase())
260 | }
261 | 
262 | export function localeIncludes(str1: string, str2: string) {
263 |     return (str1.toLocaleLowerCase && str1.toLocaleLowerCase()).includes(str2.toLocaleLowerCase && str2.toLocaleLowerCase())
264 | }
265 | 
266 | export function localeIncludesOr(str1: string, str2: string[]) {
267 |     return str2.some((el) => localeIncludes(str1, el))
268 | }
269 | 
270 | export function localeStart(str1: string, str2: string) {
271 |     return !(str1.toLocaleLowerCase && str1.toLocaleLowerCase()).indexOf(str2.toLocaleLowerCase && str2.toLocaleLowerCase())
272 | }
273 | 
274 | export function fileIncludes(str: string, strFile: string) {
275 |     const strLocale = str.toLocaleLowerCase && str.toLocaleLowerCase()
276 |     const strFileLocale = strFile.toLocaleLowerCase && strFile.toLocaleLowerCase()
277 |     return strLocale.includes(strFileLocale) || (!!strFile.split('.')[0] && strLocale.includes(strFile.split('.')[0]))
278 | }
279 | 
280 | export function pathCompare(path1: string, path2: string): boolean {
281 |     path1 = path.resolve(path1)
282 |     path2 = path.resolve(path2)
283 |     if (process.platform == "win32") { return path1.toLowerCase() === path2.toLowerCase() }
284 |     return path1 === path2
285 | }
286 | 
287 | /* DataStructures */
288 | export function multimap(arr: {[key: string]: any}[]) {
289 |     const res = {} as {[key: string]: any[]}
290 |     arr.forEach(obj =>
291 |         Object.keys(obj).forEach(key => {
292 |             if (!res[key]) {
293 |                 res[key] = [obj[key]]
294 |             } else {
295 |                 res[key].push(obj[key])
296 |             }
297 |         }))
298 |     return res
299 | }
300 | 
301 | export function multimapF(arr: {[key: string]: any}[], f: (els: any[]) => any) {
302 |     const mm = multimap(arr)
303 |     Object.keys(mm).forEach(key => {
304 |         mm[key] = f(mm[key])
305 |     })
306 |     return mm
307 | }
308 | 
309 | export function multimapUniq(arr: {[key: string]: any}[]) {
310 |     const mm = multimap(arr)
311 |     Object.keys(mm).forEach(key => {
312 |         mm[key] = uniq(mm[key])
313 |     })
314 |     return mm
315 | }
316 | 
317 | export function multimapTallySort(arr: {[key: string]: any}[]) {
318 |     const mm = multimap(arr)
319 |     Object.keys(mm).forEach(key => {
320 |         mm[key] = tallySort(mm[key])
321 |     })
322 |     return mm
323 | }
324 | 
325 | /* Similarity */
326 | export function includesSimilarity(arrA: any[], arrB: any[]): number {
327 |     let score = 0
328 |     const longer = arrA.length > arrB.length ? arrA : arrB
329 |     const shorter = arrA.length > arrB.length ? arrB : arrA
330 |     longer.forEach(el => {
331 |         shorter.includes(el) && score++
332 |     })
333 |     return longer.length ? (score / longer.length) : 0
334 | }
335 | 
336 | export function includesSimilarityByCurrentLength(currentArr: any[], testArr: any[]): number {
337 |     let score = 0
338 |     currentArr.forEach(el => {
339 |         testArr.includes(el) && score++
340 |     })
341 |     return currentArr.length ? (score / currentArr.length) : 0
342 | }
343 | 
344 | // includesCountSimilarity
345 | // positionSimilarity
346 | // orderSimilarity
347 | 
348 | // async
349 | 
350 | export async function awaitFor<T>(items: T[], f: (el: T, i: number) => void) {
351 |     let i = 0
352 |     for (const el of items) {
353 |         await f(el, i)
354 |         i++
355 |     }
356 | }
357 | 
358 | export async function awaitMap<T, R>(items: T[], f: (el: T, i: number) => R): Promise<R[]> {
359 |     let i = 0
360 |     const res = [] as any[]
361 |     for (const el of items) {
362 |         const _res = await f(el, i)
363 |         res.push(_res)
364 |         i++
365 |     }
366 |     return res
367 | }
368 | 
369 | /* Files */
370 | export function searchRegExp(base: string, re: RegExp | string | ((el: string) => boolean), files: string[] | null, result: string[], node_modules = false, maxDepth = 2, depth = 0, ignores: string[] = [], includeDirs?: boolean, condition?: (file: string) => boolean) {
371 |     try {
372 |         if (depth > maxDepth) return result
373 |         files = files || fs.readdirSync(base)
374 |         result = result || []
375 | 
376 |         files.forEach(
377 |             function (file: string) {
378 |                 try {
379 |                     const newbase = path.join(base, file)
380 |                     if (fs.statSync(newbase).isDirectory() && (node_modules || file !== 'node_modules') && !(ignores.includes(file)) && (condition ? condition(newbase) : true)) {
381 |                         result = searchRegExp(newbase, re, fs.readdirSync(newbase), result, node_modules, maxDepth, depth + 1, ignores, includeDirs, condition)
382 |                         if (includeDirs && ((re instanceof RegExp) || typeof re === 'string' ? file.match(re) : re(newbase))) {
383 |                             result.push(path.resolve(newbase))
384 |                         }
385 |                     } else {
386 |                         if (((re instanceof RegExp) || typeof re === 'string' ? file.match(re) : re(newbase)) && (condition ? condition(newbase) : true)) {
387 |                             result.push(path.resolve(newbase))
388 |                         }
389 |                     }
390 |                 } catch (ee) {
391 |                     console.error(`Error searchRegExp cycle ${file}:` + ee)
392 |                 }
393 |             }
394 |         )
395 |         return result
396 |     } catch (e) {
397 |         console.error('Error searchRegExp:' + e)
398 |         return result
399 |     }
400 | }
401 | 
402 | export const searchR = searchRegExp
403 | 
404 | export const filesR = (dir: string, eq: RegExp | string | ((el: string) => boolean), { ignores, maxDepth, node_modules }: {ignores: string[]; maxDepth: number; node_modules?: boolean}) => searchRegExp(dir, eq, null, [], ((node_modules !== undefined) ? node_modules : true), maxDepth, 0, ignores || ['node_modules', '.git'])
405 | 
406 | export const filesAll = (dir: string, { ignores, maxDepth, node_modules }: {ignores: string[]; maxDepth: number; node_modules: boolean}) => filesR(dir, () => true, { ignores, maxDepth, node_modules })
407 | 
408 | export function getLatestFiles(dir: string, date: Date, node_modules = false, maxDepth = 3) {
409 |     return searchR(dir, file => +new Date(getFileDate(file) as any) > +date, null, [], node_modules, maxDepth)
410 | }
411 | // REPLACE path to filename cuz path it is node module
412 | export function readFile(filePath: string) {
413 |     if (!fs.existsSync(filePath)) return
414 |     return fs.readFileSync(filePath).toString()
415 | }
416 | 
417 | export function readFileJSON(filePath: string) {
418 |     if (!fs.existsSync(filePath)) return
419 |     return JSON.parse(fs.readFileSync(filePath).toString())
420 | }
421 | 
422 | export function readFileJSONLines(filename: string): any[] | undefined {
423 |     if (!fs.existsSync(filename)) return
424 |     return fs.readFileSync(filename).toString().split('\n').filter(Boolean).map((el) => JSON.parse(el))
425 | }
426 | 
427 | export function writeFile(filename: string, data: string) {
428 |     return fs.writeFileSync(filename, data)
429 | }
430 | 
431 | export function writeFileJSON(filename: string, obj: any) {
432 |     return fs.writeFileSync(filename, toJSON(obj))
433 | }
434 | 
435 | export function appendFile(filename: string, data: string) {
436 |     return fs.appendFileSync(filename, data)
437 | }
438 | 
439 | export function appendFileJSON(filename: string, obj: any) {
440 |     return fs.appendFileSync(filename, '\n' + toJSON(obj))
441 | }
442 | 
443 | export function updateFile(filePath: string, f: (text: string | undefined) => string): string {
444 |     const text = readFile(filePath)
445 |     const res = f(text)
446 |     writeFile(filePath, res)
447 |     return res
448 | }
449 | 
450 | export function updateFileJSON(filePath: string, f: (data: any) => any): any {
451 |     const data = readFileJSON(filePath)
452 |     const res = f(data)
453 |     writeFileJSON(filePath, res)
454 |     return res
455 | }
456 | 
457 | async function getFirstLine(pathToFile: string) {
458 |     const readable = fs.createReadStream(pathToFile)
459 |     const reader = readline.createInterface({ input: readable })
460 |     const line = await new Promise((resolve) => {
461 |         reader.on('line', (line) => {
462 |             reader.close()
463 |             resolve(line)
464 |         })
465 |     })
466 |     readable.close()
467 |     return line
468 | }
469 | 
470 | export async function readFirstChar(filePath: string) {
471 |     const buffer = Buffer.alloc(1) // создаем буфер размером 1 байт
472 |     const fd = await fs.promises.open(filePath, 'r') // открываем файл для чтения
473 |     try {
474 |         await fd.read(buffer, 0, 1, 0) // читаем первый байт из файла
475 |     } finally {
476 |         await fd.close() // закрываем файл
477 |     }
478 |     return buffer.toString() // преобразуем буфер в строку и возвращаем первый символ
479 | }
480 | 
481 | export async function readFirstNBytes(filePath: string, n: number) {
482 |     const buffer = Buffer.alloc(n) // создаем буфер размером n байт
483 |     const fd = await fs.promises.open(filePath, 'r') // открываем файл для чтения
484 |     try {
485 |         await fd.read(buffer, 0, n, 0) // читаем первые n байт из файла
486 |     } finally {
487 |         await fd.close() // закрываем файл
488 |     }
489 |     return buffer.toString() // преобразуем буфер в строку и возвращаем первые n символов
490 | }
491 | 
492 | export function deleteFile(filename: string) {
493 |     return existFile(filename) && fs.unlinkSync(filename)
494 | }
495 | 
496 | export function deleteDirectory(dir: string) {
497 |     return fs.rmSync(dir, { recursive: true })
498 | }
499 | 
500 | export function renameFile(filename1: string, filename2: string) {
501 |     return fs.renameSync(filename1, filename2)
502 | }
503 | 
504 | export function copyFile(filename1: string, filename2: string) {
505 |     return fs.copyFileSync(filename1, filename2)
506 | }
507 | 
508 | export function copyDirectory(filename1: string, filename2: string) {
509 |     const exists = fs.existsSync(filename1)
510 |     const stats = exists && fs.statSync(filename1)
511 |     const isDirectory = exists && stats && stats.isDirectory()
512 |     if (isDirectory) {
513 |         fs.mkdirSync(filename2)
514 |         fs.readdirSync(filename1).forEach(function(childItemName: string) {
515 |             copyDirectory(path.join(filename1, childItemName),
516 |                 path.join(filename2, childItemName))
517 |         })
518 |     } else {
519 |         fs.copyFileSync(filename1, filename2)
520 |     }
521 | }
522 | 
523 | export function getFileInfo(path: string) {
524 |     if (!fs.existsSync(path)) return
525 |     const stat = fs.statSync(path)
526 |     return { path, basename: getBasename(path), ext: getFileExtension(path), isDir: stat.isDirectory(), ...stat }
527 | }
528 | 
529 | export function getFileDate(path: string) {
530 |     if (!fs.existsSync(path)) return
531 |     const stat = fs.statSync(path)
532 |     return stat.mtime
533 | }
534 | 
535 | export function getFileCreateDate(path: string) {
536 |     if (!fs.existsSync(path)) return
537 |     const stat = fs.statSync(path)
538 |     return stat.ctime
539 | }
540 | 
541 | export function getFileSize(path: string): number | undefined {
542 |     if (!fs.existsSync(path)) return
543 |     const stat = fs.statSync(path)
544 |     return stat.size
545 | }
546 | 
547 | export function getBasename(filename: string) {
548 |     return path.basename(filename)
549 | }
550 | 
551 | export function getFileExtension(filename: string) {
552 |     return path.extname(filename)
553 | }
554 | 
555 | export function getFiles(path: string) {
556 |     if (!isDirectory(path)) {
557 |         console.warn('GmJs getFiles warn: path is not a directory')
558 |         return []
559 |     }
560 |     return fs.readdirSync(path)
561 | }
562 | 
563 | export function getFilesR(path: string) {
564 |     if (!isDirectory(path)) {
565 |         console.warn('GmJs getFiles warn: path is not a directory')
566 |         return []
567 |     }
568 |     return filesR(path, () => true, { ignores: [], maxDepth: 10 })
569 | }
570 | 
571 | export function getFilesFull(path: string) {
572 |     if (!isDirectory(path)) {
573 |         console.warn('GmJs getFilesFull warn: path is not a directory')
574 |         return []
575 |     }
576 |     return fs.readdirSync(path).map(el => path + '/' + el)
577 | }
578 | 
579 | export function getFilesInfo(path: string) {
580 |     if (!isDirectory(path)) {
581 |         console.warn('GmJs getFilseInfo warn: path is not a directory')
582 |         return []
583 |     }
584 |     const files = getFilesFull(path)
585 |     return files.map(file => {
586 |         const stat = fs.statSync(file)
587 |         return { path: file, basename: getBasename(file), ext: getFileExtension(file), isDir: stat.isDirectory(), ...stat }
588 |     })
589 | }
590 | 
591 | export function getDirs(path: string) {
592 |     if (!isDirectory(path)) {
593 |         console.warn('GmJs getDirs warn: path is not a directory')
594 |         return []
595 |     }
596 |     return onlyDirs(getFilesFull(path)).map(getBasename)
597 | }
598 | 
599 | export function getDirsFull(path: string) {
600 |     if (!isDirectory(path)) {
601 |         console.warn('GmJs getDirsFull warn: path is not a directory')
602 |         return []
603 |     }
604 |     return onlyDirs(getFilesFull(path))
605 | }
606 | 
607 | export function isDirectory(path: string) {
608 |     if (!fs.existsSync(path)) return
609 |     return fs.lstatSync(path).isDirectory()
610 | }
611 | 
612 | export function isFile(path: string) {
613 |     if (!fs.existsSync(path)) return
614 |     return !fs.lstatSync(path).isDirectory()
615 | }
616 | 
617 | export function isFileExtension(path: string, ext: string) {
618 |     if (!fs.existsSync(path)) return
619 |     return getFileExtension(path) === ext || getFileExtension(path) === '.' + ext
620 | }
621 | 
622 | export function onlyDirs(files: string[]) {
623 |     return files.filter(isDirectory)
624 | }
625 | 
626 | export function onlyFiles(files: string[]) {
627 |     return files.filter(isFile)
628 | }
629 | 
630 | export function onlyExtension(files: string[], ext: string) {
631 |     return files.filter(file => isFileExtension(file, ext))
632 | }
633 | 
634 | // [ 'E:/', 'E:/asdasd' ]
635 | export function parentDirectories(filename: string): string[] | undefined {
636 |     const res = [] as string[]
637 |     let currentPath = filename
638 |     let i = 0
639 |     while (currentPath && i < 256) {
640 |         if (currentPath !== path.dirname(currentPath)) {
641 |             currentPath = path.dirname(currentPath)
642 |             res.push(currentPath)
643 |         } else {
644 |             return res.reverse()
645 |         }
646 |         i++
647 |     }
648 | }
649 | 
650 | export function parentDir(filename: string) {
651 |     return getBasename(path.dirname(filename))
652 | }
653 | 
654 | export function parentDirectory(filename: string, ...others: any[]) {
655 |     if (others) {
656 |         const all = [filename, ...others]
657 |         const parents = all.map(parentDirectories)
658 |         return transpose(shrinkRight(parents as any)).filter(el => el.every(_el => _el === el[0])).reverse()[0][0]
659 |     } else {
660 |         return path.dirname(filename)
661 |     }
662 | }
663 | 
664 | export function isParentDirectory(dir: string, filename: string): boolean {
665 |     return parentDirectory(filename) === dir
666 | }
667 | 
668 | export function isParentDirectoryR(dir: string, filename: string): boolean {
669 |     return !!parentDirectories(filename)?.includes(dir)
670 | }
671 | 
672 | export const existFile = fs?.existsSync
673 | export const createDirectory = fs?.mkdirSync
674 | export const createDirectoryR = mkdirp?.sync
675 | // Timers
676 | export function sleep(ms: number) {
677 |     return new Promise(resolve => setTimeout(resolve, ms))
678 | }
679 | 
680 | export const gmTimeout = function(func: any, time: number[], enfunc: any) {
681 |     return time.forEach(function(item, i, arr) {
682 |         setTimeout(func, item)
683 |         if (i === time.length - 1) {
684 |             return setTimeout(enfunc, item)
685 |         }
686 |     })
687 | }
688 | 
689 | export const $delay = function(ms: number, func: any) {
690 |     return setTimeout(func, ms)
691 | }
692 | 
693 | export const $interval = function(ms: number, func: any, timeout?: number) {
694 |     if (timeout) {
695 |         return intervalWithTimeout(timeout, ms, func)
696 |     } else {
697 |         return setInterval(func, ms)
698 |     }
699 | }
700 | 
701 | export const $int10 = (f: (...els: any) => any) => $interval(10, f)
702 | export const $int20 = (f: (...els: any) => any) => $interval(20, f)
703 | export const $int50 = (f: (...els: any) => any) => $interval(50, f)
704 | export const $int100 = (f: (...els: any) => any) => $interval(100, f)
705 | export const $int200 = (f: (...els: any) => any) => $interval(200, f)
706 | export const $int500 = (f: (...els: any) => any) => $interval(500, f)
707 | export const $int1000 = (f: (...els: any) => any) => $interval(1000, f)
708 | export const $int2000 = (f: (...els: any) => any) => $interval(2000, f)
709 | export const $int5000 = (f: (...els: any) => any) => $interval(5000, f)
710 | 
711 | export const $delay10 = (f: (...els: any) => any) => $delay(10, f)
712 | export const $delay20 = (f: (...els: any) => any) => $delay(20, f)
713 | export const $delay50 = (f: (...els: any) => any) => $delay(50, f)
714 | export const $delay100 = (f: (...els: any) => any) => $delay(100, f)
715 | export const $delay200 = (f: (...els: any) => any) => $delay(200, f)
716 | export const $delay500 = (f: (...els: any) => any) => $delay(500, f)
717 | export const $delay750 = (f: (...els: any) => any) => $delay(750, f)
718 | export const $delay1000 = (f: (...els: any) => any) => $delay(1000, f)
719 | export const $delay1500 = (f: (...els: any) => any) => $delay(1500, f)
720 | export const $delay2000 = (f: (...els: any) => any) => $delay(2000, f)
721 | export const $delay5000 = (f: (...els: any) => any) => $delay(5000, f)
722 | 
723 | export const gmDelaySolid = function(t: number, f: any) {
724 |     const _timestump = $time()
725 |     return setTimeout(function(ts) {
726 |         if (_timestump === ts) {
727 |             return f()
728 |         }
729 |     }, t, _timestump)
730 | }
731 | 
732 | export const intervalWithTimeout = (f: any, interval: number, timeout: number) => {
733 |     const id = $interval(interval, () => f() ? clearInterval(id) : null)
734 |     return $delay(timeout, () => clearInterval(id))
735 | }
736 | 
737 | export const $time = function() {
738 |     return (new Date()).getTime()
739 | }
740 | 
741 | export const second = 1000
742 | export const K = 1000
743 | export const minute = 60 * 1000
744 | export const hour = 60 * 60 * 1000
745 | export const day = 86400 * 1000
746 | export const week = 7 * day
747 | export const month = 30 * day
748 | export const year = 365 * day
749 | 
750 | export function dirname(meta?: string) {
751 |     if (meta) {
752 |         const moduleURL = new URL(meta)
753 |         return path.dirname(moduleURL.pathname).replace('/E:', 'E:')
754 |     } else {
755 |         return path.resolve()
756 |     }
757 | }
758 | 
759 | export const args = () => process.argv
760 | 
761 | export function convertToArgs(args: any) {
762 |     return Array.isArray(args) ? args.join(' ') : args
763 | }
764 | 
765 | export function callSync(cmd: string, args: any) {
766 |     const proc = spawnSync(cmd, args)
767 |     // console.log(proc);
768 |     return proc.output.toString()
769 | }
770 | 
771 | export const run = spawn
772 | export const runSync = callSync
773 | 
774 | export function pyExec(path: string, args: any) {
775 |     const _args = convertToArgs(args)
776 |     console.log(`python ${path} ${_args}`)
777 |     return exec(`python ${path} ${_args}`)
778 | }
779 | 
780 | export function py3Exec(path: string, args: any) {
781 |     const _args = convertToArgs(args)
782 |     console.log(`python ${path} ${_args}`)
783 |     return exec(`python ${path} ${_args}`)
784 | }
785 | 
786 | export function isPythonInstalled(): boolean {
787 |     const proc = spawnSync('python')
788 |     // console.log(proc);
789 |     return !!proc?.output?.toString()
790 | }
791 | 
792 | export function callPySync(path: string, args?: any) {
793 |     const proc = spawnSync('python', args ? [path, ...args] : [path])
794 |     // console.log(proc);
795 |     return proc.output.toString()
796 | }
797 | 
798 | export function callPy3Sync(path: string, args?: any) {
799 |     const proc = spawnSync('py', args ? [path, ...args] : [path])
800 |     return proc.output.toString()
801 | }
802 | export function openFile(path: string) {
803 |     return exec(`start "" "${path}"`)
804 | }
805 | 
806 | export function runFile(path: string) {
807 |     const parent = parentDirectory(path)
808 |     return exec(`start "" /d "${parent}" "${path}"`)
809 | }
810 | 
811 | export function openFileOrCreate(path: string) {
812 |     if (!existFile(path)) {
813 |         writeFile(path, '')
814 |     }
815 |     return exec(`start "" "${path}"`)
816 | }
817 | 
818 | export function openFileOrCreateR(path: string) {
819 |     if (!existFile(path)) {
820 |         const dir = parentDir(path)
821 |         if (!existFile(dir)) {
822 |             createDirectoryR(dir)
823 |         }
824 |         writeFile(path, '')
825 |     }
826 |     return exec(`start "" "${path}"`)
827 | }
828 | // Computed consts
829 | export const appDataDir = process.env.APPDATA && path?.dirname(process.env.APPDATA)
830 | 
831 | export function escapeHtml(unsafe: string) {
832 |     return unsafe
833 |         .replace(/&/g, '&amp;')
834 |         .replace(/</g, '&lt;')
835 |         .replace(/>/g, '&gt;')
836 |         .replace(/"/g, '&quot;')
837 |         .replace(/'/g, '&#039;')
838 | }
839 | 


--------------------------------------------------------------------------------