kuza-lang 0.0.0-stage → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +97 -2
- package/dist/ai.js +260 -0
- package/dist/i18n.js +198 -0
- package/dist/index.js +220 -0
- package/dist/repl.js +407 -0
- package/dist/ui.js +71 -0
- package/package.json +33 -4
package/README.md
CHANGED
|
@@ -1,3 +1,98 @@
|
|
|
1
|
-
#
|
|
1
|
+
# kuza-lang
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
**Kuza** — маленький язык программирования, который компилируется в JavaScript.
|
|
4
|
+
Короче и понятнее, чем JavaScript: `log >> "привет";`, `:x = 5;`, `?x > 3 >> [ ... ]`,
|
|
5
|
+
таблицы с `select ... from ... where ...`.
|
|
6
|
+
|
|
7
|
+
## Установка
|
|
8
|
+
|
|
9
|
+
```bash
|
|
10
|
+
npm i -g kuza-lang
|
|
11
|
+
```
|
|
12
|
+
|
|
13
|
+
После установки в терминале появляется команда `kuza`.
|
|
14
|
+
Пакет называется `kuza-lang`, потому что имя `kuza` реестр npm не принимает
|
|
15
|
+
(слишком похоже на существующий пакет `koa`) — на саму команду это не влияет.
|
|
16
|
+
|
|
17
|
+
Без глобальной установки можно запускать через `npx kuza-lang run main.kuza`.
|
|
18
|
+
|
|
19
|
+
## Быстрый старт
|
|
20
|
+
|
|
21
|
+
```bash
|
|
22
|
+
kuza init # создаст main.kuza с примером
|
|
23
|
+
kuza run main.kuza # выполнит программу
|
|
24
|
+
kuza build main.kuza # соберёт main.js — работает обычным node main.js
|
|
25
|
+
kuza # откроет консоль (REPL)
|
|
26
|
+
kuza help # справка
|
|
27
|
+
```
|
|
28
|
+
|
|
29
|
+
## Пример программы
|
|
30
|
+
|
|
31
|
+
```kuza
|
|
32
|
+
## main.kuza
|
|
33
|
+
:name = "мир";
|
|
34
|
+
log >> "Привет, {name}!";
|
|
35
|
+
|
|
36
|
+
:users = table<id, name, age>;
|
|
37
|
+
users.add<1, "Аня", 17>;
|
|
38
|
+
users.add<2, "Боря", 22>;
|
|
39
|
+
|
|
40
|
+
:adults = select name, age from users where age >= 18 order by age desc;
|
|
41
|
+
table >> adults;
|
|
42
|
+
|
|
43
|
+
update users set age = age + 1 where id = 1;
|
|
44
|
+
delete from users where age < 18;
|
|
45
|
+
log >> "Осталось: {len >> users}";
|
|
46
|
+
```
|
|
47
|
+
|
|
48
|
+
## Что умеет язык
|
|
49
|
+
|
|
50
|
+
- переменные `:x = 5;`, функции `func add<a, b> >> [ return a + b; ]`;
|
|
51
|
+
- условия `? ... >> [ ... ] || [ ... ]`, циклы `while<>`, `for<>`, `foreach<>`, диапазоны `1..10`;
|
|
52
|
+
- строки с подстановками `"Привет, {name}!"`, лямбды `(x) -> x * 2`, цепочки `|>`;
|
|
53
|
+
- 100+ встроенных команд: строки, массивы, JSON, файлы, HTTP, время, DOM;
|
|
54
|
+
- таблицы: `table<...>`, `select`, `update`, `delete`, сохранение в JSON;
|
|
55
|
+
- сайты: `page`, `heading`, `para`, `button`, `field`, `list`, `link`, `image`, `render`;
|
|
56
|
+
- модули `use math;`, `use time;`, `use "./helpers.kuza";`.
|
|
57
|
+
|
|
58
|
+
Полный список команд: `docs/commands.md` в репозитории языка.
|
|
59
|
+
|
|
60
|
+
## Сайты прямо на Kuza
|
|
61
|
+
|
|
62
|
+
Страница собирается из команд, а состояние — обычные переменные языка:
|
|
63
|
+
|
|
64
|
+
```kuza
|
|
65
|
+
:count = 0;
|
|
66
|
+
|
|
67
|
+
func draw<> >> [
|
|
68
|
+
page >> "Мой сайт на Kuza";
|
|
69
|
+
heading >> "Привет!";
|
|
70
|
+
para >> "Один файл — весь сайт.";
|
|
71
|
+
heading >> "Кликов: {count}";
|
|
72
|
+
button >> <"Прибавить", increase>;
|
|
73
|
+
field >> <"Как тебя зовут?", "name">;
|
|
74
|
+
render;
|
|
75
|
+
];
|
|
76
|
+
|
|
77
|
+
func increase<> >> [
|
|
78
|
+
count = count + 1;
|
|
79
|
+
draw<>;
|
|
80
|
+
];
|
|
81
|
+
|
|
82
|
+
draw<>;
|
|
83
|
+
```
|
|
84
|
+
|
|
85
|
+
```bash
|
|
86
|
+
kuza build site.kuza --web # → site.html — открывается в браузере
|
|
87
|
+
kuza watch site.kuza --web # пересобирает при каждом сохранении
|
|
88
|
+
```
|
|
89
|
+
|
|
90
|
+
Команды страницы: `page` (заголовок вкладки и очистка), `heading`, `para`, `list`,
|
|
91
|
+
`button`, `field` + `fieldValue` (прочитать введённое), `link`, `image`, `render` (нарисовать).
|
|
92
|
+
|
|
93
|
+
## Сборка
|
|
94
|
+
|
|
95
|
+
`kuza build main.kuza` создаёт самостоятельный JavaScript-файл с рантаймом —
|
|
96
|
+
его можно запускать через `node main.js` без установленного Kuza.
|
|
97
|
+
|
|
98
|
+
Лицензия: MIT.
|
package/dist/ai.js
ADDED
|
@@ -0,0 +1,260 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ИИ-ПОМОЩНИК.
|
|
3
|
+
*
|
|
4
|
+
* Два адаптера:
|
|
5
|
+
* • openai — всё, что говорит на языке OpenAI (/chat/completions):
|
|
6
|
+
* OpenAI, OpenRouter, Groq, локальный Ollama, Freebuff API.
|
|
7
|
+
* • anthropic — Claude (/v1/messages).
|
|
8
|
+
*
|
|
9
|
+
* Ключ берётся ТОЛЬКО из переменных окружения (или из .env в текущей папке):
|
|
10
|
+
* KUZA_AI_KEY / OPENAI_API_KEY либо ANTHROPIC_API_KEY
|
|
11
|
+
* KUZA_AI_PROVIDER=openai|anthropic (если ключей два)
|
|
12
|
+
* KUZA_AI_MODEL=... (иначе модель по умолчанию)
|
|
13
|
+
* KUZA_AI_BASE_URL=... (для OpenAI-совместимых серверов)
|
|
14
|
+
*
|
|
15
|
+
* Ключ никогда не печатается и не уходит никуда, кроме выбранного провайдера.
|
|
16
|
+
*/
|
|
17
|
+
import { existsSync, readFileSync } from "node:fs";
|
|
18
|
+
import { createRequire } from "node:module";
|
|
19
|
+
import { dirname, join } from "node:path";
|
|
20
|
+
import { spawnSync } from "node:child_process";
|
|
21
|
+
import { CATEGORIES, COMMANDS, EXT, NAME } from "kuza-core";
|
|
22
|
+
/** Мини-загрузчик .env: не перезаписывает уже заданные переменные. */
|
|
23
|
+
function loadDotEnv() {
|
|
24
|
+
const path = join(process.cwd(), ".env");
|
|
25
|
+
if (!existsSync(path))
|
|
26
|
+
return;
|
|
27
|
+
let text = "";
|
|
28
|
+
try {
|
|
29
|
+
text = readFileSync(path, "utf8");
|
|
30
|
+
}
|
|
31
|
+
catch {
|
|
32
|
+
return;
|
|
33
|
+
}
|
|
34
|
+
for (const rawLine of text.split(/\r?\n/)) {
|
|
35
|
+
const line = rawLine.trim();
|
|
36
|
+
if (!line || line.startsWith("#"))
|
|
37
|
+
continue;
|
|
38
|
+
const eq = line.indexOf("=");
|
|
39
|
+
if (eq === -1)
|
|
40
|
+
continue;
|
|
41
|
+
const key = line.slice(0, eq).trim();
|
|
42
|
+
let value = line.slice(eq + 1).trim();
|
|
43
|
+
if ((value.startsWith('"') && value.endsWith('"')) ||
|
|
44
|
+
(value.startsWith("'") && value.endsWith("'"))) {
|
|
45
|
+
value = value.slice(1, -1);
|
|
46
|
+
}
|
|
47
|
+
if (key && process.env[key] === undefined)
|
|
48
|
+
process.env[key] = value;
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
/** Найти настройки ИИ. Возвращает null, если ключа нет. */
|
|
52
|
+
export function resolveAiConfig() {
|
|
53
|
+
loadDotEnv();
|
|
54
|
+
const explicit = (process.env.KUZA_AI_PROVIDER ?? "").toLowerCase();
|
|
55
|
+
const openaiKey = process.env.KUZA_AI_KEY || process.env.OPENAI_API_KEY;
|
|
56
|
+
const anthropicKey = process.env.ANTHROPIC_API_KEY;
|
|
57
|
+
if (explicit === "anthropic" && anthropicKey) {
|
|
58
|
+
return {
|
|
59
|
+
provider: "anthropic",
|
|
60
|
+
apiKey: anthropicKey,
|
|
61
|
+
model: process.env.KUZA_AI_MODEL || "claude-3-5-sonnet-latest",
|
|
62
|
+
baseUrl: process.env.KUZA_AI_BASE_URL || "https://api.anthropic.com",
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
if (openaiKey) {
|
|
66
|
+
return {
|
|
67
|
+
provider: "openai",
|
|
68
|
+
apiKey: openaiKey,
|
|
69
|
+
model: process.env.KUZA_AI_MODEL || "gpt-4o-mini",
|
|
70
|
+
baseUrl: (process.env.KUZA_AI_BASE_URL || "https://api.openai.com/v1").replace(/\/$/, ""),
|
|
71
|
+
};
|
|
72
|
+
}
|
|
73
|
+
if (anthropicKey) {
|
|
74
|
+
return {
|
|
75
|
+
provider: "anthropic",
|
|
76
|
+
apiKey: anthropicKey,
|
|
77
|
+
model: process.env.KUZA_AI_MODEL || "claude-3-5-sonnet-latest",
|
|
78
|
+
baseUrl: process.env.KUZA_AI_BASE_URL || "https://api.anthropic.com",
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
return null;
|
|
82
|
+
}
|
|
83
|
+
/** Краткая шпаргалка по языку — часть системного промпта. */
|
|
84
|
+
function syntaxCheatSheet() {
|
|
85
|
+
return [
|
|
86
|
+
`Язык называется ${NAME}, файлы .${EXT}. Синтаксис:`,
|
|
87
|
+
':name = значение; — объявить переменную',
|
|
88
|
+
'log >> значение; — вывод (также warn, err, alert)',
|
|
89
|
+
':n = upper >> s; — команда с одним аргументом',
|
|
90
|
+
':m = max >> <a, b>; — команда со списком аргументов в <>',
|
|
91
|
+
'func add<a, b> >> [ ... ] — функция',
|
|
92
|
+
'f<1, 2> — вызов функции (угловые скобки как круглые)',
|
|
93
|
+
'?cond >> [ ... ] || ?c2 >> [ ... ] || [ ... ] — if / else if / else',
|
|
94
|
+
'while<cond> >> [ ... ]',
|
|
95
|
+
'for<:i = 0; i < 10; i++> >> [ ... ]',
|
|
96
|
+
'foreach<item : array> >> [ ... ]',
|
|
97
|
+
'try >> [ ... ] catch<e> >> [ ... ]',
|
|
98
|
+
'## комментарий',
|
|
99
|
+
'Операторы: + - * / % **, == != < > <= >=, and or not',
|
|
100
|
+
].join("\n");
|
|
101
|
+
}
|
|
102
|
+
/** Сжатый список всех команд — чтобы модель не выдумывала несуществующих. */
|
|
103
|
+
export function commandsContext() {
|
|
104
|
+
const categories = new Map(CATEGORIES.map((category) => [category.id, category.title]));
|
|
105
|
+
const lines = [];
|
|
106
|
+
for (const category of CATEGORIES) {
|
|
107
|
+
const items = COMMANDS.filter((command) => command.category === category.id);
|
|
108
|
+
if (items.length === 0)
|
|
109
|
+
continue;
|
|
110
|
+
lines.push(`\n## ${category.title} (${categories.get(category.id)})`);
|
|
111
|
+
for (const command of items) {
|
|
112
|
+
const signature = command.args === "none"
|
|
113
|
+
? command.name
|
|
114
|
+
: command.args === "single"
|
|
115
|
+
? `${command.name} >> x`
|
|
116
|
+
: `${command.name} >> <${command.params.join(", ")}>`;
|
|
117
|
+
const aliases = command.aliases.length ? ` [алиасы: ${command.aliases.join(", ")}]` : "";
|
|
118
|
+
lines.push(`- ${signature} — ${command.description}${aliases}`);
|
|
119
|
+
}
|
|
120
|
+
}
|
|
121
|
+
return lines.join("\n");
|
|
122
|
+
}
|
|
123
|
+
export function systemPrompt() {
|
|
124
|
+
return [
|
|
125
|
+
`Ты — встроенный помощник языка программирования ${NAME}.`,
|
|
126
|
+
`Отвечай кратко и по делу, на языке пользователя (русский по умолчанию).`,
|
|
127
|
+
`Примеры кода пиши ТОЛЬКО на ${NAME}, в блоках \`\`\`${EXT}.`,
|
|
128
|
+
"Не выдумывай команды: используй только список ниже.",
|
|
129
|
+
"",
|
|
130
|
+
syntaxCheatSheet(),
|
|
131
|
+
"",
|
|
132
|
+
"Список всех команд:",
|
|
133
|
+
commandsContext(),
|
|
134
|
+
].join("\n");
|
|
135
|
+
}
|
|
136
|
+
async function callOpenAi(config, messages, system) {
|
|
137
|
+
const response = await fetch(`${config.baseUrl}/chat/completions`, {
|
|
138
|
+
method: "POST",
|
|
139
|
+
headers: {
|
|
140
|
+
"Content-Type": "application/json",
|
|
141
|
+
Authorization: `Bearer ${config.apiKey}`,
|
|
142
|
+
},
|
|
143
|
+
body: JSON.stringify({
|
|
144
|
+
model: config.model,
|
|
145
|
+
temperature: 0.4,
|
|
146
|
+
messages: [{ role: "system", content: system }, ...messages],
|
|
147
|
+
}),
|
|
148
|
+
});
|
|
149
|
+
if (!response.ok) {
|
|
150
|
+
const text = await response.text();
|
|
151
|
+
throw new Error(`${response.status} ${text.slice(0, 300)}`);
|
|
152
|
+
}
|
|
153
|
+
const data = (await response.json());
|
|
154
|
+
return data.choices?.[0]?.message?.content?.trim() ?? "";
|
|
155
|
+
}
|
|
156
|
+
async function callAnthropic(config, messages, system) {
|
|
157
|
+
const response = await fetch(`${config.baseUrl}/v1/messages`, {
|
|
158
|
+
method: "POST",
|
|
159
|
+
headers: {
|
|
160
|
+
"Content-Type": "application/json",
|
|
161
|
+
"x-api-key": config.apiKey,
|
|
162
|
+
"anthropic-version": "2023-06-01",
|
|
163
|
+
},
|
|
164
|
+
body: JSON.stringify({
|
|
165
|
+
model: config.model,
|
|
166
|
+
max_tokens: 2000,
|
|
167
|
+
system,
|
|
168
|
+
messages,
|
|
169
|
+
}),
|
|
170
|
+
});
|
|
171
|
+
if (!response.ok) {
|
|
172
|
+
const text = await response.text();
|
|
173
|
+
throw new Error(`${response.status} ${text.slice(0, 300)}`);
|
|
174
|
+
}
|
|
175
|
+
const data = (await response.json());
|
|
176
|
+
return (data.content ?? [])
|
|
177
|
+
.filter((part) => part.type === "text")
|
|
178
|
+
.map((part) => part.text ?? "")
|
|
179
|
+
.join("")
|
|
180
|
+
.trim();
|
|
181
|
+
}
|
|
182
|
+
export async function askAi(config, messages, system = systemPrompt()) {
|
|
183
|
+
return config.provider === "anthropic"
|
|
184
|
+
? callAnthropic(config, messages, system)
|
|
185
|
+
: callOpenAi(config, messages, system);
|
|
186
|
+
}
|
|
187
|
+
export async function proposeCommand(config, description) {
|
|
188
|
+
const prompt = [
|
|
189
|
+
"Придумай одну новую команду для language Kuza и верни ТОЛЬКО JSON-объект без пояснений и без markdown.",
|
|
190
|
+
"Схема объекта:",
|
|
191
|
+
'{"id":"shout","name":"shout","aliases":["крик"],"category":"output","args":"single",',
|
|
192
|
+
'"params":["text"],"description":"...","example":"shout >> \\"привет\\";","codegen":"console.log(String({0}).toUpperCase())","returns":"void"}',
|
|
193
|
+
"",
|
|
194
|
+
"Правила:",
|
|
195
|
+
"- name — латиницей, одним словом, в стиле существующих команд;",
|
|
196
|
+
'- args: "none" | "single" | "list" (list — аргументы через запятую в <>);',
|
|
197
|
+
"- в codegen подставляй аргументы как {0}, {1} или {rest} (все через запятую);",
|
|
198
|
+
"- codegen должен быть валидным JavaScript;",
|
|
199
|
+
`- category — одна из: ${CATEGORIES.map((category) => category.id).join(", ")};`,
|
|
200
|
+
"- example и description — на русском.",
|
|
201
|
+
"",
|
|
202
|
+
`Что должна делать команда: ${description}`,
|
|
203
|
+
].join("\n");
|
|
204
|
+
const answer = await askAi(config, [{ role: "user", content: prompt }], systemPrompt());
|
|
205
|
+
const start = answer.indexOf("{");
|
|
206
|
+
const end = answer.lastIndexOf("}");
|
|
207
|
+
if (start === -1 || end === -1)
|
|
208
|
+
throw new Error("no json");
|
|
209
|
+
const parsed = JSON.parse(answer.slice(start, end + 1));
|
|
210
|
+
if (!parsed.name || !parsed.codegen || !parsed.category)
|
|
211
|
+
throw new Error("invalid");
|
|
212
|
+
return {
|
|
213
|
+
id: parsed.id || parsed.name,
|
|
214
|
+
name: parsed.name,
|
|
215
|
+
aliases: parsed.aliases ?? [],
|
|
216
|
+
category: parsed.category,
|
|
217
|
+
args: parsed.args ?? "single",
|
|
218
|
+
params: parsed.params ?? [],
|
|
219
|
+
description: parsed.description ?? description,
|
|
220
|
+
example: parsed.example ?? "",
|
|
221
|
+
codegen: parsed.codegen,
|
|
222
|
+
returns: parsed.returns,
|
|
223
|
+
};
|
|
224
|
+
}
|
|
225
|
+
export function commandConflicts(command) {
|
|
226
|
+
const taken = new Set();
|
|
227
|
+
for (const existing of COMMANDS) {
|
|
228
|
+
taken.add(existing.name);
|
|
229
|
+
for (const alias of existing.aliases)
|
|
230
|
+
taken.add(alias);
|
|
231
|
+
}
|
|
232
|
+
if (taken.has(command.name))
|
|
233
|
+
return `имя "${command.name}" уже занято`;
|
|
234
|
+
for (const alias of command.aliases) {
|
|
235
|
+
if (taken.has(alias))
|
|
236
|
+
return `алиас "${alias}" уже занят`;
|
|
237
|
+
}
|
|
238
|
+
if (!CATEGORIES.some((category) => category.id === command.category)) {
|
|
239
|
+
return `неизвестная категория "${command.category}"`;
|
|
240
|
+
}
|
|
241
|
+
return null;
|
|
242
|
+
}
|
|
243
|
+
/** Дописать команду в commands.json и попробовать перегенерировать артефакты. */
|
|
244
|
+
export function appendCommand(command) {
|
|
245
|
+
const require = createRequire(import.meta.url);
|
|
246
|
+
const commandsPath = require.resolve("kuza-core/commands.json");
|
|
247
|
+
const data = JSON.parse(readFileSync(commandsPath, "utf8"));
|
|
248
|
+
data.commands.push(command);
|
|
249
|
+
// Записываем аккуратно: 2 пробела, перевод строки в конце.
|
|
250
|
+
const fs = require("node:fs");
|
|
251
|
+
fs.writeFileSync(commandsPath, JSON.stringify(data, null, 2) + "\n", "utf8");
|
|
252
|
+
const coreDir = dirname(commandsPath);
|
|
253
|
+
const script = join(coreDir, "scripts", "generate.mjs");
|
|
254
|
+
let regenerated = false;
|
|
255
|
+
if (existsSync(script)) {
|
|
256
|
+
const result = spawnSync(process.execPath, [script], { cwd: coreDir, stdio: "ignore" });
|
|
257
|
+
regenerated = result.status === 0;
|
|
258
|
+
}
|
|
259
|
+
return { regenerated, path: commandsPath };
|
|
260
|
+
}
|
package/dist/i18n.js
ADDED
|
@@ -0,0 +1,198 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Переводы консоли: русский, узбекский, английский.
|
|
3
|
+
* Переключаются командой /lang внутри REPL.
|
|
4
|
+
*/
|
|
5
|
+
const dictionaries = {
|
|
6
|
+
ru: {
|
|
7
|
+
welcome: "Добро пожаловать в консоль языка",
|
|
8
|
+
hint: "Пиши код и нажимай Enter. Пустая строка в блоке — продолжение ввода.",
|
|
9
|
+
commandsHint: "Все команды: /commands Примеры: /examples Помощь: /help Выход: /exit",
|
|
10
|
+
bye: "Пока! Хорошего кода.",
|
|
11
|
+
unknownCommand: "Неизвестная команда",
|
|
12
|
+
fileNotFound: "Файл не найден",
|
|
13
|
+
running: "Запускаю",
|
|
14
|
+
built: "Собрано в",
|
|
15
|
+
runWithNode: "Запустить можно так",
|
|
16
|
+
openInBrowser: "Открой в браузере",
|
|
17
|
+
watching: "Слежу за файлом. Остановить: Ctrl+C",
|
|
18
|
+
watchChanged: "Файл изменён — пересобираю",
|
|
19
|
+
compileError: "Ошибка компиляции",
|
|
20
|
+
runtimeError: "Ошибка выполнения",
|
|
21
|
+
initCreated: "Создан файл",
|
|
22
|
+
initExists: "Файл уже существует",
|
|
23
|
+
initNext: "Теперь запусти",
|
|
24
|
+
aiNoKey: "ИИ не настроен. Задай переменную окружения KUZA_AI_KEY (или OPENAI_API_KEY / ANTHROPIC_API_KEY).",
|
|
25
|
+
aiNoKeyHint: "Подробная инструкция: раздел «ИИ-помощник» в README.md",
|
|
26
|
+
aiThinking: "Думаю",
|
|
27
|
+
aiError: "ИИ ответил ошибкой",
|
|
28
|
+
aiModeOn: "Режим ИИ включён. Обычный текст уходит модели, /ai — выключить",
|
|
29
|
+
aiModeOff: "Режим ИИ выключен",
|
|
30
|
+
aiAddUsage: 'Использование: /ai add-command "что должна делать команда"',
|
|
31
|
+
aiAddProposal: "Предложение новой команды",
|
|
32
|
+
aiAddConfirm: "Добавить её в commands.json? (y/n)",
|
|
33
|
+
aiAddCancel: "Отменено",
|
|
34
|
+
aiAddDone: "Команда добавлена в commands.json",
|
|
35
|
+
aiAddRebuild: "Чтобы она заработала, пересобери ядро: npm run build -w kuza-core — и перезапусти консоль.",
|
|
36
|
+
aiAddInvalid: "Ответ модели не похож на корректную команду",
|
|
37
|
+
cleared: "Консоль очищена",
|
|
38
|
+
langSet: "Язык переключён на русский",
|
|
39
|
+
themeSet: "Тема переключена",
|
|
40
|
+
examplesTitle: "Примеры программ",
|
|
41
|
+
examplesUsage: "Запустить пример: /examples run hello",
|
|
42
|
+
commandsTitle: "Команды",
|
|
43
|
+
commandsFiltered: "Ничего не найдено по запросу",
|
|
44
|
+
helpTitle: "Помощь",
|
|
45
|
+
helpBody: [
|
|
46
|
+
"Пиши программы на Kuza прямо в консоли:",
|
|
47
|
+
' :x = 5; объявить переменную',
|
|
48
|
+
' log >> x * 2; вывести значение',
|
|
49
|
+
" 2 + 2 простое выражение напечатается само",
|
|
50
|
+
"",
|
|
51
|
+
"Слэш-команды:",
|
|
52
|
+
" /help эта справка",
|
|
53
|
+
" /commands [фильтр] список команд языка",
|
|
54
|
+
" /examples примеры; /examples run hello — запустить",
|
|
55
|
+
" /clear очистить экран и сбросить переменные",
|
|
56
|
+
" /ai [вопрос] помощник; /ai add-command \"...\" — добавить команду",
|
|
57
|
+
" /lang ru|uz|en язык интерфейса",
|
|
58
|
+
" /theme dark|light тема",
|
|
59
|
+
" /exit выход",
|
|
60
|
+
],
|
|
61
|
+
sessionRestart: "История ввода сброшена",
|
|
62
|
+
},
|
|
63
|
+
uz: {
|
|
64
|
+
welcome: "Kuza tili konsoliga xush kelibsiz",
|
|
65
|
+
hint: "Kod yozing va Enter bosing. Blok ichida bo'sh qator — davomi.",
|
|
66
|
+
commandsHint: "Barcha buyruqlar: /commands Misollar: /examples Yordam: /help Chiqish: /exit",
|
|
67
|
+
bye: "Xayr! Yaxshi kod.",
|
|
68
|
+
unknownCommand: "Noma'lum buyruq",
|
|
69
|
+
fileNotFound: "Fayl topilmadi",
|
|
70
|
+
running: "Ishga tushiryapman",
|
|
71
|
+
built: "Yig'ildi",
|
|
72
|
+
runWithNode: "Bunday ishga tushirish mumkin",
|
|
73
|
+
openInBrowser: "Brauzerda oching",
|
|
74
|
+
watching: "Faylni kuzatyapman. To'xtatish: Ctrl+C",
|
|
75
|
+
watchChanged: "Fayl o'zgardi — qayta yig'aman",
|
|
76
|
+
compileError: "Kompilyatsiya xatosi",
|
|
77
|
+
runtimeError: "Bajarish xatosi",
|
|
78
|
+
initCreated: "Fayl yaratildi",
|
|
79
|
+
initExists: "Fayl allaqachon mavjud",
|
|
80
|
+
initNext: "Endi ishga tushiring",
|
|
81
|
+
aiNoKey: "AI sozlanmagan. KUZA_AI_KEY (yoki OPENAI_API_KEY / ANTHROPIC_API_KEY) muhit o'zgaruvchisini bering.",
|
|
82
|
+
aiNoKeyHint: "Batafsil: README.md dagi «AI yordamchi» bo'limi",
|
|
83
|
+
aiThinking: "O'ylayapman",
|
|
84
|
+
aiError: "AI xato qaytardi",
|
|
85
|
+
aiModeOn: "AI rejimi yoqildi. Oddiy matn modelga ketadi, /ai — o'chirish",
|
|
86
|
+
aiModeOff: "AI rejimi o'chirildi",
|
|
87
|
+
aiAddUsage: 'Foydalanish: /ai add-command "buyruq nima qilishi kerak"',
|
|
88
|
+
aiAddProposal: "Yangi buyruq taklifi",
|
|
89
|
+
aiAddConfirm: "Uni commands.json ga qo'shamizmi? (y/n)",
|
|
90
|
+
aiAddCancel: "Bekor qilindi",
|
|
91
|
+
aiAddDone: "Buyruq commands.json ga qo'shildi",
|
|
92
|
+
aiAddRebuild: "Ishlashi uchun yadroni qayta yig'ing: npm run build -w kuza-core — va konsolni qayta ishga tushiring.",
|
|
93
|
+
aiAddInvalid: "Model javobi to'g'ri buyruqqa o'xshamaydi",
|
|
94
|
+
cleared: "Konsol tozalandi",
|
|
95
|
+
langSet: "Til o'zgartirildi",
|
|
96
|
+
themeSet: "Mavzu o'zgartirildi",
|
|
97
|
+
examplesTitle: "Misollar",
|
|
98
|
+
examplesUsage: "Misolni ishga tushirish: /examples run hello",
|
|
99
|
+
commandsTitle: "Buyruqlar",
|
|
100
|
+
commandsFiltered: "So'rov bo'yicha hech narsa topilmadi",
|
|
101
|
+
helpTitle: "Yordam",
|
|
102
|
+
helpBody: [
|
|
103
|
+
"Kuza dasturlarini to'g'ridan-to'g'ri konsolda yozing:",
|
|
104
|
+
' :x = 5; o\'zgaruvchi e\'lon qilish',
|
|
105
|
+
' log >> x * 2; qiymatni chiqarish',
|
|
106
|
+
" 2 + 2 oddiy ifoda o'zi chop etiladi",
|
|
107
|
+
"",
|
|
108
|
+
"Slash buyruqlar:",
|
|
109
|
+
" /help yordam",
|
|
110
|
+
" /commands [filtr] buyruqlar ro'yxati",
|
|
111
|
+
" /examples misollar; /examples run hello",
|
|
112
|
+
" /clear ekranni tozalash",
|
|
113
|
+
' /ai [savol] yordamchi; /ai add-command "..."',
|
|
114
|
+
" /lang ru|uz|en interfeys tili",
|
|
115
|
+
" /theme dark|light mavzu",
|
|
116
|
+
" /exit chiqish",
|
|
117
|
+
],
|
|
118
|
+
sessionRestart: "Kiritish tarixi tozalandi",
|
|
119
|
+
},
|
|
120
|
+
en: {
|
|
121
|
+
welcome: "Welcome to the console of",
|
|
122
|
+
hint: "Type code and press Enter. Inside a block, an empty line continues input.",
|
|
123
|
+
commandsHint: "All commands: /commands Examples: /examples Help: /help Exit: /exit",
|
|
124
|
+
bye: "Bye! Happy coding.",
|
|
125
|
+
unknownCommand: "Unknown command",
|
|
126
|
+
fileNotFound: "File not found",
|
|
127
|
+
running: "Running",
|
|
128
|
+
built: "Built to",
|
|
129
|
+
runWithNode: "Run it with",
|
|
130
|
+
openInBrowser: "Open it in a browser",
|
|
131
|
+
watching: "Watching the file. Stop with Ctrl+C",
|
|
132
|
+
watchChanged: "File changed — rebuilding",
|
|
133
|
+
compileError: "Compile error",
|
|
134
|
+
runtimeError: "Runtime error",
|
|
135
|
+
initCreated: "Created file",
|
|
136
|
+
initExists: "File already exists",
|
|
137
|
+
initNext: "Now run",
|
|
138
|
+
aiNoKey: "AI is not configured. Set KUZA_AI_KEY (or OPENAI_API_KEY / ANTHROPIC_API_KEY).",
|
|
139
|
+
aiNoKeyHint: "Details: the AI assistant section in README.md",
|
|
140
|
+
aiThinking: "Thinking",
|
|
141
|
+
aiError: "AI returned an error",
|
|
142
|
+
aiModeOn: "AI mode on. Plain text goes to the model, /ai turns it off",
|
|
143
|
+
aiModeOff: "AI mode off",
|
|
144
|
+
aiAddUsage: 'Usage: /ai add-command "what the command should do"',
|
|
145
|
+
aiAddProposal: "Proposed new command",
|
|
146
|
+
aiAddConfirm: "Add it to commands.json? (y/n)",
|
|
147
|
+
aiAddCancel: "Cancelled",
|
|
148
|
+
aiAddDone: "Command added to commands.json",
|
|
149
|
+
aiAddRebuild: "To make it work, rebuild the core: npm run build -w kuza-core — then restart the console.",
|
|
150
|
+
aiAddInvalid: "The model answer is not a valid command",
|
|
151
|
+
cleared: "Console cleared",
|
|
152
|
+
langSet: "Language switched",
|
|
153
|
+
themeSet: "Theme switched",
|
|
154
|
+
examplesTitle: "Examples",
|
|
155
|
+
examplesUsage: "Run an example: /examples run hello",
|
|
156
|
+
commandsTitle: "Commands",
|
|
157
|
+
commandsFiltered: "Nothing found for",
|
|
158
|
+
helpTitle: "Help",
|
|
159
|
+
helpBody: [
|
|
160
|
+
"Write Kuza programs right in the console:",
|
|
161
|
+
' :x = 5; declare a variable',
|
|
162
|
+
' log >> x * 2; print a value',
|
|
163
|
+
" 2 + 2 a bare expression prints itself",
|
|
164
|
+
"",
|
|
165
|
+
"Slash commands:",
|
|
166
|
+
" /help this help",
|
|
167
|
+
" /commands [filter] list language commands",
|
|
168
|
+
" /examples examples; /examples run hello",
|
|
169
|
+
" /clear clear screen and reset variables",
|
|
170
|
+
' /ai [question] assistant; /ai add-command "..."',
|
|
171
|
+
" /lang ru|uz|en interface language",
|
|
172
|
+
" /theme dark|light theme",
|
|
173
|
+
" /exit quit",
|
|
174
|
+
],
|
|
175
|
+
sessionRestart: "Input history reset",
|
|
176
|
+
},
|
|
177
|
+
};
|
|
178
|
+
let current = "ru";
|
|
179
|
+
export function getLang() {
|
|
180
|
+
return current;
|
|
181
|
+
}
|
|
182
|
+
export function setLang(lang) {
|
|
183
|
+
current = lang;
|
|
184
|
+
}
|
|
185
|
+
export function isLang(value) {
|
|
186
|
+
return value === "ru" || value === "uz" || value === "en";
|
|
187
|
+
}
|
|
188
|
+
export function t(key) {
|
|
189
|
+
const dictionary = dictionaries[current];
|
|
190
|
+
const value = dictionary[key];
|
|
191
|
+
if (typeof value === "string")
|
|
192
|
+
return value;
|
|
193
|
+
const fallback = dictionaries.ru[key];
|
|
194
|
+
return typeof fallback === "string" ? fallback : String(key);
|
|
195
|
+
}
|
|
196
|
+
export function helpLines() {
|
|
197
|
+
return [...dictionaries[current].helpBody];
|
|
198
|
+
}
|
package/dist/index.js
ADDED
|
@@ -0,0 +1,220 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* ТОЧКА ВХОДА CLI.
|
|
4
|
+
*
|
|
5
|
+
* kuza открыть консоль (REPL)
|
|
6
|
+
* kuza run main.kuza скомпилировать и выполнить
|
|
7
|
+
* kuza build main.kuza собрать в main.js
|
|
8
|
+
* kuza build main.kuza --web собрать страницу в main.html
|
|
9
|
+
* kuza watch main.kuza пересобирать при сохранении
|
|
10
|
+
* kuza init создать main.kuza с примером
|
|
11
|
+
* kuza help справка
|
|
12
|
+
* kuza --version версия
|
|
13
|
+
*/
|
|
14
|
+
import { existsSync, readFileSync, watchFile, writeFileSync } from "node:fs";
|
|
15
|
+
import { basename, dirname, extname, join, resolve } from "node:path";
|
|
16
|
+
import { FILE_EXT, NAME, VERSION, compile, formatDiagnostic, run, } from "kuza-core";
|
|
17
|
+
import { startRepl } from "./repl.js";
|
|
18
|
+
import { t } from "./i18n.js";
|
|
19
|
+
import { bold, code, danger, dim, primary, printBanner, success, warning, } from "./ui.js";
|
|
20
|
+
const argv = process.argv.slice(2);
|
|
21
|
+
function printEntry(entry) {
|
|
22
|
+
switch (entry.type) {
|
|
23
|
+
case "error":
|
|
24
|
+
console.log(danger("✕ " + entry.message));
|
|
25
|
+
break;
|
|
26
|
+
case "warn":
|
|
27
|
+
console.log(warning("⚠ " + entry.message));
|
|
28
|
+
break;
|
|
29
|
+
case "info":
|
|
30
|
+
console.log(dim("› " + entry.message));
|
|
31
|
+
break;
|
|
32
|
+
default:
|
|
33
|
+
console.log(entry.message);
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
function usage() {
|
|
37
|
+
const ex = `main${FILE_EXT}`;
|
|
38
|
+
console.log("");
|
|
39
|
+
console.log(bold(`${NAME} ${VERSION}`) + dim(` — ${t("running")} ${NAME}-программы`));
|
|
40
|
+
console.log("");
|
|
41
|
+
console.log(` ${primary("kuza")} ${dim("открыть консоль (REPL)")}`);
|
|
42
|
+
console.log(` ${primary("kuza")} run ${ex} ${dim("выполнить файл")}`);
|
|
43
|
+
console.log(` ${primary("kuza")} build ${ex} ${dim("собрать в main.js")}`);
|
|
44
|
+
console.log(` ${primary("kuza")} build ${ex} --web ${dim("собрать страницу в main.html")}`);
|
|
45
|
+
console.log(` ${primary("kuza")} watch ${ex} ${dim("пересобирать при сохранении")}`);
|
|
46
|
+
console.log(` ${primary("kuza")} init ${dim("создать main" + FILE_EXT)}`);
|
|
47
|
+
console.log(` ${primary("kuza")} help ${dim("эта справка")}`);
|
|
48
|
+
console.log("");
|
|
49
|
+
console.log(dim("Пример: ") + code(`${NAME.toLowerCase()} init && ${NAME.toLowerCase()} run ${ex}`));
|
|
50
|
+
console.log("");
|
|
51
|
+
}
|
|
52
|
+
function fail(text) {
|
|
53
|
+
console.error(danger(text));
|
|
54
|
+
process.exitCode = 1;
|
|
55
|
+
}
|
|
56
|
+
/** Читать файлы из use "./helpers.kuza" относительно запускаемого файла. */
|
|
57
|
+
function moduleResolver(entryPath) {
|
|
58
|
+
return (specifier) => readFileSync(resolve(dirname(entryPath), specifier), "utf8");
|
|
59
|
+
}
|
|
60
|
+
async function runFile(file) {
|
|
61
|
+
const path = resolve(file);
|
|
62
|
+
if (!existsSync(path)) {
|
|
63
|
+
fail(`${t("fileNotFound")}: ${file}`);
|
|
64
|
+
return;
|
|
65
|
+
}
|
|
66
|
+
const source = readFileSync(path, "utf8");
|
|
67
|
+
const compileOptions = { filename: path, resolveModule: moduleResolver(path) };
|
|
68
|
+
const compiled = compile(source, compileOptions);
|
|
69
|
+
if (!compiled.ok) {
|
|
70
|
+
console.error(danger(`${t("compileError")}: ${basename(path)}`));
|
|
71
|
+
console.error(danger(formatDiagnostic(compiled.errors[0], source)));
|
|
72
|
+
process.exitCode = 1;
|
|
73
|
+
return;
|
|
74
|
+
}
|
|
75
|
+
console.log(dim(`${t("running")} ${basename(path)}`));
|
|
76
|
+
const result = await run(source, compileOptions);
|
|
77
|
+
for (const entry of result.output)
|
|
78
|
+
printEntry(entry);
|
|
79
|
+
process.exitCode = result.ok ? 0 : 1;
|
|
80
|
+
}
|
|
81
|
+
/** Готовая HTML-страница: собранный JavaScript плюс контейнер #kuza-app. */
|
|
82
|
+
function pageHtml(code) {
|
|
83
|
+
return `<!doctype html>\n<html lang="ru">\n<head>\n<meta charset="utf-8">\n<meta name="viewport" content="width=device-width, initial-scale=1">\n<title>${NAME}</title>\n</head>\n<body>\n<div id="kuza-app"></div>\n<script>\n${code}</script>\n</body>\n</html>\n`;
|
|
84
|
+
}
|
|
85
|
+
function buildFile(file, web) {
|
|
86
|
+
const path = resolve(file);
|
|
87
|
+
if (!existsSync(path)) {
|
|
88
|
+
fail(`${t("fileNotFound")}: ${file}`);
|
|
89
|
+
return;
|
|
90
|
+
}
|
|
91
|
+
const source = readFileSync(path, "utf8");
|
|
92
|
+
const compiled = compile(source, {
|
|
93
|
+
standalone: true,
|
|
94
|
+
filename: path,
|
|
95
|
+
resolveModule: moduleResolver(path),
|
|
96
|
+
});
|
|
97
|
+
if (!compiled.ok) {
|
|
98
|
+
console.error(danger(`${t("compileError")}: ${basename(path)}`));
|
|
99
|
+
console.error(danger(formatDiagnostic(compiled.errors[0], source)));
|
|
100
|
+
process.exitCode = 1;
|
|
101
|
+
return;
|
|
102
|
+
}
|
|
103
|
+
const base = path.slice(0, path.length - extname(path).length);
|
|
104
|
+
const outPath = web ? `${base}.html` : `${base}.js`;
|
|
105
|
+
writeFileSync(outPath, web ? pageHtml(compiled.code) : compiled.code, "utf8");
|
|
106
|
+
console.log(success(`✓ ${t("built")} ${outPath}`));
|
|
107
|
+
console.log(web
|
|
108
|
+
? dim(`${t("openInBrowser")}: `) + code(`"${basename(outPath)}"`)
|
|
109
|
+
: dim(`${t("runWithNode")}: `) + code(`node "${basename(outPath)}"`));
|
|
110
|
+
}
|
|
111
|
+
/** Пересобирать файл при каждом сохранении. */
|
|
112
|
+
function watchProject(file, web) {
|
|
113
|
+
const path = resolve(file);
|
|
114
|
+
if (!existsSync(path)) {
|
|
115
|
+
fail(`${t("fileNotFound")}: ${file}`);
|
|
116
|
+
return;
|
|
117
|
+
}
|
|
118
|
+
const rebuild = () => {
|
|
119
|
+
process.exitCode = 0;
|
|
120
|
+
buildFile(file, web);
|
|
121
|
+
};
|
|
122
|
+
rebuild();
|
|
123
|
+
watchFile(path, { interval: 400 }, (current, previous) => {
|
|
124
|
+
if (current.mtimeMs === previous.mtimeMs)
|
|
125
|
+
return;
|
|
126
|
+
console.log(dim(`↻ ${t("watchChanged")}`));
|
|
127
|
+
rebuild();
|
|
128
|
+
});
|
|
129
|
+
console.log(dim(t("watching")));
|
|
130
|
+
}
|
|
131
|
+
const SAMPLE = `## main${FILE_EXT} — первая программа на ${NAME}
|
|
132
|
+
## Запуск: ${NAME.toLowerCase()} run main${FILE_EXT}
|
|
133
|
+
|
|
134
|
+
:name = "мир";
|
|
135
|
+
log >> "Привет, " + name + "!";
|
|
136
|
+
|
|
137
|
+
:numbers = [1, 2, 3, 4, 5];
|
|
138
|
+
log >> "Сумма: " + sum >> numbers;
|
|
139
|
+
|
|
140
|
+
?len >> numbers > 3 >> [
|
|
141
|
+
log >> "Чисел больше трёх";
|
|
142
|
+
] || [
|
|
143
|
+
log >> "Чисел мало";
|
|
144
|
+
]
|
|
145
|
+
`;
|
|
146
|
+
function initProject(target) {
|
|
147
|
+
const dir = target ? resolve(target) : process.cwd();
|
|
148
|
+
const file = join(dir, `main${FILE_EXT}`);
|
|
149
|
+
if (existsSync(file)) {
|
|
150
|
+
console.log(warning(`${t("initExists")}: ${file}`));
|
|
151
|
+
return;
|
|
152
|
+
}
|
|
153
|
+
try {
|
|
154
|
+
writeFileSync(file, SAMPLE, { encoding: "utf8", flag: "wx" });
|
|
155
|
+
}
|
|
156
|
+
catch {
|
|
157
|
+
fail(`Не удалось создать ${file}. Проверь, что папка существует: ${dir}`);
|
|
158
|
+
return;
|
|
159
|
+
}
|
|
160
|
+
console.log(success(`✓ ${t("initCreated")} ${file}`));
|
|
161
|
+
console.log(dim(`${t("initNext")}: `) + code(`${NAME.toLowerCase()} run main${FILE_EXT}`));
|
|
162
|
+
}
|
|
163
|
+
async function main() {
|
|
164
|
+
const [first, ...rest] = argv;
|
|
165
|
+
if (!first) {
|
|
166
|
+
printBanner();
|
|
167
|
+
await startRepl();
|
|
168
|
+
return;
|
|
169
|
+
}
|
|
170
|
+
if (first === "--version" || first === "-v" || first === "version") {
|
|
171
|
+
console.log(`${NAME} ${VERSION}`);
|
|
172
|
+
return;
|
|
173
|
+
}
|
|
174
|
+
if (first === "--help" || first === "-h" || first === "help") {
|
|
175
|
+
usage();
|
|
176
|
+
return;
|
|
177
|
+
}
|
|
178
|
+
if (first === "run") {
|
|
179
|
+
if (!rest[0]) {
|
|
180
|
+
fail(`Укажи файл: ${NAME.toLowerCase()} run main${FILE_EXT}`);
|
|
181
|
+
return;
|
|
182
|
+
}
|
|
183
|
+
await runFile(rest[0]);
|
|
184
|
+
return;
|
|
185
|
+
}
|
|
186
|
+
if (first === "build") {
|
|
187
|
+
const web = rest.includes("--web");
|
|
188
|
+
const target = rest.find((arg) => !arg.startsWith("--"));
|
|
189
|
+
if (!target) {
|
|
190
|
+
fail(`Укажи файл: ${NAME.toLowerCase()} build main${FILE_EXT}`);
|
|
191
|
+
return;
|
|
192
|
+
}
|
|
193
|
+
buildFile(target, web);
|
|
194
|
+
return;
|
|
195
|
+
}
|
|
196
|
+
if (first === "watch") {
|
|
197
|
+
const web = rest.includes("--web");
|
|
198
|
+
const target = rest.find((arg) => !arg.startsWith("--"));
|
|
199
|
+
if (!target) {
|
|
200
|
+
fail(`Укажи файл: ${NAME.toLowerCase()} watch main${FILE_EXT}`);
|
|
201
|
+
return;
|
|
202
|
+
}
|
|
203
|
+
watchProject(target, web);
|
|
204
|
+
return;
|
|
205
|
+
}
|
|
206
|
+
if (first === "init") {
|
|
207
|
+
initProject(rest[0]);
|
|
208
|
+
return;
|
|
209
|
+
}
|
|
210
|
+
if (first.endsWith(FILE_EXT)) {
|
|
211
|
+
await runFile(first);
|
|
212
|
+
return;
|
|
213
|
+
}
|
|
214
|
+
fail(`${t("unknownCommand")}: ${first}. Попробуй "${NAME.toLowerCase()} help"`);
|
|
215
|
+
}
|
|
216
|
+
main().catch((error) => {
|
|
217
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
218
|
+
console.error(danger(`💥 ${message}`));
|
|
219
|
+
process.exitCode = 1;
|
|
220
|
+
});
|
package/dist/repl.js
ADDED
|
@@ -0,0 +1,407 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ИНТЕРАКТИВНАЯ КОНСОЛЬ (REPL).
|
|
3
|
+
*
|
|
4
|
+
* REPL = Read, Eval, Print, Loop: читает строку, выполняет, печатает результат.
|
|
5
|
+
*
|
|
6
|
+
* Как хранится состояние: мы держим весь ввод сессии и при каждом новом
|
|
7
|
+
* куске перекомпилируем его целиком, печатая только новые строки вывода.
|
|
8
|
+
* Просто и надёжно: переменные и функции «живут» между вводами.
|
|
9
|
+
*/
|
|
10
|
+
import { existsSync, readdirSync, readFileSync } from "node:fs";
|
|
11
|
+
import { createRequire } from "node:module";
|
|
12
|
+
import { basename, dirname, join } from "node:path";
|
|
13
|
+
import { createInterface } from "node:readline";
|
|
14
|
+
import { CATEGORIES, COMMANDS, FILE_EXT, compile, formatDiagnostic, run, } from "kuza-core";
|
|
15
|
+
import { appendCommand, commandConflicts, proposeCommand, resolveAiConfig, askAi } from "./ai.js";
|
|
16
|
+
import { helpLines, isLang, setLang, t } from "./i18n.js";
|
|
17
|
+
import { accent, bold, code, danger, dim, primary, setTheme, success, warning, } from "./ui.js";
|
|
18
|
+
const require = createRequire(import.meta.url);
|
|
19
|
+
function promptMain() {
|
|
20
|
+
return `${primary("kuza")} ${dim("›")} `;
|
|
21
|
+
}
|
|
22
|
+
function promptContinue() {
|
|
23
|
+
return `${dim(" ...")} `;
|
|
24
|
+
}
|
|
25
|
+
/** Закрыты ли все блоки [ ], строки и комментарии? */
|
|
26
|
+
function isComplete(text) {
|
|
27
|
+
let depth = 0;
|
|
28
|
+
let inString = null;
|
|
29
|
+
let inComment = false;
|
|
30
|
+
let escaped = false;
|
|
31
|
+
for (let i = 0; i < text.length; i++) {
|
|
32
|
+
const ch = text[i];
|
|
33
|
+
const next = text[i + 1];
|
|
34
|
+
if (inComment) {
|
|
35
|
+
if (ch === "\n")
|
|
36
|
+
inComment = false;
|
|
37
|
+
continue;
|
|
38
|
+
}
|
|
39
|
+
if (inString) {
|
|
40
|
+
if (escaped) {
|
|
41
|
+
escaped = false;
|
|
42
|
+
continue;
|
|
43
|
+
}
|
|
44
|
+
if (ch === "\\") {
|
|
45
|
+
escaped = true;
|
|
46
|
+
continue;
|
|
47
|
+
}
|
|
48
|
+
if (ch === inString)
|
|
49
|
+
inString = null;
|
|
50
|
+
continue;
|
|
51
|
+
}
|
|
52
|
+
if (ch === "`" || ch === '"' || ch === "'") {
|
|
53
|
+
inString = ch;
|
|
54
|
+
continue;
|
|
55
|
+
}
|
|
56
|
+
if ((ch === "#" && next === "#") || (ch === "/" && next === "/")) {
|
|
57
|
+
inComment = true;
|
|
58
|
+
i++;
|
|
59
|
+
continue;
|
|
60
|
+
}
|
|
61
|
+
if (ch === "[")
|
|
62
|
+
depth++;
|
|
63
|
+
if (ch === "]")
|
|
64
|
+
depth = Math.max(0, depth - 1);
|
|
65
|
+
}
|
|
66
|
+
return depth === 0 && inString === null;
|
|
67
|
+
}
|
|
68
|
+
/** Похоже ли на «просто выражение», которое надо напечатать? */
|
|
69
|
+
function looksLikeExpression(snippet) {
|
|
70
|
+
const text = snippet.trim();
|
|
71
|
+
if (!text || text.includes("\n"))
|
|
72
|
+
return false;
|
|
73
|
+
if (/^(func|while|for|foreach|try|return|throw|break|continue)\b/.test(text))
|
|
74
|
+
return false;
|
|
75
|
+
if (text.startsWith(":") || text.startsWith("?") || text.startsWith("["))
|
|
76
|
+
return false;
|
|
77
|
+
if (text.includes(">>"))
|
|
78
|
+
return false;
|
|
79
|
+
// Присваивание? (одиночный "=", не "==" / "!=" / "<=" / ">=")
|
|
80
|
+
if (/(^|[^=!<>])=([^=]|$)/.test(text))
|
|
81
|
+
return false;
|
|
82
|
+
return true;
|
|
83
|
+
}
|
|
84
|
+
function printEntry(entry) {
|
|
85
|
+
switch (entry.type) {
|
|
86
|
+
case "error":
|
|
87
|
+
console.log(danger("✕ " + entry.message));
|
|
88
|
+
break;
|
|
89
|
+
case "warn":
|
|
90
|
+
console.log(warning("⚠ " + entry.message));
|
|
91
|
+
break;
|
|
92
|
+
case "info":
|
|
93
|
+
console.log(accent("› " + entry.message));
|
|
94
|
+
break;
|
|
95
|
+
default:
|
|
96
|
+
console.log(entry.message);
|
|
97
|
+
}
|
|
98
|
+
}
|
|
99
|
+
function examplesDirectory() {
|
|
100
|
+
const commandsPath = require.resolve("kuza-core/commands.json");
|
|
101
|
+
return join(dirname(commandsPath), "examples");
|
|
102
|
+
}
|
|
103
|
+
export async function startRepl(_replOptions = {}) {
|
|
104
|
+
const rl = createInterface({
|
|
105
|
+
input: process.stdin,
|
|
106
|
+
output: process.stdout,
|
|
107
|
+
terminal: process.stdin.isTTY === true,
|
|
108
|
+
historySize: 200,
|
|
109
|
+
completer: (line) => {
|
|
110
|
+
const trimmed = line.trimStart();
|
|
111
|
+
if (!trimmed.startsWith("/"))
|
|
112
|
+
return [[], line];
|
|
113
|
+
const names = ["/help", "/commands", "/examples", "/clear", "/ai", "/lang", "/theme", "/exit"];
|
|
114
|
+
return [names.filter((name) => name.startsWith(trimmed)), line];
|
|
115
|
+
},
|
|
116
|
+
});
|
|
117
|
+
let buffer = [];
|
|
118
|
+
let session = [];
|
|
119
|
+
let printed = 0;
|
|
120
|
+
let aiMode = false;
|
|
121
|
+
const aiHistory = [];
|
|
122
|
+
const resetSession = () => {
|
|
123
|
+
session = [];
|
|
124
|
+
printed = 0;
|
|
125
|
+
};
|
|
126
|
+
function printOutput(entries, from) {
|
|
127
|
+
for (const entry of entries.slice(from))
|
|
128
|
+
printEntry(entry);
|
|
129
|
+
}
|
|
130
|
+
async function execute(snippet) {
|
|
131
|
+
const prepared = looksLikeExpression(snippet) ? `log >> ${snippet.trim()};` : snippet;
|
|
132
|
+
const candidate = [...session, prepared].join("\n");
|
|
133
|
+
const compiled = compile(candidate, { mode: "body" });
|
|
134
|
+
if (!compiled.ok) {
|
|
135
|
+
console.error(danger(formatDiagnostic(compiled.errors[0], candidate)));
|
|
136
|
+
return;
|
|
137
|
+
}
|
|
138
|
+
session.push(prepared);
|
|
139
|
+
const result = await run(session.join("\n"));
|
|
140
|
+
printOutput(result.output, printed);
|
|
141
|
+
printed = result.output.length;
|
|
142
|
+
if (!result.ok) {
|
|
143
|
+
// Откатываем сломанный кусок, чтобы следующая строка снова работала.
|
|
144
|
+
session.pop();
|
|
145
|
+
printed = Math.max(0, printed - 1);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
async function askAssistant(question) {
|
|
149
|
+
const config = resolveAiConfig();
|
|
150
|
+
if (!config) {
|
|
151
|
+
console.log(warning(t("aiNoKey")));
|
|
152
|
+
console.log(dim(t("aiNoKeyHint")));
|
|
153
|
+
return;
|
|
154
|
+
}
|
|
155
|
+
console.log(dim(t("aiThinking") + "…"));
|
|
156
|
+
try {
|
|
157
|
+
aiHistory.push({ role: "user", content: question });
|
|
158
|
+
const answer = await askAi(config, aiHistory);
|
|
159
|
+
aiHistory.push({ role: "assistant", content: answer });
|
|
160
|
+
console.log("");
|
|
161
|
+
console.log(answer);
|
|
162
|
+
console.log("");
|
|
163
|
+
}
|
|
164
|
+
catch (error) {
|
|
165
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
166
|
+
console.log(danger(`${t("aiError")}: ${message}`));
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
async function addCommand(description) {
|
|
170
|
+
const config = resolveAiConfig();
|
|
171
|
+
if (!config) {
|
|
172
|
+
console.log(warning(t("aiNoKey")));
|
|
173
|
+
console.log(dim(t("aiNoKeyHint")));
|
|
174
|
+
return;
|
|
175
|
+
}
|
|
176
|
+
if (!description) {
|
|
177
|
+
console.log(dim(t("aiAddUsage")));
|
|
178
|
+
return;
|
|
179
|
+
}
|
|
180
|
+
console.log(dim(t("aiThinking") + "…"));
|
|
181
|
+
try {
|
|
182
|
+
const proposal = await proposeCommand(config, description);
|
|
183
|
+
const conflict = commandConflicts(proposal);
|
|
184
|
+
console.log("");
|
|
185
|
+
console.log(bold(t("aiAddProposal")) + ":");
|
|
186
|
+
console.log(code(JSON.stringify(proposal, null, 2)));
|
|
187
|
+
console.log("");
|
|
188
|
+
if (conflict) {
|
|
189
|
+
console.log(danger("✕ " + conflict));
|
|
190
|
+
return;
|
|
191
|
+
}
|
|
192
|
+
const answer = await new Promise((resolvePrompt) => {
|
|
193
|
+
rl.question(accent(t("aiAddConfirm") + " "), resolvePrompt);
|
|
194
|
+
});
|
|
195
|
+
if (!/^(y|yes|д|да|1)$/i.test(answer.trim())) {
|
|
196
|
+
console.log(dim(t("aiAddCancel")));
|
|
197
|
+
return;
|
|
198
|
+
}
|
|
199
|
+
const { path } = appendCommand(proposal);
|
|
200
|
+
console.log(success("✓ " + t("aiAddDone") + ": " + path));
|
|
201
|
+
console.log(dim(t("aiAddRebuild")));
|
|
202
|
+
}
|
|
203
|
+
catch (error) {
|
|
204
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
205
|
+
console.log(danger(`${t("aiAddInvalid")}: ${message}`));
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
function listCommands(filter) {
|
|
209
|
+
const query = filter.toLowerCase();
|
|
210
|
+
let found = 0;
|
|
211
|
+
for (const category of CATEGORIES) {
|
|
212
|
+
const categoryMatches = category.id.toLowerCase().includes(query) ||
|
|
213
|
+
category.title.toLowerCase().includes(query) ||
|
|
214
|
+
category.titleEn.toLowerCase().includes(query);
|
|
215
|
+
const items = COMMANDS.filter((command) => command.category === category.id &&
|
|
216
|
+
(!query ||
|
|
217
|
+
categoryMatches ||
|
|
218
|
+
command.name.toLowerCase().includes(query) ||
|
|
219
|
+
command.description.toLowerCase().includes(query) ||
|
|
220
|
+
command.aliases.some((alias) => alias.toLowerCase().includes(query))));
|
|
221
|
+
if (items.length === 0)
|
|
222
|
+
continue;
|
|
223
|
+
found += items.length;
|
|
224
|
+
console.log("");
|
|
225
|
+
console.log(bold(primary(category.title)));
|
|
226
|
+
for (const command of items) {
|
|
227
|
+
const signature = command.args === "none"
|
|
228
|
+
? command.name
|
|
229
|
+
: command.args === "single"
|
|
230
|
+
? `${command.name} >> x`
|
|
231
|
+
: `${command.name} >> <${command.params.join(", ")}>`;
|
|
232
|
+
console.log(` ${code(signature.padEnd(34))} ${dim(command.description)}`);
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
console.log("");
|
|
236
|
+
if (found === 0)
|
|
237
|
+
console.log(dim(`${t("commandsFiltered")} "${filter}"`));
|
|
238
|
+
else
|
|
239
|
+
console.log(dim(`Всего: ${found}. Подробнее: docs/commands.md`));
|
|
240
|
+
}
|
|
241
|
+
async function listExamples(argument) {
|
|
242
|
+
const dir = examplesDirectory();
|
|
243
|
+
if (!existsSync(dir)) {
|
|
244
|
+
console.log(dim("Папка examples не найдена."));
|
|
245
|
+
return;
|
|
246
|
+
}
|
|
247
|
+
const files = readdirSync(dir).filter((name) => name.endsWith(FILE_EXT));
|
|
248
|
+
if (argument.startsWith("run")) {
|
|
249
|
+
const wanted = argument.slice(3).trim().replace(/\.kuza$/, "");
|
|
250
|
+
if (!wanted) {
|
|
251
|
+
console.log(dim(t("examplesUsage")));
|
|
252
|
+
return;
|
|
253
|
+
}
|
|
254
|
+
const file = files.find((name) => basename(name, FILE_EXT) === wanted);
|
|
255
|
+
if (!file) {
|
|
256
|
+
console.log(danger(`${t("fileNotFound")}: ${wanted}`));
|
|
257
|
+
return;
|
|
258
|
+
}
|
|
259
|
+
const source = readFileSync(join(dir, file), "utf8");
|
|
260
|
+
console.log("");
|
|
261
|
+
console.log(dim(`▶ examples/${file}`));
|
|
262
|
+
const result = await run(source);
|
|
263
|
+
for (const entry of result.output)
|
|
264
|
+
printEntry(entry);
|
|
265
|
+
console.log("");
|
|
266
|
+
return;
|
|
267
|
+
}
|
|
268
|
+
console.log("");
|
|
269
|
+
console.log(bold(t("examplesTitle")));
|
|
270
|
+
for (const file of files)
|
|
271
|
+
console.log(` ${code(basename(file, FILE_EXT))} ${dim("examples/" + file)}`);
|
|
272
|
+
console.log("");
|
|
273
|
+
console.log(dim(t("examplesUsage")));
|
|
274
|
+
console.log("");
|
|
275
|
+
}
|
|
276
|
+
/** Возвращает true, если пора выходить. */
|
|
277
|
+
async function handleSlash(text) {
|
|
278
|
+
const [name, ...restParts] = text.slice(1).split(/\s+/);
|
|
279
|
+
const rest = restParts.join(" ");
|
|
280
|
+
switch ((name ?? "").toLowerCase()) {
|
|
281
|
+
case "help":
|
|
282
|
+
console.log("");
|
|
283
|
+
console.log(bold(t("helpTitle")));
|
|
284
|
+
for (const line of helpLines())
|
|
285
|
+
console.log(line);
|
|
286
|
+
console.log("");
|
|
287
|
+
return false;
|
|
288
|
+
case "commands":
|
|
289
|
+
listCommands(rest);
|
|
290
|
+
return false;
|
|
291
|
+
case "examples":
|
|
292
|
+
await listExamples(rest);
|
|
293
|
+
return false;
|
|
294
|
+
case "clear":
|
|
295
|
+
resetSession();
|
|
296
|
+
aiHistory.length = 0;
|
|
297
|
+
console.clear();
|
|
298
|
+
console.log(dim(t("cleared")));
|
|
299
|
+
return false;
|
|
300
|
+
case "ai": {
|
|
301
|
+
const task = rest.trim();
|
|
302
|
+
if (task.startsWith("add-command")) {
|
|
303
|
+
const description = task
|
|
304
|
+
.slice("add-command".length)
|
|
305
|
+
.trim()
|
|
306
|
+
.replace(/^["'«]|["'»]$/g, "");
|
|
307
|
+
await addCommand(description);
|
|
308
|
+
return false;
|
|
309
|
+
}
|
|
310
|
+
if (!task) {
|
|
311
|
+
aiMode = !aiMode;
|
|
312
|
+
console.log(aiMode ? success(t("aiModeOn")) : dim(t("aiModeOff")));
|
|
313
|
+
return false;
|
|
314
|
+
}
|
|
315
|
+
await askAssistant(task);
|
|
316
|
+
return false;
|
|
317
|
+
}
|
|
318
|
+
case "lang": {
|
|
319
|
+
const value = rest.trim().toLowerCase();
|
|
320
|
+
if (isLang(value)) {
|
|
321
|
+
setLang(value);
|
|
322
|
+
console.log(success(t("langSet")));
|
|
323
|
+
}
|
|
324
|
+
else {
|
|
325
|
+
console.log(dim("Использование: /lang ru|uz|en"));
|
|
326
|
+
}
|
|
327
|
+
return false;
|
|
328
|
+
}
|
|
329
|
+
case "theme": {
|
|
330
|
+
const value = rest.trim().toLowerCase();
|
|
331
|
+
if (value === "dark" || value === "light") {
|
|
332
|
+
setTheme(value);
|
|
333
|
+
console.log(success(t("themeSet") + ": " + value));
|
|
334
|
+
}
|
|
335
|
+
else {
|
|
336
|
+
console.log(dim("Использование: /theme dark|light"));
|
|
337
|
+
}
|
|
338
|
+
return false;
|
|
339
|
+
}
|
|
340
|
+
case "exit":
|
|
341
|
+
case "quit":
|
|
342
|
+
return true;
|
|
343
|
+
default:
|
|
344
|
+
console.log(dim(`${t("unknownCommand")}: /${name}. Попробуй /help`));
|
|
345
|
+
return false;
|
|
346
|
+
}
|
|
347
|
+
}
|
|
348
|
+
rl.setPrompt(promptMain());
|
|
349
|
+
rl.prompt();
|
|
350
|
+
rl.on("SIGINT", () => {
|
|
351
|
+
if (buffer.length > 0) {
|
|
352
|
+
buffer = [];
|
|
353
|
+
console.log("");
|
|
354
|
+
rl.setPrompt(promptMain());
|
|
355
|
+
rl.prompt();
|
|
356
|
+
}
|
|
357
|
+
else {
|
|
358
|
+
rl.close();
|
|
359
|
+
}
|
|
360
|
+
});
|
|
361
|
+
for await (const line of rl) {
|
|
362
|
+
// Многострочный ввод: пока блок не закрыт, собираем строки.
|
|
363
|
+
if (buffer.length > 0) {
|
|
364
|
+
buffer.push(line);
|
|
365
|
+
const text = buffer.join("\n");
|
|
366
|
+
if (!isComplete(text)) {
|
|
367
|
+
rl.setPrompt(promptContinue());
|
|
368
|
+
rl.prompt();
|
|
369
|
+
continue;
|
|
370
|
+
}
|
|
371
|
+
buffer = [];
|
|
372
|
+
rl.setPrompt(promptMain());
|
|
373
|
+
await execute(text);
|
|
374
|
+
rl.prompt();
|
|
375
|
+
continue;
|
|
376
|
+
}
|
|
377
|
+
if (!line.trim()) {
|
|
378
|
+
rl.prompt();
|
|
379
|
+
continue;
|
|
380
|
+
}
|
|
381
|
+
if (line.trimStart().startsWith("/")) {
|
|
382
|
+
const shouldExit = await handleSlash(line.trim());
|
|
383
|
+
if (shouldExit) {
|
|
384
|
+
rl.close();
|
|
385
|
+
break;
|
|
386
|
+
}
|
|
387
|
+
rl.prompt();
|
|
388
|
+
continue;
|
|
389
|
+
}
|
|
390
|
+
if (!isComplete(line)) {
|
|
391
|
+
buffer = [line];
|
|
392
|
+
rl.setPrompt(promptContinue());
|
|
393
|
+
rl.prompt();
|
|
394
|
+
continue;
|
|
395
|
+
}
|
|
396
|
+
if (aiMode) {
|
|
397
|
+
await askAssistant(line);
|
|
398
|
+
}
|
|
399
|
+
else {
|
|
400
|
+
await execute(line);
|
|
401
|
+
}
|
|
402
|
+
rl.prompt();
|
|
403
|
+
}
|
|
404
|
+
console.log("");
|
|
405
|
+
console.log(dim(t("bye")));
|
|
406
|
+
console.log("");
|
|
407
|
+
}
|
package/dist/ui.js
ADDED
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Оформление консоли: ASCII-лого, цвета, рамки.
|
|
3
|
+
* Тема влияет только на оттенки — тёмная (по умолчанию) и светлая.
|
|
4
|
+
*/
|
|
5
|
+
import boxen from "boxen";
|
|
6
|
+
import chalk from "chalk";
|
|
7
|
+
import gradient from "gradient-string";
|
|
8
|
+
import { NAME, VERSION, FILE_EXT, TAGLINE, COLORS } from "kuza-core";
|
|
9
|
+
import { t } from "./i18n.js";
|
|
10
|
+
let theme = "dark";
|
|
11
|
+
export function setTheme(name) {
|
|
12
|
+
theme = name;
|
|
13
|
+
}
|
|
14
|
+
export function getTheme() {
|
|
15
|
+
return theme;
|
|
16
|
+
}
|
|
17
|
+
function pick(darkHex, lightHex) {
|
|
18
|
+
return (text) => chalk.hex(theme === "dark" ? darkHex : lightHex)(text);
|
|
19
|
+
}
|
|
20
|
+
/** Основной цвет бренда: оранжевый. */
|
|
21
|
+
export const primary = (text) => pick(COLORS.primary, "#b45309")(text);
|
|
22
|
+
/** Второй цвет градиента: светлый оранжевый. */
|
|
23
|
+
export const accent = (text) => pick(COLORS.accent, "#c2410c")(text);
|
|
24
|
+
/** Кремовый текст бренда. */
|
|
25
|
+
export const brandText = (text) => pick(COLORS.text, "#3f2d20")(text);
|
|
26
|
+
/** Приглушённый текст. */
|
|
27
|
+
export const dim = (text) => chalk.gray(text);
|
|
28
|
+
/** Жирный текст. */
|
|
29
|
+
export const bold = (text) => chalk.bold(text);
|
|
30
|
+
/** Успех. */
|
|
31
|
+
export const success = (text) => pick("#3ddc84", "#15803d")(text);
|
|
32
|
+
/** Ошибка. */
|
|
33
|
+
export const danger = (text) => pick("#ff5c7a", "#b91c1c")(text);
|
|
34
|
+
/** Предупреждение. */
|
|
35
|
+
export const warning = (text) => pick("#ffcc02", "#a16207")(text);
|
|
36
|
+
/** Подсказка-команда. */
|
|
37
|
+
export const code = (text) => chalk.hex(theme === "dark" ? "#ffd479" : "#92400e")(text);
|
|
38
|
+
const ASCII_LOGO = [
|
|
39
|
+
" ██╗ ██╗██╗ ██╗███████╗ █████╗ ",
|
|
40
|
+
" ██║ ██╔╝██║ ██║╚══███╔╝██╔══██╗",
|
|
41
|
+
" █████╔╝ ██║ ██║ ███╔╝ ███████║",
|
|
42
|
+
" ██╔═██╗ ██║ ██║ ███╔╝ ██╔══██║",
|
|
43
|
+
" ██║ ██╗╚██████╔╝███████╗██║ ██║",
|
|
44
|
+
" ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝",
|
|
45
|
+
].join("\n");
|
|
46
|
+
export function printBanner() {
|
|
47
|
+
// Градиент логотипа: от светлого оранжевого к акценту.
|
|
48
|
+
const painted = gradient([...COLORS.gradient]).multiline(ASCII_LOGO);
|
|
49
|
+
console.log("");
|
|
50
|
+
console.log(painted);
|
|
51
|
+
console.log("");
|
|
52
|
+
const title = `${bold(brandText(NAME))} ${dim("v" + VERSION)} ${dim("· " + FILE_EXT)}`;
|
|
53
|
+
const lines = [
|
|
54
|
+
`${title} ${dim("·")} ${brandText(TAGLINE)}`,
|
|
55
|
+
"",
|
|
56
|
+
`${accent("›")} ${brandText(t("welcome"))} ${primary(NAME)}`,
|
|
57
|
+
`${dim(t("hint"))}`,
|
|
58
|
+
"",
|
|
59
|
+
`${brandText(t("commandsHint"))}`,
|
|
60
|
+
];
|
|
61
|
+
console.log(boxen(lines.join("\n"), {
|
|
62
|
+
padding: 1,
|
|
63
|
+
margin: { top: 0, bottom: 1, left: 0, right: 0 },
|
|
64
|
+
borderStyle: "round",
|
|
65
|
+
borderColor: theme === "dark" ? COLORS.primary : "#C2410C",
|
|
66
|
+
...(theme === "dark" ? { backgroundColor: COLORS.bg } : {}),
|
|
67
|
+
}));
|
|
68
|
+
}
|
|
69
|
+
export function printCompileError(text) {
|
|
70
|
+
console.error(danger(text));
|
|
71
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,35 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "kuza-lang",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.3.0",
|
|
4
|
+
"description": "Kuza — консоль языка: запуск, сборка, REPL и ИИ-помощник",
|
|
5
|
+
"license": "MIT",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"bin": {
|
|
8
|
+
"kuza": "dist/index.js"
|
|
9
|
+
},
|
|
10
|
+
"main": "./dist/index.js",
|
|
11
|
+
"files": [
|
|
12
|
+
"dist",
|
|
13
|
+
"README.md"
|
|
14
|
+
],
|
|
15
|
+
"engines": {
|
|
16
|
+
"node": ">=20"
|
|
17
|
+
},
|
|
18
|
+
"keywords": [
|
|
19
|
+
"kuza",
|
|
20
|
+
"language",
|
|
21
|
+
"cli",
|
|
22
|
+
"repl",
|
|
23
|
+
"compiler"
|
|
24
|
+
],
|
|
25
|
+
"scripts": {
|
|
26
|
+
"build": "tsc -p tsconfig.json",
|
|
27
|
+
"start": "node dist/index.js"
|
|
28
|
+
},
|
|
29
|
+
"dependencies": {
|
|
30
|
+
"kuza-core": "^0.3.0",
|
|
31
|
+
"boxen": "^8.0.1",
|
|
32
|
+
"chalk": "^5.3.0",
|
|
33
|
+
"gradient-string": "^3.0.0"
|
|
34
|
+
}
|
|
35
|
+
}
|