@intend-it/cli 1.0.1

package/dist/index.js

@@ -0,0 +1,483 @@
+#!/usr/bin/env node
+
+// src/commands/init.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+var DEFAULT_CONFIG_NAME = "intend.config.json";
+var DEFAULT_CONFIG = {
+  sourceDir: "./src/intents",
+  outDir: "./out",
+  provider: "gemini",
+  gemini: {
+    apiKey: "${GEMINI_API_KEY}",
+    model: "gemini-flash-latest",
+    temperature: 0.2
+  },
+  ollama: {
+    model: "llama3",
+    baseUrl: "http://localhost:11434",
+    temperature: 0.2
+  },
+  include: ["**/*.intent"],
+  exclude: ["**/*.test.intent"]
+};
+function loadConfig(configPath) {
+  const path = configPath ? resolve(process.cwd(), configPath) : resolve(process.cwd(), DEFAULT_CONFIG_NAME);
+  if (!existsSync(path)) {
+    if (configPath) {
+      throw new Error(`Config file not found: ${path}`);
+    }
+    const config = { ...DEFAULT_CONFIG };
+    if (process.env.GEMINI_API_KEY) {
+      config.gemini = { ...config.gemini, apiKey: process.env.GEMINI_API_KEY };
+    }
+    return config;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    const userConfig = JSON.parse(content);
+    const config = {
+      ...DEFAULT_CONFIG,
+      ...userConfig,
+      gemini: { ...DEFAULT_CONFIG.gemini, ...userConfig.gemini || {} },
+      ollama: { ...DEFAULT_CONFIG.ollama, ...userConfig.ollama || {} }
+    };
+    if (config.gemini && config.gemini.apiKey === "${GEMINI_API_KEY}" && process.env.GEMINI_API_KEY) {
+      config.gemini.apiKey = process.env.GEMINI_API_KEY;
+    }
+    return config;
+  } catch (error) {
+    throw new Error(`Failed to parse config file: ${error.message}`);
+  }
+}
+function createConfigFile(directory = process.cwd()) {
+  const path = join(directory, DEFAULT_CONFIG_NAME);
+  if (existsSync(path)) {
+    throw new Error(`Config file already exists: ${path}`);
+  }
+  writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
+}
+
+// src/ui.ts
+import pc from "picocolors";
+import ora from "ora";
+var BRAND = {
+  name: "intend",
+  version: "0.0.1"
+};
+var heading = (text) => pc.bold(text);
+var success = (text) => pc.green(text);
+var error = (text) => pc.red(text);
+var warn = (text) => pc.yellow(text);
+var accent = (text) => pc.cyan(text);
+var dim = (text) => pc.dim(text);
+var bullet = (text) => `  ${dim("›")} ${text}`;
+var path = (p) => dim(p);
+var num = (n) => pc.bold(pc.white(String(n)));
+var duration = (ms) => dim(`${(ms / 1000).toFixed(2)}s`);
+var cmd = (name) => pc.cyan(name);
+var label = (name, value) => `${dim(name + ":")} ${value}`;
+var icons = {
+  success: pc.green("✓"),
+  error: pc.red("✗"),
+  warning: pc.yellow("!"),
+  info: pc.cyan("i"),
+  cached: pc.blue("⚡"),
+  arrow: dim("→")
+};
+function spinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "dots"
+  });
+}
+function printHeader(text) {
+  console.log();
+  console.log(heading(text));
+}
+function printError(message, detail) {
+  console.log();
+  console.log(`${icons.error} ${error(message)}`);
+  if (detail) {
+    console.log(`  ${dim(detail)}`);
+  }
+}
+function printSuccess(message) {
+  console.log(`${icons.success} ${success(message)}`);
+}
+function printWarning(message) {
+  console.log(`${icons.warning} ${warn(message)}`);
+}
+function newline() {
+  console.log();
+}
+function printHelp() {
+  console.log();
+  console.log(`${heading("intend")} ${dim(`v${BRAND.version}`)}`);
+  console.log(dim("AI-Powered Intent Compiler"));
+  console.log();
+  console.log(heading("Usage"));
+  console.log(`  ${dim("$")} intend ${dim("<command>")} ${dim("[options]")}`);
+  console.log();
+  console.log(heading("Commands"));
+  console.log(`  ${cmd("init")} ${dim("[dir]")}        Initialize a new project`);
+  console.log(`  ${cmd("build")}              Build the project`);
+  console.log(`  ${cmd("watch")}              Watch and rebuild on changes`);
+  console.log(`  ${cmd("parse")} ${dim("<file>")}      Parse a file to AST/CST`);
+  console.log();
+  console.log(heading("Options"));
+  console.log(`  ${cmd("--config")} ${dim("<path>")}   Path to config file`);
+  console.log(`  ${cmd("--output")} ${dim("<dir>")}    Output directory`);
+  console.log(`  ${cmd("--provider")} ${dim("<name>")} AI provider ${dim("(gemini | ollama)")}`);
+  console.log(`  ${cmd("--api-key")} ${dim("<key>")}   Gemini API key`);
+  console.log(`  ${cmd("--force")}            Force regeneration (skip cache)`);
+  console.log(`  ${cmd("--help")}             Show this help`);
+  console.log();
+}
+
+// src/commands/init.ts
+async function initCommand(args) {
+  const directory = args[1] ? resolve2(process.cwd(), args[1]) : process.cwd();
+  printHeader("Initialize Project");
+  console.log(label("Directory", path(directory)));
+  newline();
+  const spinner2 = spinner("Creating project structure...").start();
+  if (!existsSync2(directory)) {
+    mkdirSync(directory, { recursive: true });
+  }
+  const srcDir = join2(directory, "src", "intents");
+  if (!existsSync2(srcDir)) {
+    mkdirSync(srcDir, { recursive: true });
+  }
+  const outDir = join2(directory, "out");
+  if (!existsSync2(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  spinner2.succeed(dim("Project structure created"));
+  console.log(bullet(`${dim("src/intents/")} ${dim("(intent files)")}`));
+  console.log(bullet(`${dim("out/")} ${dim("(generated code)")}`));
+  const configSpinner = spinner("Creating configuration...").start();
+  try {
+    createConfigFile(directory);
+    configSpinner.succeed(dim("intend.config.json created"));
+  } catch (error2) {
+    configSpinner.stopAndPersist({
+      symbol: icons.warning,
+      text: warn(error2.message)
+    });
+  }
+  const examplePath = join2(srcDir, "example.intent");
+  if (!existsSync2(examplePath)) {
+    const exampleContent = `export intent Greeting(name: string) -> string {
+    step "Create greeting message" => const message
+    ensure message is defined
+}`;
+    writeFileSync2(examplePath, exampleContent, "utf-8");
+    console.log(bullet(`${dim("src/intents/example.intent")} ${dim("(example)")}`));
+  }
+  newline();
+  printSuccess("Project initialized");
+  newline();
+  console.log(heading("Next Steps"));
+  console.log(bullet(`Configure provider in ${accent("intend.config.json")}`));
+  console.log(bullet(`Set ${accent("GEMINI_API_KEY")} env var ${dim("(if using Gemini)")}`));
+  console.log(bullet(`Run ${accent("intend build")} to generate code`));
+  newline();
+}
+
+// src/commands/build.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3, resolve as resolve3, basename } from "path";
+import { AICodeGenerator, FileSystemCAS, computeHash } from "@intend-it/core";
+import { parseToAST } from "@intend-it/parser";
+import { readdirSync, statSync } from "fs";
+function findIntentFiles(dir, fileList = []) {
+  const files = readdirSync(dir);
+  files.forEach((file) => {
+    const filePath = join3(dir, file);
+    const stat = statSync(filePath);
+    if (stat.isDirectory()) {
+      if (file !== "node_modules" && file !== ".git") {
+        findIntentFiles(filePath, fileList);
+      }
+    } else {
+      if (file.endsWith(".intent")) {
+        fileList.push(filePath);
+      }
+    }
+  });
+  return fileList;
+}
+async function buildCommand(options) {
+  const config = loadConfig(options.config);
+  if (options.output)
+    config.outDir = options.output;
+  if (options.apiKey && config.gemini)
+    config.gemini.apiKey = options.apiKey;
+  if (options.provider)
+    config.provider = options.provider;
+  const sourceDir = resolve3(process.cwd(), config.sourceDir);
+  const outDir = resolve3(process.cwd(), config.outDir);
+  const providerName = config.provider || "gemini";
+  if (config.provider === "gemini" && (!config.gemini || !config.gemini.apiKey)) {
+    printError("Gemini API key required", "Set GEMINI_API_KEY env var or add to intend.config.json");
+    process.exit(1);
+  }
+  printHeader("Build");
+  console.log(label("Source", path(sourceDir)));
+  console.log(label("Output", path(outDir)));
+  console.log(label("Provider", accent(providerName)));
+  newline();
+  const scanSpinner = spinner("Scanning for .intent files...").start();
+  let files = [];
+  try {
+    files = findIntentFiles(sourceDir);
+    scanSpinner.succeed(dim(`Found ${num(files.length)} intent file${files.length !== 1 ? "s" : ""}`));
+  } catch (err) {
+    scanSpinner.fail(error(`Failed to scan ${sourceDir}`));
+    process.exit(1);
+  }
+  if (files.length === 0) {
+    printWarning("No .intent files found");
+    return;
+  }
+  const startTime = Date.now();
+  const projectContext = new Map;
+  const fileData = new Map;
+  let parseErrors = 0;
+  for (const file of files) {
+    try {
+      const content = readFileSync2(file, "utf-8");
+      const astResult = parseToAST(content);
+      projectContext.set(file, astResult.ast);
+      const hash = computeHash(content, config);
+      fileData.set(file, { content, hash, ast: astResult.ast });
+    } catch (err) {
+      console.log(`  ${icons.error} ${dim("Parse failed:")} ${basename(file)}`);
+      console.log(`    ${dim(err.message)}`);
+      parseErrors++;
+    }
+  }
+  const generator = new AICodeGenerator({
+    provider: config.provider,
+    geminiConfig: config.gemini ? {
+      apiKey: config.gemini.apiKey,
+      model: config.gemini.model,
+      temperature: config.gemini.temperature
+    } : undefined,
+    ollamaConfig: config.ollama,
+    mode: "full",
+    maxAttempts: options.attempts,
+    projectContext
+  });
+  const connectSpinner = spinner(`Connecting to ${providerName}...`).start();
+  try {
+    const connected = await generator.testConnection();
+    if (!connected) {
+      if (config.provider === "ollama") {
+        connectSpinner.fail(error("Failed to connect to Ollama. Is it running?"));
+      } else {
+        connectSpinner.fail(error("Failed to connect to Gemini API"));
+      }
+      process.exit(1);
+    }
+    connectSpinner.succeed(dim(`Connected to ${providerName}`));
+  } catch (error2) {
+    connectSpinner.fail(error(`Connection failed: ${error2.message}`));
+    process.exit(1);
+  }
+  const casDir = resolve3(process.cwd(), ".intend", "store");
+  const cas = new FileSystemCAS(casDir);
+  let successCount = 0;
+  let failCount = parseErrors;
+  let cachedCount = 0;
+  if (!existsSync3(outDir)) {
+    mkdirSync2(outDir, { recursive: true });
+  }
+  newline();
+  console.log(heading("Compiling"));
+  for (const file of files) {
+    if (!fileData.has(file))
+      continue;
+    const relativePath = file.substring(sourceDir.length + 1);
+    const fileName = basename(file, ".intent");
+    const outFile = join3(outDir, `${fileName}.ts`);
+    const fileSpinner = spinner(`${relativePath}`).start();
+    const fileStart = Date.now();
+    try {
+      const { hash, ast } = fileData.get(file);
+      const cached = await cas.get(hash);
+      let finalCode;
+      if (!options.force && cached) {
+        fileSpinner.stopAndPersist({
+          symbol: icons.cached,
+          text: `${dim(relativePath)} ${dim("(cached)")}`
+        });
+        finalCode = cached.code;
+        cachedCount++;
+      } else {
+        const generated = await generator.generate(ast, file);
+        finalCode = generated.code;
+        await cas.put(hash, finalCode);
+        const fileDuration = Date.now() - fileStart;
+        fileSpinner.succeed(`${relativePath} ${dim(`${fileDuration}ms`)}`);
+      }
+      writeFileSync3(outFile, finalCode, "utf-8");
+      successCount++;
+    } catch (error2) {
+      fileSpinner.fail(`${relativePath} ${dim(error2.message)}`);
+      failCount++;
+    }
+  }
+  const totalDuration = Date.now() - startTime;
+  newline();
+  console.log(heading("Summary"));
+  console.log(`  ${icons.success} ${num(successCount)} compiled ${cachedCount > 0 ? dim(`(${cachedCount} cached)`) : ""}`);
+  if (failCount > 0) {
+    console.log(`  ${icons.error} ${num(failCount)} failed`);
+  }
+  console.log(`  ${icons.arrow} ${duration(totalDuration)}`);
+  newline();
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+// src/commands/watch.ts
+import { watch } from "fs";
+import { resolve as resolve4 } from "path";
+async function watchCommand(options) {
+  printHeader("Watch Mode");
+  const config = loadConfig(options.config);
+  const sourceDir = resolve4(process.cwd(), config.sourceDir);
+  console.log(label("Watching", path(sourceDir)));
+  newline();
+  await buildCommand(options).catch(() => {});
+  const watchSpinner = spinner("Waiting for changes...").start();
+  let isBuilding = false;
+  let debounceTimer = null;
+  watch(sourceDir, { recursive: true }, (eventType, filename) => {
+    if (!filename || !filename.endsWith(".intent"))
+      return;
+    if (debounceTimer)
+      clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      if (isBuilding)
+        return;
+      isBuilding = true;
+      watchSpinner.stop();
+      console.log();
+      console.log(`${icons.info} ${dim("Change detected:")} ${filename}`);
+      try {
+        await buildCommand(options);
+      } catch (error2) {} finally {
+        isBuilding = false;
+        watchSpinner.start("Waiting for changes...");
+      }
+    }, 500);
+  });
+}
+
+// src/index.ts
+import { parse, parseToAST as parseToAST2 } from "@intend-it/parser";
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+var args = process.argv.slice(2);
+var cmd2 = args[0];
+if (!cmd2 || cmd2 === "--help" || cmd2 === "-h") {
+  printHelp();
+  process.exit(0);
+}
+switch (cmd2) {
+  case "init":
+    initCommand(args).catch(handleError);
+    break;
+  case "build":
+    handleBuild(args).catch(handleError);
+    break;
+  case "watch":
+    handleWatch(args).catch(handleError);
+    break;
+  case "parse":
+    handleParse(args).catch(handleError);
+    break;
+  default:
+    printError(`Unknown command: ${cmd2}`);
+    printHelp();
+    process.exit(1);
+}
+async function handleBuild(args2) {
+  const options = {};
+  for (let i = 1;i < args2.length; i++) {
+    if (args2[i] === "--output")
+      options.output = args2[i + 1];
+    if (args2[i] === "--config")
+      options.config = args2[i + 1];
+    if (args2[i] === "--api-key")
+      options.apiKey = args2[i + 1];
+    if (args2[i] === "--provider")
+      options.provider = args2[i + 1];
+    if (args2[i] === "--watch")
+      options.watch = true;
+    if (args2[i] === "--force")
+      options.force = true;
+    if (args2[i].startsWith("--attempts="))
+      options.attempts = parseInt(args2[i].split("=")[1]);
+  }
+  if (options.watch) {
+    await watchCommand(options);
+  } else {
+    await buildCommand(options);
+  }
+}
+async function handleWatch(args2) {
+  const options = { watch: true };
+  for (let i = 1;i < args2.length; i++) {
+    if (args2[i] === "--output")
+      options.output = args2[i + 1];
+    if (args2[i] === "--config")
+      options.config = args2[i + 1];
+    if (args2[i] === "--api-key")
+      options.apiKey = args2[i + 1];
+    if (args2[i] === "--provider")
+      options.provider = args2[i + 1];
+  }
+  await watchCommand(options);
+}
+async function handleParse(args2) {
+  if (args2.length < 2) {
+    printError("Missing file argument", "Usage: intend parse <file.intent> [--cst]");
+    process.exit(1);
+  }
+  const filePath = resolve5(process.cwd(), args2[1]);
+  const showCst = args2.includes("--cst");
+  if (!existsSync4(filePath)) {
+    printError(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  if (showCst) {
+    const result = parse(content);
+    if (result.lexingErrors.length > 0) {
+      printError("Lexing errors");
+      console.log(dim(JSON.stringify(result.lexingErrors, null, 2)));
+    } else if (result.parsingErrors.length > 0) {
+      printError("Parsing errors");
+      console.log(dim(JSON.stringify(result.parsingErrors, null, 2)));
+    } else {
+      console.log(JSON.stringify(result.cst, null, 2));
+    }
+  } else {
+    const result = parseToAST2(content);
+    console.log(JSON.stringify(result.ast, null, 2));
+  }
+}
+function handleError(err) {
+  printError(err.message || String(err));
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@intend-it/cli",
+  "version": "1.0.1",
+  "description": "CLI for the Intend programming language",
+  "type": "module",
+  "bin": {
+    "intend": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external picocolors --external ora --external @intend-it/parser --external @intend-it/core",
+    "clean": "rm -rf dist",
+    "dev": "bun run src/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DRFR0ST/intend.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "intend",
+    "cli",
+    "ai",
+    "compiler"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@intend-it/parser": "workspace:*",
+    "@intend-it/core": "workspace:*",
+    "picocolors": "^1.1.1",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}