@tolgamorf/env2op-cli 0.1.0 → 0.1.2

package/src/core/env-parser.ts

@@ -1,34 +1,34 @@
 import { existsSync, readFileSync } from "node:fs";
 import { errors } from "../utils/errors";
-import type { EnvVariable, ParseResult } from "./types";
+import type { EnvLine, EnvVariable, ParseResult } from "./types";
 
 /**
  * Parse a value from an environment variable line
  * Handles quoted strings and inline comments
  */
 function parseValue(raw: string): string {
-	const trimmed = raw.trim();
+    const trimmed = raw.trim();
 
-	// Handle double-quoted values
-	if (trimmed.startsWith('"')) {
-		const endQuote = trimmed.indexOf('"', 1);
-		if (endQuote !== -1) {
-			return trimmed.slice(1, endQuote);
-		}
-	}
+    // Handle double-quoted values
+    if (trimmed.startsWith('"')) {
+        const endQuote = trimmed.indexOf('"', 1);
+        if (endQuote !== -1) {
+            return trimmed.slice(1, endQuote);
+        }
+    }
 
-	// Handle single-quoted values
-	if (trimmed.startsWith("'")) {
-		const endQuote = trimmed.indexOf("'", 1);
-		if (endQuote !== -1) {
-			return trimmed.slice(1, endQuote);
-		}
-	}
+    // Handle single-quoted values
+    if (trimmed.startsWith("'")) {
+        const endQuote = trimmed.indexOf("'", 1);
+        if (endQuote !== -1) {
+            return trimmed.slice(1, endQuote);
+        }
+    }
 
-	// Handle unquoted values with potential inline comments
-	// Only treat # as comment if preceded by whitespace
-	const parts = trimmed.split(/\s+#/);
-	return (parts[0] ?? trimmed).trim();
+    // Handle unquoted values with potential inline comments
+    // Only treat # as comment if preceded by whitespace
+    const parts = trimmed.split(/\s+#/);
+    return (parts[0] ?? trimmed).trim();
 }
 
 /**
@@ -39,58 +39,62 @@ function parseValue(raw: string): string {
  * @throws Env2OpError if file not found
  */
 export function parseEnvFile(filePath: string): ParseResult {
-	if (!existsSync(filePath)) {
-		throw errors.envFileNotFound(filePath);
-	}
+    if (!existsSync(filePath)) {
+        throw errors.envFileNotFound(filePath);
+    }
 
-	const content = readFileSync(filePath, "utf-8");
-	const lines = content.split("\n");
-	const variables: EnvVariable[] = [];
-	const parseErrors: string[] = [];
-	let currentComment = "";
+    const content = readFileSync(filePath, "utf-8");
+    const rawLines = content.split("\n");
+    const variables: EnvVariable[] = [];
+    const lines: EnvLine[] = [];
+    const parseErrors: string[] = [];
+    let currentComment = "";
 
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i] ?? "";
-		const trimmed = line.trim();
-		const lineNumber = i + 1;
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i] ?? "";
+        const trimmed = line.trim();
+        const lineNumber = i + 1;
 
-		// Skip empty lines (reset comment)
-		if (!trimmed) {
-			currentComment = "";
-			continue;
-		}
+        // Empty lines
+        if (!trimmed) {
+            lines.push({ type: "empty" });
+            currentComment = "";
+            continue;
+        }
 
-		// Capture comments for next variable
-		if (trimmed.startsWith("#")) {
-			currentComment = trimmed.slice(1).trim();
-			continue;
-		}
+        // Comments (preserve original content including #)
+        if (trimmed.startsWith("#")) {
+            lines.push({ type: "comment", content: line });
+            currentComment = trimmed.slice(1).trim();
+            continue;
+        }
 
-		// Parse KEY=VALUE
-		// Key must start with letter or underscore, followed by letters, numbers, or underscores
-		const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+        // Parse KEY=VALUE
+        // Key must start with letter or underscore, followed by letters, numbers, or underscores
+        const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
 
-		if (match?.[1]) {
-			const key = match[1];
-			const rawValue = match[2] ?? "";
-			const value = parseValue(rawValue);
+        if (match?.[1]) {
+            const key = match[1];
+            const rawValue = match[2] ?? "";
+            const value = parseValue(rawValue);
 
-			variables.push({
-				key,
-				value,
-				comment: currentComment || undefined,
-				line: lineNumber,
-			});
+            variables.push({
+                key,
+                value,
+                comment: currentComment || undefined,
+                line: lineNumber,
+            });
 
-			currentComment = "";
-		} else if (trimmed.includes("=")) {
-			// Line has = but doesn't match valid key format
-			parseErrors.push(`Line ${lineNumber}: Invalid variable name`);
-		}
-		// Lines without = are silently ignored (could be malformed or intentional)
-	}
+            lines.push({ type: "variable", key, value });
+            currentComment = "";
+        } else if (trimmed.includes("=")) {
+            // Line has = but doesn't match valid key format
+            parseErrors.push(`Line ${lineNumber}: Invalid variable name`);
+        }
+        // Lines without = are silently ignored (could be malformed or intentional)
+    }
 
-	return { variables, errors: parseErrors };
+    return { variables, lines, errors: parseErrors };
 }
 
 /**
@@ -100,11 +104,8 @@ export function parseEnvFile(filePath: string): ParseResult {
  * @param filePath - Original file path for error message
  * @throws Env2OpError if no variables found
  */
-export function validateParseResult(
-	result: ParseResult,
-	filePath: string,
-): void {
-	if (result.variables.length === 0) {
-		throw errors.envFileEmpty(filePath);
-	}
+export function validateParseResult(result: ParseResult, filePath: string): void {
+    if (result.variables.length === 0) {
+        throw errors.envFileEmpty(filePath);
+    }
 }

package/src/core/onepassword.ts

@@ -6,114 +6,119 @@ import type { CreateItemOptions, CreateItemResult } from "./types";
  * Check if the 1Password CLI is installed
  */
 export async function checkOpCli(): Promise<boolean> {
-	try {
-		await $`op --version`.quiet();
-		return true;
-	} catch {
-		return false;
-	}
+    try {
+        await $`op --version`.quiet();
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 /**
  * Check if user is signed in to 1Password CLI
  */
 export async function checkSignedIn(): Promise<boolean> {
-	try {
-		await $`op account get`.quiet();
-		return true;
-	} catch {
-		return false;
-	}
+    try {
+        await $`op account get`.quiet();
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 /**
  * Check if an item exists in a vault
  */
-export async function itemExists(
-	vault: string,
-	title: string,
-): Promise<boolean> {
-	try {
-		await $`op item get ${title} --vault ${vault}`.quiet();
-		return true;
-	} catch {
-		return false;
-	}
+export async function itemExists(vault: string, title: string): Promise<boolean> {
+    try {
+        await $`op item get ${title} --vault ${vault}`.quiet();
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 /**
  * Delete an item from a vault
  */
 export async function deleteItem(vault: string, title: string): Promise<void> {
-	try {
-		await $`op item delete ${title} --vault ${vault}`.quiet();
-	} catch (error) {
-		// Item might not exist, that's fine
-	}
+    try {
+        await $`op item delete ${title} --vault ${vault}`.quiet();
+    } catch (_error) {
+        // Item might not exist, that's fine
+    }
 }
 
 /**
  * Create a Secure Note in 1Password with the given fields
  * Note: Caller should check for existing items and handle confirmation before calling this
  */
-export async function createSecureNote(
-	options: CreateItemOptions,
-): Promise<CreateItemResult> {
-	const { vault, title, fields, secret } = options;
+export async function createSecureNote(options: CreateItemOptions): Promise<CreateItemResult> {
+    const { vault, title, fields, secret } = options;
 
-	// Build field arguments
-	// Format: key[type]=value
-	const fieldType = secret ? "password" : "text";
-	const fieldArgs = fields.map(
-		({ key, value }) => `${key}[${fieldType}]=${value}`,
-	);
+    // Build field arguments
+    // Format: key[type]=value
+    const fieldType = secret ? "password" : "text";
+    const fieldArgs = fields.map(({ key, value }) => `${key}[${fieldType}]=${value}`);
 
-	try {
-		// Build the command arguments array
-		const args = [
-			"item",
-			"create",
-			"--category=Secure Note",
-			`--vault=${vault}`,
-			`--title=${title}`,
-			"--format=json",
-			...fieldArgs,
-		];
+    try {
+        // Build the command arguments array
+        const args = [
+            "item",
+            "create",
+            "--category=Secure Note",
+            `--vault=${vault}`,
+            `--title=${title}`,
+            "--format=json",
+            ...fieldArgs,
+        ];
 
-		// Execute op command
-		const result = await $`op ${args}`.json();
+        // Execute op command
+        const result = await $`op ${args}`.json();
 
-		return {
-			id: result.id,
-			title: result.title,
-			vault: result.vault?.name ?? vault,
-		};
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw errors.itemCreateFailed(message);
-	}
+        // Extract field IDs mapped by label
+        const fieldIds: Record<string, string> = {};
+        if (Array.isArray(result.fields)) {
+            for (const field of result.fields) {
+                if (field.label && field.id) {
+                    fieldIds[field.label] = field.id;
+                }
+            }
+        }
+
+        return {
+            id: result.id,
+            title: result.title,
+            vault: result.vault?.name ?? vault,
+            vaultId: result.vault?.id ?? "",
+            fieldIds,
+        };
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw errors.itemCreateFailed(message);
+    }
 }
 
 /**
  * Check if a vault exists
  */
 export async function vaultExists(vault: string): Promise<boolean> {
-	try {
-		await $`op vault get ${vault}`.quiet();
-		return true;
-	} catch {
-		return false;
-	}
+    try {
+        await $`op vault get ${vault}`.quiet();
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 /**
  * Create a new vault
  */
 export async function createVault(name: string): Promise<void> {
-	try {
-		await $`op vault create ${name}`.quiet();
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw errors.vaultCreateFailed(message);
-	}
+    try {
+        await $`op vault create ${name}`.quiet();
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw errors.vaultCreateFailed(message);
+    }
 }

package/src/core/template-generator.ts

@@ -1,4 +1,5 @@
 import { writeFileSync } from "node:fs";
+import pkg from "../../package.json";
 import type { TemplateOptions } from "./types";
 
 /**
@@ -10,51 +11,53 @@ import type { TemplateOptions } from "./types";
  * - `op inject -i template.tpl -o .env`
  * - `op run --env-file template.tpl -- command`
  */
-export function generateTemplateContent(options: TemplateOptions): string {
-	const { vault, itemTitle, variables } = options;
+export function generateTemplateContent(options: TemplateOptions, templateFileName: string): string {
+    const { vaultId, itemId, lines: envLines, fieldIds } = options;
 
-	const lines: string[] = [
-		"# Generated by env2op",
-		"# https://github.com/tolgamorf/env2op",
-		"#",
-		"# Usage:",
-		`#   op inject -i ${getTemplateName(options)} -o .env`,
-		`#   op run --env-file ${getTemplateName(options)} -- npm start`,
-		"",
-	];
+    const outputLines: string[] = [
+        `# Generated by env2op v${pkg.version}`,
+        "# https://github.com/tolgamorf/env2op-cli#README",
+        "#",
+        "# Usage:",
+        `#   op inject -i ${templateFileName} -o .env`,
+        `#   op run --env-file ${templateFileName} -- npm start`,
+        "",
+    ];
 
-	for (const { key, comment } of variables) {
-		if (comment) {
-			lines.push(`# ${comment}`);
-		}
-		lines.push(`${key}=op://${vault}/${itemTitle}/${key}`);
-	}
+    for (const line of envLines) {
+        switch (line.type) {
+            case "empty":
+                outputLines.push("");
+                break;
+            case "comment":
+                outputLines.push(line.content);
+                break;
+            case "variable": {
+                const fieldId = fieldIds[line.key] ?? line.key;
+                outputLines.push(`${line.key}=op://${vaultId}/${itemId}/${fieldId}`);
+                break;
+            }
+        }
+    }
 
-	return `${lines.join("\n")}\n`;
-}
-
-/**
- * Get the template filename based on the source file
- */
-function getTemplateName(options: TemplateOptions): string {
-	return `${options.itemTitle.toLowerCase().replace(/\s+/g, "-")}.tpl`;
+    return `${outputLines.join("\n")}\n`;
 }
 
 /**
  * Write template to file
  */
 export function writeTemplate(content: string, outputPath: string): void {
-	writeFileSync(outputPath, content, "utf-8");
+    writeFileSync(outputPath, content, "utf-8");
 }
 
 /**
  * Generate usage instructions for display
  */
 export function generateUsageInstructions(templatePath: string): string {
-	return [
-		"",
-		"Usage:",
-		`  op inject -i ${templatePath} -o .env`,
-		`  op run --env-file ${templatePath} -- npm start`,
-	].join("\n");
+    return [
+        "",
+        "Usage:",
+        `  op inject -i ${templatePath} -o .env`,
+        `  op run --env-file ${templatePath} -- npm start`,
+    ].join("\n");
 }

package/src/core/types.ts

@@ -2,78 +2,96 @@
  * Represents a single environment variable parsed from a .env file
  */
 export interface EnvVariable {
-	/** The variable name/key */
-	key: string;
-	/** The variable value */
-	value: string;
-	/** Optional comment from preceding line */
-	comment?: string;
-	/** Line number in source file */
-	line: number;
+    /** The variable name/key */
+    key: string;
+    /** The variable value */
+    value: string;
+    /** Optional comment from preceding line */
+    comment?: string;
+    /** Line number in source file */
+    line: number;
 }
 
+/**
+ * Represents a line in the .env file (preserves structure)
+ */
+export type EnvLine =
+    | { type: "comment"; content: string }
+    | { type: "empty" }
+    | { type: "variable"; key: string; value: string };
+
 /**
  * Result of parsing an .env file
  */
 export interface ParseResult {
-	/** Successfully parsed variables */
-	variables: EnvVariable[];
-	/** Any parse errors encountered */
-	errors: string[];
+    /** Successfully parsed variables */
+    variables: EnvVariable[];
+    /** All lines preserving structure */
+    lines: EnvLine[];
+    /** Any parse errors encountered */
+    errors: string[];
 }
 
 /**
  * Options for creating a 1Password Secure Note
  */
 export interface CreateItemOptions {
-	/** Vault name */
-	vault: string;
-	/** Item title */
-	title: string;
-	/** Fields to store */
-	fields: EnvVariable[];
-	/** Store as password type (hidden) instead of text (visible) */
-	secret: boolean;
+    /** Vault name */
+    vault: string;
+    /** Item title */
+    title: string;
+    /** Fields to store */
+    fields: EnvVariable[];
+    /** Store as password type (hidden) instead of text (visible) */
+    secret: boolean;
 }
 
 /**
  * Result of creating a 1Password item
  */
 export interface CreateItemResult {
-	/** 1Password item ID */
-	id: string;
-	/** Item title */
-	title: string;
-	/** Vault name */
-	vault: string;
+    /** 1Password item ID */
+    id: string;
+    /** Item title */
+    title: string;
+    /** Vault name */
+    vault: string;
+    /** Vault ID */
+    vaultId: string;
+    /** Field IDs mapped by field label */
+    fieldIds: Record<string, string>;
 }
 
 /**
  * Options for the convert command
  */
 export interface ConvertOptions {
-	/** Path to .env file */
-	envFile: string;
-	/** 1Password vault name */
-	vault: string;
-	/** Secure Note title */
-	itemName: string;
-	/** Preview mode - don't make changes */
-	dryRun: boolean;
-	/** Store all fields as password type */
-	secret: boolean;
-	/** Skip confirmation prompts (auto-accept) */
-	yes: boolean;
+    /** Path to .env file */
+    envFile: string;
+    /** 1Password vault name */
+    vault: string;
+    /** Secure Note title */
+    itemName: string;
+    /** Preview mode - don't make changes */
+    dryRun: boolean;
+    /** Store all fields as password type */
+    secret: boolean;
+    /** Skip confirmation prompts (auto-accept) */
+    yes: boolean;
 }
 
 /**
  * Options for template generation
  */
 export interface TemplateOptions {
-	/** Vault name */
-	vault: string;
-	/** Item title in 1Password */
-	itemTitle: string;
-	/** Variables to include */
-	variables: EnvVariable[];
+    /** Vault ID */
+    vaultId: string;
+    /** Item ID in 1Password */
+    itemId: string;
+    /** Variables to include */
+    variables: EnvVariable[];
+    /** All lines preserving structure */
+    lines: EnvLine[];
+    /** Field IDs mapped by field label */
+    fieldIds: Record<string, string>;
 }

package/src/index.ts

@@ -4,36 +4,34 @@
  * This module exports the core functionality for programmatic use.
  */
 
-// Core types
-export type {
-	EnvVariable,
-	ParseResult,
-	CreateItemOptions,
-	CreateItemResult,
-	ConvertOptions,
-	TemplateOptions,
-} from "./core/types";
-
 // Env parsing
 export { parseEnvFile, validateParseResult } from "./core/env-parser";
-
 // 1Password integration
 export {
-	checkOpCli,
-	checkSignedIn,
-	itemExists,
-	deleteItem,
-	createSecureNote,
-	vaultExists,
-	createVault,
+    checkOpCli,
+    checkSignedIn,
+    createSecureNote,
+    createVault,
+    deleteItem,
+    itemExists,
+    vaultExists,
 } from "./core/onepassword";
-
 // Template generation
 export {
-	generateTemplateContent,
-	writeTemplate,
-	generateUsageInstructions,
+    generateTemplateContent,
+    generateUsageInstructions,
+    writeTemplate,
 } from "./core/template-generator";
+// Core types
+export type {
+    ConvertOptions,
+    CreateItemOptions,
+    CreateItemResult,
+    EnvLine,
+    EnvVariable,
+    ParseResult,
+    TemplateOptions,
+} from "./core/types";
 
 // Errors
 export { Env2OpError, ErrorCodes, errors } from "./utils/errors";